Java构造方法（与类名相同的方法）、类方法、类变量、实例方法、实例变量

一、构造方法
- 1、构造方法的特点：
- 2、构造方法分类
- 3、构造方法的重载
- 4、构造方法中的 this
二、类方法、类变量、实例方法、实例变量
三、类方法（静态方法，用static修饰的方法）
- 四、类方法与实例方法的区别
- 五、继承和多态

一、构造方法

跟类名相同的方法名 被称作构造方法，其作用是用于当一个类被new成对象时，对象需要声明的一些变量的构造声明。

1、构造方法的特点：

（1）构造方法的名字必须与定义他的类名完全相同（甚至连void也没有），且没有返回类型；

（2）构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。

Person p = new Person();   : person() 调用的就是Person的构造方法。

（3）每个类可以有零个或多个构造方法；

（4）不能被static、final、synchronized、abstract和native修饰。且构造方法不能被子类继承。

（5）构造方法在创建对象时自动执行，一般不能显式地直接调用。

2、构造方法分类

（1）默认构造方法 ----老马 p59

// 无参构造方法
class Banana{public Banana() { System.out.println("无参的构造方法被调用,这里是香蕉"); }
}
public class text3 {public static void main(String[] args) {Banana s = new Banana();}
}

从代码和结果可以看出，“new Banana()” 除了实例化对象，还调用了构造方法Banana();

一旦定义了构造方法，Java就不会再自动生成默认构造方法。
如果只定义了第二个构造方法（带参数的），则下面语句：
Point p = new Point();
就会报错，因为找不到不带参数的构造方法。

（2）带参数的构造方法

// 有参构造方法
class Apple{int size;public Apple(int a) {System.out.println("有参的构造方法被调用,这里是苹果");size = a;}public void shuchu() { System.out.println("这个苹果有" + size + "这么大"); }
}
public class text3 {public static void main(String[] args) {Apple apple = new Apple(18);apple.shuchu();}
}

从代码和结果可以看到Apple(int a)这是一个有参的构造方法，在new Apple(18)实例化对象的同时，把参数传给a赋值给size并调用了shuchu()这个构造方法。

（3）私有构造方法：修饰符为 private
场景：
1）不能创建类的实例，类只能被静态访问，如Math、Arrays类，它们的构造方法就是私有的。
2）能创建类的实例，但只能被类的静态方法调用。单例场景。
3）只是用来被其他多个构造函数调用，用来减少重复代码。

3、构造方法的重载

