跟类名相同的方法名 被称作构造方法，其作用是用于当一个类被new成对象时，对象需要声明的一些变量的构造声明。（1）构造方法的名字必须与定义他的类名完全相同（甚至连void也没有），且没有返回类型；
（2）构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。
Person p = new Person(); : person() 调用的就是Person的构造方法。
（3）每个类可以有零个或多个构造方法；
（4）不能被static、final、synchronized、abstract和native修饰。且构造方法不能被子类继承。
（5）构造方法在创建对象时自动执行，一般不能显式地直接调用。
（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）只是用来被其他多个构造函数调用，用来减少重复代码。
/*
* 构造方法的重载
*/
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();
}
}
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
静态方法 是属于整个类的，所以静态方法 的方法体中，不能有 与类的对象有关的内容（实例对象、实例方法 是属于类的对象）。即类方法体有如下限制：
静态方法只能访问静态变量，不能访问实例变量，可以调用其他的静态方法，不能调用实例方法。注释：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_base
System.out.println(b.m); // base
System.out.println(c.s); // static_child
System.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_child
System.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的属性和方法（实例变量、实例方法、静态变量、静态方法）
// 静态绑定执行后，在子类中找不到的属性、方法，就到父类中找；父类不能反过来。
// 静态变量、静态方法一般通过类名访问、但是也可以通过类的对象访问。
}
}