木道寻08

这个屌丝很懒，什么也没留下！

热门标签

详解类和对象

作者：木道寻08 | 2024-08-21 09:06:10

踩

类和对象

面向对象与面向过程

在本章开始前：先思考一下：

什么是面向对象？

看名字它是注重对象的。当解决一个问题的时候，面向对象会把事物抽象成对象的概念，就是说这个问题里面有哪些对象，然后给对象
赋一些属性和方法，然后让每个对象去执行自己的方法，问题得到解决。

换一个说法：面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来

补充：

Java是一门纯面向对象的语言(Object Oriented Program，继承OOP)，在面向

对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠象

之间的交互完成一件事情。用面向对象的思想来涉及程序，更符合人们对事物

的认知，对于大型程序的设计、扩展以及维护都非常友好

下面再来一个问题：

什么是面向过程？

从名字可以看出它是注重过程的。当解决一个问题的时候，面向过程会把事情拆分成：一个个函数和数据（用于方法的参数）。然后按照一定的顺序，执行

完这些方法（每个方法看作一个过程），等方法执行完了，事情就搞定了。

换一个说法：面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。

这里： C语言就是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

下面我们通过例子来区分一下啥是面下对象，啥是面向过程。

这里就来举一个例子：

洗衣机里面放有脏衣服，怎么洗干净？

面向过程的解决方法：

1、执行加洗衣粉方法；

2、执行加水方法；

3、执行洗衣服方法；

4、执行清洗方法；

5、执行烘干方法；

以上就是将解决这个问题的过程拆成一个个方法（是没有对象去调用的），通过一个个方法的执行来解决问题。

面向对象的解决方法：

1、我先弄出两个对象：“洗衣机”对象和“人”对象

2、针对对象“洗衣机”加入一些属性和方法：“洗衣服方法”“清洗方法”、“烘干方法”

3、针对对象“人”加入属性和方法：“加洗衣粉方法”、“加水方法”

4、然后执行

人.加洗衣粉

人.加水

洗衣机.洗衣服

洗衣机.清洗

洗衣机.烘干

解决同一个问题，面向对象编程就是先抽象出对象，然后用对象执行方法的方式解决问题。

例子二：打麻将例子你我他

面向过程：打麻将（你，我，他）

---------解决问题拆成一个动作，把数据丢进去

面向对象：我.打麻将（你，他） or 你.打麻将（我，他） or 他.打麻将(我，你)

---------解决问题抽象出对象，对象执行动作。

注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

知道了面向对象，那么对象从哪里来？

比如上面的洗衣服过程，洗衣机，人这两个对象从哪里来呢？

其实在 java 中对象是从类中创建出来的。

类就是一类对象的统称。对象就是这一类具体化的一个实例

那么下面我们就来学习一下类 .

类

简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实

体。一个模子可以实例化无数个对象。总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。声明一个类就是创建一个新的

数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类。

语法：

// 创建类
class ClassName{ 
  field;    // 字段(属性) 或者 成员变量
  method;    // 行为 或者 成员方法
}
1
2
3
4
5

这里：

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成属性或者类成员变量。

方法主要说明类具有哪些功能，称为类的成员方法。

class Person{
    
    public String name;
    public int age;

}
1
2
3
4
5
6

来看这里我们就通过 class 创建了一个类，注意: 类名一般采用大驼峰。

这里 name / age可以称为字段也可以称为属性，还可以称为成员变量 (普通成员变量)。
(在类中成员变量有两种：1.普通成员变量如上面 2. 被 s’tatic定义静态成员变量 )

Person 是人的意思，这里我们定义的 name 和 age 正好就是我们每个人拥有的属性。

同样我们定义的类中是可以添加方法的。


class Person {

  public String name;
  public int age;

  public void eat() {
      System.out.println(name + "大口吃饭");
  }