/** 构造方法的重载*/
class Food{String name;int size;public Food(String b , int a) { // 构造函数name = b;size = a;}public Food(String b) {name = b;}public Food(int a) {size = a;}public void shuchu() {System.out.println("这个" + name +"有" + size + "这么大");}
}
public class text4 {public static void main(String[] args) {Food s = new Food("苹果");Food x = new Food("草莓",18);Food z = new Food(20);s.shuchu();x.shuchu();z.shuchu();}
}

4、构造方法中的 this

this的第1种用法：this 表示当前实例；

this的第2种用法：调用第2个构造方法；

new Point() 的时候：
（1）分配存放实际数据的内存；
（2）给实例变量设置默认值，new Point() 设置的默认值为0；
（3）调用构造方法（构造函数）；

public class Point() {private int x;private int y;public void setX(int x) {this.x = x;  // this.x为实例变量x（无static修饰，能够被实例继承）， 右侧的x为方法参数中的x}                // this的第一种用法：this表示当前实例public void setY(int y) {this.y = y;}public Point() {this(0, 0);  //this的第2种用法：调用第2个构造方法，并传递参数 "0,0"}public Point(int x, int y) {this.x = x;this.y = y;}
}

----《Java编程的逻辑》马俊昌 p59

二、类方法、类变量、实例方法、实例变量

（1）类方法：static修饰，静态方法，静态方法是没有this的方法。
（2）类变量：static修饰，静态变量。
（3）实例方法
（4）实例变量

与static相对应的是【实例变量】【实例方法】，没有static修饰符。

Arrays类就只有类方法。 ----《Java编程的逻辑》p54

三、类方法（静态方法，用static修饰的方法）

静态方法 是属于整个类的，所以静态方法 的方法体中，不能有与类的对象有关的内容（实例对象、实例方法 是属于类的对象）。即类方法体有如下限制：

静态方法只能访问静态变量，不能访问实例变量，可以调用其他的静态方法，不能调用实例方法。

注释：IDEA中调代码时，main方法就是静态方法，也只能访问静态方法、静态变量。

实例方法既能访问实例变量，也能访问静态变量，既可以调用实例方法，也可以调用静态方法。 ----《Java编程的逻辑》p55

规定：使用类名来调用静态方法，而不要使用实例或表达式来调用。 ----《Java核心技术卷I》p117、Java语言编程规范

静态方法 不能被覆盖（重写）；静态方法中不能使用super，this关键字；
实例方法中可以调用静态方法；实例方法中可以使用super，this关键字；

四、类方法与实例方法的区别

静态方法在加载类时就被分配了内存地址，因此加载后即可被任意对象调用，并且可以通过类名直接调用（类名.方法名）。
实例方法 需要在创建对象后才会被分配内存地址，所以实例方法不能通过类名调用。

五、继承和多态

（1）每一个类有且只有一个父类，没有声明父类的，其父类为Object。
（2）子类继承了父类非private的属性和方法，可以增加自己的属性和方法，以及重写父类的方法实现。
（3）在 new 的过程中，父类先进行初始化。
（4）

public class Base {public static String s = "static_base";public String m = "base";public static String s_static_base = "s_static_base";public String m_base = "m_base";public static void staticTest() {System.out.println("base static.");}public void notStaticTest() {System.out.println("base not static.");}public void notStaticTest_base() {System.out.println("base_not_static_base.");}private void privateTest() {System.out.println("base private.");}
}

package org.example;public class Child extends Base{public static String s = "static_child";public String m = "child";public static String s_static_child = "s_static_child";public String m_child = "m_child";public static void staticTest() {System.out.println("child static.");}public void notStaticTest() {System.out.println("child not static.");}public void notStaticTest_child() {System.out.println("base_not_static_child.");String s = m_base;}private void privateTest() {System.out.println("child private.");}
}

public class Test {public static void main(String[] args) {Child c = new Child();Base b = c;// 重名 静态绑定: 实例变量、静态变量、静态方法、private方法。// 重写：只用作实例方法（没有static修饰的方法, 属于实例对象的方法，实例对象可对其进行重写。)// "public VS private"System.out.println(b.s);  // static_baseSystem.out.println(b.m);  // baseSystem.out.println(c.s);  // static_childSystem.out.println(c.m);  // child// 实例变量、继承：子类中找不到，就调用父类变量、方法System.out.println(b.m_base);  // m_base（静态绑定）// System.out.println(b.m_child);      // error: Base 中找不到 m_child，不会到子类中去查找：显然不会到子类中去查找。System.out.println(c.m_child); // m_child（静态绑定）System.out.println(c.m_base);  // m_base// 子类中没有这个 实例变量，就到父类中寻找。// 静态变量System.out.println(b.s_static_base);  // s_static_base（静态绑定）// System.out.println(b.s_static_child);   // error: Base 中找不到 s_static_childSystem.out.println(c.s_static_child); // s_static_child（静态绑定）System.out.println(c.s_static_base);  // s_static_base// 子类中没有这个 静态变量，就到父类中寻找。// 静态方法b.staticTest();  // base static.（静态绑定）c.staticTest();  // child static.（静态绑定）// private方法: 只能在类中访问，不能在外部访问// b.privateTest();  // error// c.privateTest();  // error// 实例方法（属于实例对象的方法）：被重写（子类重写与父类相同参数签名的方法）b.notStaticTest();  // child not static.c.notStaticTest();  // child not static.// 实例方法：继承b.notStaticTest_base();// b.notStaticTest_child();  // error 找不到c.notStaticTest_child();c.notStaticTest_base();      // 子类中没有这个 实例方法，就到父类中寻找。// 子类继承父类非private的属性和方法（实例变量、实例方法、静态变量、静态方法）// 静态绑定执行后，在子类中找不到的属性、方法，就到父类中找；父类不能反过来。// 静态变量、静态方法一般通过类名访问、但是也可以通过类的对象访问。}
}