构造方法

1.1 成员变量的使用

public class Test1_UseExtends {
    public static void main(String[] args) {
       // 创建子类对象测试
       Erzi z = new Erzi();
//     z.eat();
       z.study();
    }
}

//创建父类
class Baba{
    int sum = 0;
    int count = 20;    
    public void eat() {
       int count = 10;
       System.out.println(count); // 10 
      

	 //现在成员变量和局部变量同名啦，想使用成员变量要用this关键字
       System.out.println(this.count); //  20 
       
       System.out.println(sum); //0
    }
}

//创建子类
class Erzi extends  Baba{
    public void study() {
	      //在子类中想要使用父类的成员变量count
		  //super就相当于在底层帮你创建了父类对象，super代表了父类对象的一个引用
	       //Baba super = new Baba();
	       System.out.println( super.count ); //20
    }
}

---

1.2 成员方法的使用

• 继承方法，特有方法，重写方法

public class Test2_UseExtends2 {
    public static void main(String[] args) {
       //创建子类对象测试
       Zi zi = new Zi();
       zi.eat();//如果没有发生方法重写，使用的是父类的实现方式；如果发生了方法重写，使用的是子类的实现方式。
       zi.study();//使用子类的特有方法
    } 
}
//创建父类

class Fu{
    public void eat() {
       System.out.println("爸爸在吃肉肉");
    }
}

//创建子类
class Zi extends Fu{
    //子类继承父类后，想要  修改  父类的原有功能  ---  方法的重写现象  -- 尽量不修改源码
    //重写的要求：发生继承关系   +  要修改原有业务   +  在子类中的方法声明和父类一模一样
    //子类在进行重写时，必须有足够的权限(子类权限>=父类权限)
    public void eat() {

	//super.eat();  
	//重写真的没有影响父类的原有功能吗？--- 没有影响
	       System.out.println("儿子在喝汤");
    }
    
    //提供特有方法
    public void study() {
       System.out.println("儿子在学习");
    }
}

---

1.3 构造方法的使用

• 子类创建对象时，默认会去访问父类的无参构造方法
• 在子类构造方法的第一行，都有一条默认的语句：super();this()
• 父类没有无参构造时，可以用super调用父类的其他构造

public class Test3_UseExtends3 {

    public static void main(String[] args) {
       //创建子类对象测试
       Zi2 z= new Zi2();//干了两件事：先执行父类的无参构造，再执行子类的构造
    }
}

//创建父类
class Fu2{ 
    //当父类没有无参构造时(只提供了含参构造时)，子类还能创建对象吗？ ---
    public Fu2(int a) {
       System.out.println("Fu2()..."+a);
    }
}

//创建子类
class Zi2 extends Fu2{
    public Zi2() {
		//super();
		 //在子类的构造方法中，默认会存在super()，会自动去找父类的无参构造
       //当父类没有无参构造时(只提供了含参构造时)，子类创建对象时无法使用super()，怎么办？ ---可以调用父类的含参构造
       //super关键字使用在 构造方法中 ，位置上必须是第一条语句，类似于this
       super(10);
       System.out.println("Zi2()...");
    }
    //父类构造方法能继承吗？  --  不能
	//  public Fu2() {    System.out.println("Fu2()...");   }
}

---

2 static

• 是java中的一个关键字
• 用于修饰成员（成员变量和成员方法）

特点：

随着类的加载而加载；
只加载一次，就会一直存在，直到类消失就一起消失了；
优先于对象加载；
被所有对象所共享；
可以直接被类名调用；

静态代码块、构造代码块、局部代码块：

静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化。
构造代码块：在创建对象时会自动调用，每次创建对象都会被调用。
局部代码块：方法里的代码块。

---

3 final

概念：
1、 是java提供的一个关键字
2、 final是最终的意思
3、 final可以修饰类，方法，成员变量

• 初衷是因为：java出现了继承后，子类可以更改父类的功能，当父类功能不许子类改变时可以利用final关键字修饰父类。

特点：
1、 被final修饰的类，不能被继承
2、 被final修饰的方法，不能被重写
3、 被final修饰的变量是个常量，值不能被改变
4、 常量的定义形式：final 数据类型 常量名 = 值

---

4 多态

概念：

1、多态指同一个实体同时具有多种形式。 它是面向对象程序设计（OOP）的一个重要特征。
2、主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
3、好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

特点：

1、 多态的前提1是继承
2、 多态的前提2是要有方法的重写
3、 父类引用指向子类对象,如：Animal a = newDog(); – 小到大，向上转型
4、 多态中，编译看左边，运行看右边

public class Test8_ManyTai {
    public static void main(String[] args) {
       //创建子类对象测试
       Dog d = new Dog();
       d.eat();//狗吃s，执行的是子类的功能呢还是父类的功能呢？-- 重写后的子类的功能       
       //创建多态对象测试
       Animal a = new Dog();//口诀1：父类引用  指向 子类对象--多态
       //口诀2：编译看左边，运行看右边
       //编译看左边：  是指  想要保存成功，只能调用左边也就是父类提供的功能
       //运行看右边：  是指  程序的运行结果  要使用右边也就是 子类 的实现方式
       a.eat();//狗吃s
    }
}

//创建父类
class Animal{
    public void eat() {
       System.out.println("吃啥都行");
    }
}

//创建子类
//多态前提：继承 +  重写
class Dog extends Animal{
    //重写：方法声明一样但是方法体不一样
    public void eat() {
       System.out.println("狗吃s");
    }
}