  public void sleep() {
      System.out.println(name + "正在睡觉");
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

下面我们就来练习一下：创建类，以我们更好的掌握

在这里插入图片描述

注意：这里静态方法还没讲到可以先不完成。

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 狗的行为 （方法）
    public void barks() {
        System.out.println(name + "汪汪叫");
    }

    public void wag() {
        System.out.println(name + "摇尾巴");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

小练习完成后我们来实例化我们的对象。

实例化对象

之前我们学习过 new 他的作用就是用来帮我们实例化对象的也可以说创建一个对象。

class Dog {
  //这里 名字 和 颜色 就是 我们 的 成员变量
  public String name; // 名字
  public String color; // 颜色

  // 狗的行为 （方法）
  public void barks() {
      System.out.println(name + "汪汪叫");
  }

  public void wag() {
      System.out.println(name + "摇尾巴");
  }
}

public class Main {

  public static void main(String[] args) {
      Dog dog = new Dog();
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这里我们就实例化出了一个 dog 对象。当然我们也是

可以实例化多个对象的(有了模具，想要多少个我们就能

new 多少个，这里要啥女朋友有这么简单就好了)。

下面继续：

class Dog {
  //这里 名字 和 颜色 就是 我们 的 成员变量
  public String name; // 名字
  public String color; // 颜色

  // 狗的行为 （方法）
  public void barks() {
      System.out.println(name + "汪汪叫");
  }

  public void wag() {
      System.out.println(name + "摇尾巴");
  }
}

public class Main {

  public static void main(String[] args) {
      Dog dog = new Dog();
      Dog dog2 = new Dog();
      Dog dog3 = new Dog();
      Dog dog4 = new Dog();
      Dog dog5 = new Dog();

  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

对象有了，我们就需要通过对象去访问类中的成员变量，这里我们就可以通过 .点号来访问我们的成员变量。

访问类的成员变量

语法：引用(由类定义的变量名). 成员变量名。

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 狗的行为 （方法）
    public void barks() {
        System.out.println(name + "汪汪叫");
    }

    public void wag() {
        System.out.println(name + "摇尾巴");
    }
}

public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.color = "粉色";
        dog.barks();
        dog.wag();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这里我们就成功访问了类中的成员变量

在这里插入图片描述

如果这里我们没有赋值呢？

这里就将 dog.name 和 dog.color 给注释掉来看一下

在这里插入图片描述

可以看到为变为了 null，这里如果我们没有给成员变量赋值，这里系统就会赋于默认值。

来看这张图 : 这里就是我们每个类型的默认值。

下面继续：

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 狗的行为 （方法）
    public void barks() {
        System.out.println(name + "汪汪叫");
    }

    public void wag() {
        System.out.println(name + "摇尾巴");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这里我们创建两个引用 dog1 和 dog2 来保存我们对象的地址。如：

在这里插入图片描述

类的静态成员变量

刚刚提到过被 static 修饰的变量为静态成员变量，这里就来具体展示一下。

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 静态成员变量
    public static int age;
    // 狗的行为 （方法）
    public void barks() {
        System.out.println(name + "汪汪叫");
    }

    public void wag() {
        System.out.println(name + "摇尾巴");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这里就通过 static 修饰了 age 这里的 age 就是静态成员变量

静态成员变量的两种访问方式

1.通过对象 :

在这里插入图片描述

但这种写法编译器会报警告，一般不建议这样写。

2.通过类名 :

在这里插入图片描述

静态成员变量能够通过类名来调用成员属性，那么我们的普通成员变量能不能呢？

在这里插入图片描述

通过我们的尝试发现他是不可以调用的，这里是为什么呢？？

这里就与之前提过一嘴的方法区有关。

在这里插入图片描述

这里我们的静态成员变量是属于类的，不是属于对象的，通过对象虽然可以访问到静态成员变量，但编译器会包警告，这里我们就需要通过方法二来调用我们的静态成员变量。

下面我们来做一道题来更深刻的理解一下静态成员变量。

 public class HasStatic {// 1
	private static int x = 100;// 2
	public static void main(String args[]) {// 3
		HasStatic hsl = new HasStatic();// 4
		hsl.x++;// 5
		HasStatic hs2 = new HasStatic();// 6
		hs2.x++;// 7
		hsl = new HasStatic();// 8
		hsl.x++;// 9
		HasStatic.x--;// 10
		System.out.println(" x=" + x);// 11
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

想一想这里的最终输出多少，

在这里插入图片描述

静态成员变量你会了，那么静态成员方法也是同理：

这里只举例 类名 . 方法名

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 静态成员变量
    public static int age;
    // 狗的行为 （方法）
    public void barks() {
        System.out.println(name + "汪汪叫");
    }

    public void wag() {
        System.out.println(name + "摇尾巴");
    }
    public static void Jump(){
        System.out.println("正在跳");
    }

}

public class Main {

    public static void main(String[] args) {
        Dog.age = 10;
        System.out.println(Dog.age);
        Dog.Jump();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

下面就来看一下这道题：

package NowCoder;
class Test {
	public static void hello() {
	    System.out.println("hello");
	}
}
public class MyApplication {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test test=null;
		test.hello();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

这里能不能将 heelo 打印出来呢？

答案：这里是可以将 hello 打印出来的，还记的我们静态成员变量是放在方法区的吗，这里 static 修饰的是方法其实也是一样的，同样是放在方法区的。

hello方法是一个静态方法，调用静态方法不需要创建实例对象。

此时的 Test test=null; 表示test这个引用不指向任何对象。所以此处可以正常访问。

但是我们需要牢记，静态方法的正确访问方式应该是用过类型来访问。即：Test.hello();

另外：在静态成员变量中我们需要注意一些事项

如：

1.普通方法中定义静态成员变量

这里还是拿 Dog 这个类举例，我们创建一个 fun方法，在 fun方法中创建一个静态成员变量 size.


class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 静态成员变量
    public static int age;
    // 狗的行为 （方法）
    public void barks() {
        System.out.println(name + "汪汪叫");
    }

    public void wag() {
        System.out.println(name + "摇尾巴");
    }
    public static void Jump(){
        System.out.println("正在跳");
    }
    
    //注意:  
    public void fun(){
        public static int size = 10;
    }

}

public class Main {

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在这里插入图片描述

可以发现这里报错了，其实很容易理解。

1.被static 修饰的是属于类的，这样定义就不是属于类属于方法了

2.假设能定义 fun方法的调用需要对象的引用来调用如果可以定义static 的变量，这个变量不需要对象通过类名 Person 就可以调用

2.静态成员方法调定义静态成员变量

那么我们在一个静态的方法中定义一个静态的变量呢？

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 静态成员变量
    public static int age;

    public static void Jump(){
        System.out.println("正在跳");
    }
    
    public static void func(){
        public static int size = 10;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这里插入图片描述

这里虽然不需要对象了但是被static 修饰的是属于类的，这样定义就不是属于类属于方法了

这里不能在方法中创建静态成员变量，那么我们调用方法总可以了吧，下面我们就来看一下。

3普通方法调用静态方法

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 静态成员变量
    public static int age;
    // 狗的行为 （方法）
  
    public static void func(){
        System.out.println("测试 的 静态 方法");
    }
    public void func2(){
        func();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这里插入图片描述

可以看到我们在普通成员方法中调用静态成员方法编译器没有报错，其实也不难想。

普通方法需要对象，静态方法不需要对象，方法两部分不干扰，所以可以调用如果在静态方法中调用普通呢？

如：旅游，有对象的（普通成员方法）是不是都会带自己的女朋友去，如果自己一个人偷偷去，回来不得被女朋友提分手，而一个单身狗（静态成员方法）是不是可以带人（有好感的妹子）去，或者一个人去这都是可以的。

同理这里普通成员方法都能调用静态方法，那么在静态方法中调用静态方法同样也是可以的。

在这里插入图片描述

普通方法能够调用静态方法，那么我们静态方法能不能调用一个普通方法呢？？？

4.静态方法调用普通方法

class Dog {
    //这里 名字 和 颜色 就是 我们 的 成员变量
    public String name; // 名字
    public String color; // 颜色

    // 静态成员变量
    public static int age;

    public static void func1(){
        func2();
        System.out.println("func1 :: 测试");
    }
    public void func2(){
        System.out.println("func2 :: 测试");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这里插入图片描述

可以发现这里报错了，为什么呢？

想一想其实非常简单，我们知道静态方法是不需要对象的，而普通方法是需要对象将一个需要对象的放进一个没有对象的那肯定会发生错误的。

举例：还是拿旅游举例，一个没有对象的人叫一个有对象的人去旅游，但是有一个条件不能带女朋友，（我自己都没

有，不能让你带来让我吃狗粮）如果这个人去了那么旅游回来，女朋友百分之百会提出分手（旅游都不带我，你肯定是不爱

我），这时肯定是不能去的吗（相比一个人旅游还不如和女朋友在一起）。

那么这不就一个道理，在没有对象的方法中调用需要对象的方法拿肯定是不行的。

如果非要在静态方法中调用不同方法其实也非常简单，这里还是旅游举例，这里就直接拉上对象不就可以了吗。

代码这样写：

在这里插入图片描述

静态方法中没有对象我们创建一个对象来使用。

这里普通成员变量和静态成员变量就讲完了，下面来画个图形象的体现一下两者之间的关系。

这里补充：

在类中定义的变量是可以被 fine 修饰的

class Student{
    public final int SIZE = 10;
    public static final int SIZE2 = 20;
}
1
2
3
4

final修饰的叫常量，也属于对象。被final 修饰，后续不可更改同样 final 也是可以修饰静态变量为静态的常量，属于类本身，只有一份被final修饰，后续不可更该另外一个变量存放在哪里和你是否被fine修改无关

注意：常量一般使用大写

看完静态成员变量下面我们来学习一下构造方法，

构造方法

1.初始化对象

通过前面知识点的学习知道，在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败

public static void main(String[] args) {
  int a;
  System.out.println(a);
}
// Error:(26, 28) java: 可能尚未初始化变量a
1
2
3
4
5

在这里插入图片描述

要让上述代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象：

在这里插入图片描述

那么如何初始化对象呢？

class Dog {
    public String name;
    public int age;    
}


public class Main {


    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.age = 10;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可以看到我们这里成员变量就 2 个初始化直接通过 dog. 即可，如果成员变量一多是不是就不太方便，那么对象要如何初始化呢？

这里在来一个问题：局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

怀着这两个问题来看一下我们的构造方法。

构造方法

概念：构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

另外：在对对象产生(对象实例化/ new 的执行过程 ) 会有两个步骤。

1.为对象分配内存空间

2.调用合适的构造方法 (一个类中可以拥有多个构造方法，如：不带参数带参数（这个参数又会有个数区别）这里就构成了重载)

当这 2 个步骤走完才会真正的创建对象。

下面就来演示一下：

class Dog {
    public String name;
    public int age;
    
    public Dog(){
        System.out.println("不带参数的 构造方法");
    }
    public Dog(String name){
        this.name = name;
        System.out.println("带有 一个 参数的构造 方法");
    }
    public Dog(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带有 两个 参数的 构造 方法");
    }

}
public class Main {


    public static void main(String[] args) {
        Dog dog1 = new Dog();
        Dog dog2 = new Dog("旺财");
        Dog dog3 = new Dog("小黑", 14);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这里插入图片描述

可以看到我们就创建出 3 个构造方法。这里的构造方法也是可以被 private 修饰的，此时其他的类就无法通过 new 这个构成方法来创建对象。

另外：当然构造方法所处类的内部是可以被调用的，因为 private 就是将所修饰部分私有化，只有内部才能使用。外者不能使用既然构造方法可以私有化，肯定由它的作用：实现单例模式的大前提，现在不讲，还不会

这里大家会不会有一个疑问？为啥一开始没写构造方法不是一样创建出对象。

其实如果我们没有写构造方法，我们的编译器会默认创建一个不带参数的构造方法。

class Dog {
    public String name;
    public int age;

//    public Dog() {
//        System.out.println("不带参数的 构造方法");
//    }
//
//    public Dog(String name) {
//        this.name = name;
//        System.out.println("带有 一个 参数的构造 方法");
//    }
//
//    public Dog(String name, int age) {
//        this.name = name;
//        this.age = age;
//        System.out.println("带有 两个 参数的 构造 方法");
//    }

}

public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

这里就先将我们创建的构造方法屏蔽掉我们执行下看看。

在这里插入图片描述

这里就是成功执行了程序。

注意：如果我们在类中写了构造方法，编译器就不会会默认提供不带参数的构造方法了。

还是这个代码：我们将不带参数的构造方法注释掉

class Dog {
    public String name;
    public int age;

//    public Dog() {
//        System.out.println("不带参数的 构造方法");
//    }

    public Dog(String name) {
        this.name = name;
        System.out.println("带有 一个 参数的构造 方法");
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带有 两个 参数的 构造 方法");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这里插入图片描述

可以看到报错了。

另外：构造方法支持重载. 规则和普通方法的重载一致构造方法重载规则：类名相同，参数的类型和个数，两者中，至少有一个不同项。调用构造方法时，编译器会自动筛选调用合适的构造方法

构成方法了解完我们来了解一下 this

this

关于 this 我们有三种用法，这里就先罗列出来

1.this.data 调用当前的对象的属性/字段/成员变量

2.this.func() 调用当前的对象的方法

3.this()调用当前对象的其他构造方法

1.this.data

1.this.data 调用当前的对象的属性/字段/成员变量

这个 this.data 是用来解决形参名不小心与成员变量名相同的问题。

先来看一下同名不适用 this 的情况

class Dog {
    public String name;
    public int age;

    public Dog() {
        System.out.println("不带参数的 构造方法");
    }

    public Dog(String name) {
        this.name = name;
        System.out.println("带有 一个 参数的构造 方法");
    }

    public Dog(String name, int age) {
        name = name;
         age = age;
        System.out.println("带有 两个 参数的 构造 方法");
    }

    public void sleep() {

        System.out.println(age + "岁的 小狗");
        System.out.println(name + "正在睡觉");
    }

}

public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog("小黑",4);
        dog.sleep();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

这里就通过带有两个参数的构造方法，对 age 和那么赋值，然后条用 sleep() 方法，来看赋值情况

在这里插入图片描述

这里看到我们的 age 为 0 ，name 为 null ，这里是为什么呢？？？

其实这里有点与 c 中的局部变量优先一样，

这里传入的形参名 age 和 name 与赋值的名字相同，编译器，并不知情，会按照局部变量优先，此时就会出现 自己赋值给自己的情况 ，

这里就可以使用我们的 this 来指定当前变量是这个类中的。

   public Dog(String name, int age) {
        this.name = name;
         this.age = age;
        System.out.println("带有 两个 参数的 构造 方法");
    }

    public void sleep() {

        System.out.println(age + "岁的 小狗");
        System.out.println(name + "正在睡觉");
    }
1
2
3
4
5
6
7
8
9
10
11

在这里插入图片描述

第一种用法看完我们来看第二种

2.this.func()

2.this.func() 调用当前的对象的方法

class Dog {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name + "开心的 吃");
    }

    public void sleep(String name) {
        this.name = name;
        this.eat();
        System.out.println(name + "正在睡觉");
    }
}

public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sleep("小黑");
    }    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这里插入图片描述

这里就通过`` this.方法名 ` 调用了 eat 方法。

3.this()

3.this()调用当前对象的其他构造方法

注意：这里 this() , 括号内是可以带参数的参数类型与参数个数决定所调用的构造方法，另外这里 this() 只能使用在构造方法当中，而且只能在第一行。

下面演示：


class Dog {
    public String name;
    public int age;

    public Dog() {
        // 调用 带有 两个 参数  的 构造 方法
        this("小黑", 15);
        System.out.println("不带参数的 构造方法");
    }

    public Dog(String name) {
        // 调用 不带参数的 构造 方法
        this();
        this.name = name;
        System.out.println("带有 一个 参数的构造 方法");
    }

    public Dog(String name, int age) {
        this.name = name;
         this.age = age;
        System.out.println("带有 两个 参数的 构造 方法");
    }

    public void sleep() {

        System.out.println(age + "岁的 小狗");
        System.out.println(name + "正在睡觉");
    }
}
public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

在这里插入图片描述

另外：

在这里插入图片描述

这样使用 this.() 是不可以的，进入不带参数的构造方法，然后通过``this.(“小黑”) 进入带有一个参数的构造方法，然后又通过this.()`

绕回来了，这里就会死循环，显然是不可以的，这里我们的编译器，就比较智能直接报错了。

下面就进入到本文的最后一讲代码块。

代码块

概念：

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块(本地代码块)

构造块(实例代码块)

静态块 (静态代码块)

同步代码块（后续讲解多线程部分再谈）

这里主要讲实例代码块和静态代码块

1.本地代码块

public class Main {

    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10;
            System.out.println("x1 = " + x);
        }
        int x = 100;
        System.out.println("x2 = " + x);
    }
}
1
2
3
4
5
6
7
8
9
10
11

执行结果为 10 和 100.

这种代码块用的比较少，下面就来看我们的实例代码块

2.实例代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Dog {
    public String name;
    public int age;

// 这里 就是 实例 代码块
    {
        name = "小黑";
        age = 20;
    }

    public void eat() {
        System.out.println(name + "大口的吃");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在这里插入图片描述

这里就通过实例代码块初始化了实例成员变量。

3.静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

class Dog {
    // 姓名
    public String name;
    // 年龄
    public int age;
    // 颜色
    public static  String color;
    // 性格
    public static String character;

    实例代码 块
    {
        this.name = "小黑";
        this.age = 20;
    }

    静态 代码 块
    static {
        color = "粉色";
        character = "乖巧";
    }
    public void eat() {
        System.out.println(name + "大口的吃");
    }
    public void fun(){
        System.out.println(name + " 真是 " + character + "的 狗 "+ "颜色 是" + color);
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.fun();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

最终我们的结果：

在这里插入图片描述

最后我们来看一下实例代码块和静态代码块的区别

实例代码块 or 静态代码块

下面就来看代码分析：

class Dog {
    private String name;
    public int age;

    public void func(){
        System.out.println("这是  测试 方法");
    }

    {
        System.out.println("小灰灰");
    }

    static {
        System.out.println("红 太郎 ");
    }

    static {
        System.out.println("灰太狼");
    }
}

public class Main{
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.func();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

想一想这里我们会输出什么：

在这里插入图片描述

可以看到我们会先输出静态代码块里的内容然后是实例代码块，最后是我们的方法。

通过上面我们能总结出一种规律（这里只给出了一组测试用例，如果你多尝试几次也是这样的）

结论: 当一个类中既有静态代码块和实例代码块，和方法时，会先调用静态代码块，然后是实例代码块，最后是方法


class Dog {
    private String name;
    public int age;

    public void func(){
        System.out.println("这是  测试 方法");
    }

    {
        System.out.println("小灰灰");
    }

    static {
        System.out.println("红 太郎 ");
    }

    static {
        System.out.println("灰太狼");
    }
}

public class Main{
    public static void main(String[] args) {
        Dog dog = new Dog();
//        dog.func();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

这里我们讲调用的方法注释掉，来看一下结果。

在这里插入图片描述

可以看到还是我们的静态代码块先执行，然后是实例，这里没有通过对象调用 fun 方法，所以 fun 没有生效。

另外：静态代码块只能执行一次

class Dog {
    private String name;
    public int age;

    public void func(){
        System.out.println("这是  测试 方法");
    }

    {
        System.out.println("小灰灰");
    }

    static {
        System.out.println("红 太郎 ");
    }

    static {
        System.out.println("灰太狼");
    }
}

public class Main{
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.func();
        Dog dog2 =new Dog();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在这里插入图片描述

来看我们再 new 了一个对象时，这里静态代码块中的红太郎和灰太狼就没有了。

总结：

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行

最后我们再来思考一个问题静态代码块，和静态成员变量是那个先执行呢？？

下面我们就来通过代码来看一下。

class Dog {
    private String name;
    public int age;

    public static int count = 10;
    
    count 
    public void func(){
        System.out.println("这是  测试 方法");
    }

    {
        System.out.println("小灰灰");
    }

    static {
        count = 20;
        System.out.println("红 太郎 ");
    }

    static {
        System.out.println("灰太狼");
    }
}

public class Main{

    public static void main(String[] args) {
        System.out.println(Dog.count);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

想一下这里的 count 输出多少。

在这里插入图片描述

这里我们直接通过类名调用 count 发现 count 等于 10 ，可以发现这里是先执行了 public static int count = 10;再执行了静态代码块中的

count = 20；

那么我们调换一下位置再来看一下。

class Dog {
    private String name;
    public int age;

   
    
    public void func(){
        System.out.println("这是  测试 方法");
    }

    {
        System.out.println("小灰灰");
    }

    static {
        count = 20;
        System.out.println("红 太郎 ");
    }

    static {
        System.out.println("灰太狼");
    }
    public static int count = 10;
}

public class Main{

    public static void main(String[] args) {
        System.out.println(Dog.count);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

此时 count 又等于多少呢？？

在这里插入图片描述

可以发现等于 10 这里是先执行了代码块，再执行了 public static int count = 10;

那么这里可以得出结论，静态代码块与静态成员变量的执行顺序与写的顺序有关，谁在前面谁先执行，注意这里静态代码块之间这时这样的。

最后来看一道题目：请问下面 cut 等于几？？

public class Test{
    static int cnt = 6;
    static{
        cnt += 9;
    }
    public static void main(String[] args）{
        System.out.println（"cnt = " + cnt);
    }
    static{
        cnt /=3;
    };
}
1
2
3
4
5
6
7
8
9
10
11
12

按照上面总结的我们很容易得出答案，如先执行 cnt = 6，然后再执行 cnt += 9 最后再执行 cnt /= 3; 答案就为 5。

你写对了吗？？

本文就到此为止。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】

详解 类和对象

文章目录

类和对象

面向 对象与面向 过程

类

实例化对象

访问 类的成员变量

类 的静态成员变量

静态成员变量的 两种访问方式

1.普通方法中 定义 静态成员变量

2.静态成员方法 调定义 静态成员 变量

3普通方法 调用静态 方法

4.静态方法调用 普通方法

构造方法

1.初始化 对象

this

1.this.data

2.this.func()

3.this()

代码块

1.本地 代码块

2.实例代码块

3.静态代码块

实例代码块 or 静态 代码块

详解类和对象

面向对象与面向过程

访问类的成员变量

类的静态成员变量

静态成员变量的两种访问方式

1.普通方法中定义静态成员变量

2.静态成员方法调定义静态成员变量

3普通方法调用静态方法

4.静态方法调用普通方法

1.初始化对象

1.本地代码块

实例代码块 or 静态代码块