网站服务器维护价格数字营销策划
本章跟上一节性质类似，比较繁，需要自己手动多多复盘和总结
一、啥是继承？
1、继承的定义
主要意思就是对代码进行共性抽取来实现代码复用
public class java0608 {static String name ="dog";static int age = 5;static void bark(){System.out.println("汪汪");}}public class java0607 extends java0608 {static int a = 1;public static void main(String[] args) {System.out.println(name);java0608.bark();}
}这两段代码就是一个典型的继承，通过子类+extends+父类的形式得到了父类的变量和方法
注意：子类要有不同于父类的成员，否则就没必要继承了
2、子类与父类成员变量同名
在访问成员变量时以子类变量优先，假如恰好子类变量和父类变量同名，要访问父类的变量则需要在前面加上super用以区分
简单概括一下就是：子类没有父类找，父类没有就报错
这里我分成三段代码便于阅读：
public class java0608 {public int a = 9;public int b = 3;public int c = 5;
}public class java0607 extends java0608 {public int a = 1;public void test(){System.out.println(super.a);System.out.println(this.b);System.out.println(c);}
}public class java060702 {public static void main(String[] args) {java0607 t =new java0607();t.test();}
}3、子类方法与父类同名
这个跟上面也是同理，这里需要特别注意的是：
一旦父类与子类方法同名，也就构成了我们常见的重载，这个时候就有了两种匹配情况：
1、根据你所调用方法后面括号里传入的参数来给你匹配合适的方法
2、参数个数都一样就仍然是子类优先
public class java0608 {public int a = 9;public int b = 3;public int c = 5;public void method(){System.out.println("调用了父类的方法");
}
public class java0607 extends java0608 {public int a = 1;public void test(){System.out.println(super.a);System.out.println(this.b);System.out.println(c);super.method();}public void method(){System.out.println("调用了子类的方法");}
}其实到这里我们是不是就发现super跟this有点像？
对，我把它俩列举出来：
this.data访问当前类的成员变量 super.data访问父类的成员变量
this.fun()访问当前类的成员方法 super.fun()访问父类的成员方法
this() 访问当前类的构造方法 f super() 访问???(引出下文)
所以它们都是只能在非静态方法中使用，且只能在第一行，并且他俩不能同时出现
二、super访问构造方法
当在子类中使用构造方法来初始化变量时，我们往往会在他完成构造之前先帮助父类对其中的成员进行初始化
举个例子：
public class java0608 {
//
public java0608(){System.out.println("调用了父类的构造方法");
}public class java0607 extends java0608 {public java0607(){
// super(); 当⽗类的构造⽅法是不带参数的构造⽅法且只有这⼀个的情况下，默认会添加⼀个super();System.out.println("调用了子类的构造方法");}public class java0609 {public static void main(String[] args) {java0607 t =new java0607();
// t.test();
}
}这个运行的结果就是先父类后子类的形式
三、代码块的访问顺序
public class java0607 extends java0608 {static {System.out.println("访问了子类的静态代码块1");}{System.out.println("访问了子类的实例代码块2");}public java0607(String name,int age){super(name,age); //当⽗类的构造⽅法是不带参数的构造⽅法且只有这⼀个的情况下，默认会添加⼀个super();System.out.println("访问了子类的构造代码块3");}public class java0608 {static {System.out.println("访问了父类的静态代码块4");}{System.out.println("访问了父类的实例代码块5");}
public java0608(String name,int age){System.out.println("调用了父类的构造方法6");
}
public class java0609 {public static void main(String[] args) {java0607 t =new java0607("张三",18);
// t.test();}
}程序运行完以后我们会发现是415623
也就是秉持静态总体最优先，父类总体优先的规则
实例化第二个对象以后我们也会发现是静态没有第二次调用，与之前很类似
四、protected关键字
package bit.pack;public class demo3protected{protected int a = 8;
}
package bit;
import bit.pack.demo3protected;
public class demo4protected extends demo3protected{public void test() { //方式一:调用方法来访问protected变量System.out.println(super.a); //不能在静态方法中访问非静态成员，main方法就加了static}public static void main(String[] args) {demo4protected t = new demo4protected();System.out.println(t.a); //方式二:实例化子类对象来访问protected变量}
}这里展示的就是不同包底下的子类访问方式
五、多态
1、两种绑定类型
先一口气定义一个包下三个不同的类，方便展示：
package bit.pack;public class Animal {public int age;public String name;public Animal(int age, String name) {this.age = age;this.name = name;}public void eat(){System.out.println(this.name+"正在吃饭");}
}
package bit.pack;public class Dog2 extends Animal{public Dog2(int age,String name){super(age, name);this.age = age;}public void eat(){System.out.println(this.name+"正在吃狗粮");}public void bark(){System.out.println(this.name+"正在汪汪叫");}}package bit.pack;public class Test {public static void main(String[] args) {
// Dog2 dog = new Dog2();
// Animal animal = dog; //表示父类的引用指向了子类的对象Animal animal = new Dog2(18,"旺财"); //向上转型animal.eat();}
}这里的子类和父类的方法用到了重写这个概念
并通过父类的引用指向子类对象的方式实现了向上转型
由于这里引用的是Animal类型, 因此我们发现只能调用Animal下的方法,调用bark方法程序就运行失败了。于是我们得到只能调用父类下方法的结论
然而运行后我们发现结果是子类下的打印：旺财正在吃狗粮
我们把这种现象称为：运行时绑定（动态绑定）
它的发生条件就是：1、发生了向上转型
2、子类重写了父类的方法
3、父类调用了这个方法
那就引申出了另一种绑定：编译时绑定（静态绑定）
简单讲其实就是重载时匹配合适的方法：
public void class add(int a,int b)public void class add(int a,int b,int c)add(2,3)add(1,2,3)