一, 继承的进阶
1.1，成员变量
重点明确原理。
特殊情况：
子父类中定义了一模一样的成员变量。
都存在于子类对象中。
如何在子类中直接访问同名的父类中的变量呢？
通过关键字 super来完成。
super和this的用法很相似。
this：代表的是本类的对象的引用。
super：代表的是父类的内存空间。
注意：这种情况开发见不到，因为父类一旦描述完了属性，子类直接使用就可以了。
//父类。 class Fu { /*private int num1 = 3;*///父类中私有的内容子类不可以直接访问。 int num = 3; } class Zi extends Fu { /*int num2 = 4;*/ int num = 4; void show() { // System.out.println("num1="+num1); // System.out.println("num2="+num2); System.out.println("zi num="+num); // num=4 System.out.println("fu num="+super.num);// num=3 } } class ExtendsDemo { public static void main(String[] args) { Zi z = new Zi(); z.show(); } }
图解
1.2 成员函数@@
子父类中成员函数的特点
特殊情况：
子父类中的定义了一模一样的函数。
运行的结果:子类的函数在运行。
这种情况在子父类中，是函数的另一个特性：override(重写，覆盖，复写)
【重写什么时候用？】
举例：
//描述手机。
class Phone { int number; //打电话。 void call(){} //来电显示。 void show() { sop("电话号码.."+number); } } Phone p = new Phone(); p.show();
随着电话的升级，只显示号码不爽，希望显示姓名，大头贴。
修改源码，虽然费劲但是可以解决，不利于后期的维护和扩展。
为了扩展方便。新功能是不是新的电话具备呢？
单独描述单独封装。新电话也是电话中的一种。继承。直接获取父类中的功能。
但是新电话的来显功能已经变化了。需要重新定义。
那么定义一个新功能合适吗？比如newShow，不合适，因为父类已经将来显功能定义完了，
子类完全不需要重新定义新功能。直接用就可以了。如果子类的来显功能内容不同。
直需要保留来显功能，定义子类的内容即可：这就是重写的应用！
class NewPhone extends Phone { String name; String picPath;//图片路径。 void show() { //sop("电话号码"); super.show();//如果还需要父类中原有的部分功能，可以通过super调用。@@@@@ sop("姓名"+name); sop("大头贴"+picPath); } }
【重写(覆盖)的注意事项】@@
1，子类覆盖父类，必须保证全要大于或者等于父类的权限。
Fu:
private void show(){}
Zi:
public void show(){}
2，静态覆盖静态。
写法上稍微注意:必须一模一样:函数的返回值类型 , 函数名 参数列表都要一样。
【重写总结】
当一个类是另一个类中的一种时，可以通过继承，来扩展功能。
如果从父类具备的功能内容需要子类特殊定义时，使用重写。
*/ class Fu { int show() { System.out.println("fu show run"); return 0; } } class Zi extends Fu { void show() { System.out.println("zi show run"); } } class ExtendsDemo2 { public static void main(String[] args) { Zi z = new Zi(); z.show(); } }
图解
1.3 构造函数
【子父类中构造函数的特点】
class Fu { int Fu() { System.out.println("fu show run"); return 0; } } class Zi extends Fu { void Zi() { System.out.println("zi show run"); } } class ExtendsDemo2 { public static void main(String[] args) { new Zi(); } }
当子父类都有构造函数时，发现结果为：
fu constructor run
zi constructor run
先执行了父类的构造函数，再执行子类的构造函数。
【这是为啥呢？】
因为子类的所有的构造函数中的第一行都有一句隐式语句 super(); //默认调用的是父类中的空参数的构造函数。
【子类中的构造函数为什么有一句隐式的super()呢？】
原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。
才可以更方便的使用父类中的内容。
【小结】
当父类中没有空参数构造函数时，子类的构造函数必须同构显示的super语句指定要访问的父类中的构造函数。
这就是传说中的子类实例化过程。*/
class Fu { Fu() { //super(); //显示初始化。 System.out.println("fu constructor run..A.."); } Fu(int x) { //显示初始化。 System.out.println("fu constructor run..B.."+x); } } class Zi extends Fu { Zi() { System.out.println("zi constructor run..C.."); } Zi(int x) { System.out.println("zi constructor run..D.."+x); } } class ExtendsDemo3 { public static void main(String[] args) { // new Zi(); // AC@@ new Zi(6); // AD@@ } }
【实例化过程的细节】
1，如果子类的构造函数第一行写了this调用了本类其他构造函数，那么super调用父类的语句还有吗？
没有的，因为this()或者super(),只能定义在构造函数的第一行，因为初始化动作要先执行。
2，父类构造函数中是否有隐式的super呢？
也是有的。记住：只要是构造函数默认第一行都是super();
父类的父类是谁呢？super调用的到底是谁的构造函数呢？
Java体系在设计，定义了一个所有对象的父类Object ，
【总结】
类中的构造函数默认第一行都有隐式的super()语句，在访问父类中的构造函数。
所以父类的构造函数既可以给自己的对象初始化，也可以给自己的子类对象初始化。
如果默认的隐式super语句没有对应的构造函数，必须在构造函数中通过this或者super的形式明确调用的构造函数。
【问题】@@@
1，this语句和super语句是否可以在同一个构造函数中出现呢？不行，因为必须定义在第一行。
2，为什么要定义在第一行呢？因为初始化动作要先执行。
//子类的实例化过程的应用。也是super调用的应用。
//什么时候用super调用父类中构造函数。只要使用父类的指定初始化动作，就在子类中通过super(参数列表)格式进行调用。
class Person { private String name; private int age; public Person(String name,int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } } class Student extends Person { public Student(String name,int age) { //调用父类。使用父类的初始化动作。 super(name,age); } public void study() {} } class Worker extends Person { public Worker(String name,int age) { //调用父类。使用父类的初始化动作。 super(name,age); } }
1.4 final
可以修饰 类,方法,变量
/*
继承的弊端：打破封装性。
不让其他类继承该类，就不会有重写。
怎么能实现呢？通过Java中的一个关键字来实现，final(最终化)。
【final关键字】
是一个修饰符，可以修饰类，方法，变量(成员变量，局部变量，静态变量)。
【特点】
1，final修饰的类是一个最终类，不能在派生子类。
如果类中从出现部分可以重写，部分不可以？怎么办？只要让指定的方法最终化就可以了。
2，final修饰的方法是最终方法，不可以给重写。
3，final修饰的变量是一个常量，只能被赋值一次。
【什么时候会在程序中定义final常量呢？】
当程序中一个数据使用时是固定不变的，这时为了增加阅读性，可以该该数据起个名字。
这就是变量，为了保证这个变量的值不被修改，加上final修饰，这就一个阅读性很强的常量。
书写规范，被final修饰的常量名所有的字母都是大写的。如果由多个单词组成单词间通过 _ 连接。
*/ /*final*/class Fu { /*final*/ void show() { //调用到一些系统的功能。 //功能的内容是不可以改变的。 } } class Zi extends Fu { static final int number = 9;//最终化的是显示初始化值。 static final double PI = 3.14; //重写 void show() { final int count = 21; // count = 2; System.out.println(count); } } class FinalDemo { public static void main(String[] args) { System.out.println("Hello World!"); } }
二 抽象类
2.1 产生
/*
描述狗,行为：吼叫。
描述狼，行为：吼叫。
发现他们之间有共性，可以进行向上抽取。
当然是抽取它们的所属共性类型：犬科。
犬科这类事物：都具备吼叫行为,但是具体怎么叫，是不确定的，是由具体的子类来明确的。
这时在描述犬科时，发现了有些功能不具体，这些不具体的功能，需要在类中标识出来，通过java中的关键字abstract(抽象)。
定义了抽象函数的类也必须被abstract关键字修饰，被abstract关键字修饰的类是抽象类。
*/
//抽象类：在描述事物时，没有足够的信息描述一个事物，这时该事物就是抽象事物。
2.2 抽象类的特点
1，抽象类和抽象方法都需要被abstract修饰。
抽象方法一定要定义在抽象类中。
2，抽象类不可以创建实例，原因：调用抽象方法没有意义。
3，只有覆盖了抽象类中所有的抽象方法后，其子类才可以实例化。
否则该子类还是一个抽象类。
之所以继承，更多的是在思想，是面对共性类型操作会更简单。
【细节问题】
1，抽象类一定是个父类？
是的，因为不断抽取而来的。
2，抽象类是否有构造函数？
有，虽然不能给自己的对象初始化，但是可以给自己的子类对象初始化。
抽象类和一般类的异同点：
相同：
1，它们都是用来描述事物的。
2，它们之中都可以定义属性和行为。
不同：
1，一般类可以具体的描述事物。
抽象类描述事物的信息不具体
2，抽象类中可以多定义一个成员：抽象函数。
3，一般类可以创建对象，而抽象类不能创建对象。
3，抽象类中是否可以不定义抽象方法。
是可以的，那这个抽象类的存在到底有什么意义呢？仅仅是不让该类创建对象。
4，抽象关键字abstract不可以和哪些关键字共存？
1，final：
2，private：
3，static：
*/ abstract class 犬科 //extends Object { static abstract void 吼叫();//抽象函数。需要abstract修饰，并分号;结束 } //代码体现。 class Dog extends 犬科 { void 吼叫() { System.out.println("汪汪汪汪"); } } class Wolf extends 犬科 { void 吼叫() { System.out.println("嗷嗷嗷嗷"); } } class AbstractDemo { public static void main(String[] args) { System.out.println("Hello World!"); } }
2.2 例子
/*
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。
在问题领域中先找寻其中涉及的对象。
程序员
属性：姓名，工号，薪水
行为：工作
项目经理
属性：姓名，工号，薪水，奖金
行为：工作
这些对象是否有关系呢？因为发现了他们之间的共性，应该存在着关系。
可以将他们的共性向上抽取到共性类型：员工。
员工：
属性：姓名，工号，薪水
行为：工作
发现员工的工作内容本身就不具体。应该是抽象的，由具体的子类来体现的。
一定要动手!
*/ abstract class Employee { private String name; private String id; private double pay; /** 构造一个员工对象，一初始化就具备着三个属性。 */ public Employee(String name,String id,double pay) { this.name = name; this.id = id; this.pay = pay; } /** 工作行为。 */ public abstract void work(); } //具体的子类：程序员。 class Programmer extends Employee { public Programmer(String name,String id,double pay) { super(name,id,pay); } public void work() { System.out.println("code...."); } } //具体的子类：经理。 class Manager extends Employee { //特有属性。 private double bonus; public Manager(String name,String id,double pay,double bonus) { super(name,id,pay); this.bonus = bonus; } public void work() { System.out.println("manage"); } } class AbstractTest { public static void main(String[] args) { System.out.println("Hello World!"); } }
三 接口
3.1 产生
/*
抽象类中可以定义抽象方法的 。
当一个抽象类中的方法全是抽象的。
这时，可以通过另一种特殊的形式来体现。
用接口来表示。
3.2 定义
接口该如何定义呢？
interface abstract class Demo { abstract void show1(); abstract void show2(); } */ /*
3.3 接口中的成员
接口中的成员已经被限定为固定的几种。
【接口的定义格式先介绍两种：】
1，定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量。
2，定义方法，方法也有固定的修饰符，public abstract
注意:如果你不写编译器会给你自动加上
例如当你只写一个final的时候,编译器会给你自动加上public static final
接口中的成员都是公共的。
3.4 接口的特点
1，接口不可以创建对象。
2，子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。
否则子类是一个抽象类。
*/ interface Demo//定义一个名称为Demo的接口。 { public static final int NUM = 3; public abstract void show1(); public abstract void show2(); }
//定义子类去覆盖接口中的方法。子类必须和接口产生关系，类与类的关系是继承，类与接口之间的关系是 实现。通过 关键字 implements 注意: 定义接口时命名 名+Impl
class DemoImpl implements Demo//子类实现Demo接口。 { //重写接口中的方法。 public void show1(){} public void show2(){} }
【接口最重要的体现】
解决多继承的弊端。将多继承这种机制在java中通过多实现完成了。
interface A
{
void show1();
}
interface B
{
void show2();
}
class C implements A,B// 多实现。同时实现多个接口。
{
public void show1(){}
public void show2(){}
}
【怎么解决多继承的弊端呢？】
弊端：多继承时，当多个父类中有相同功能时，子类调用会产生不确定性。
其实核心原因就是在于多继承父类中功能有主体，而导致调用运行时，不确定运行哪个主体内容。
为什么多实现就解决了呢？
因为接口中的功能都没有方法体，由子类来明确。
interface A { void show(); } interface B { void show(); } class C implements A,B// 多实现。同时实现多个接口。 { public void show(); } C c = new C(); c.show();
【基于接口的扩展。】
class Fu { public void show(){} } //子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。 //如果子类想要继续扩展其他类中的功能呢？这时通过实现接口来完成。 interface Inter { pulbic void show1(); } class Zi extends Fu implements Inter { public void show1() { } }
[ 接口的好处]
接口的出现避免了单继承的局限性。
父类中定义的事物的基本功能。
接口中定义的事物的扩展功能。
3.5 接口出现后的一些小细节
1，类与类之间是继承(is a)关系，类与接口之间是实现(like a)关系，
接口与接口之间是继承关系，而且可以多继承。
interface InterA { void show1(); } interface InterAA { void show11(); } interface InterB extends InterA,InterAA//接口的多继承。 { void show2(); } class Test implements InterB { public void show1(){} public void show2(){} public void show11(){} } class InterfaceDemo { public static void main(String[] args) { DemoImpl d = new DemoImpl(); d.show1(); d.show2(); } }
3.6 接口的思想
举例：笔记本电脑，USB接口的故事。
1，接口的出现对功能是实现了扩展。
2，接口的出现定义了规则。
3，接口的出现降低了耦合性(解耦)。
接口的出现，完成了解耦，说明有两方，一方在使用这个规则，另一方在实现这个规则。
比如笔记本电脑使用这个规则，而外围设备在实现这个规则。
3.7 接口和抽象类的区别
描述事物。
犬:按照功能分类: 导盲犬，缉毒犬...
犬的行为
吼叫();
吃饭();
abstract class 犬 { public abstract void 吼叫(); public abstract void 吃饭(); } class 缉毒犬 extends 犬 { public void 吼叫(){} public void 吃饭(){} public void 缉毒(){} } //对于缉毒，有可能还有缉毒猪，具备者缉毒功能，应该将缉毒功能抽取。 //对缉毒进行描述。 abstract class 缉毒 { public abstract void 缉毒(); }
缉毒犬既需要犬的功能又需要缉毒的功能。
无法直接多继承。
是否可以多实现呢？可以的。
犬是接口，缉毒也是接口。缉毒犬多实现即可。
类负责描述的是事物的基本功能。接口负责描述事物的扩展功能。
缉毒犬是犬中一种。is a 关系，
将犬定义成类。而缉毒是犬的一个扩展功能。这时将缉毒定义接口。
这时描述就变成了这样：
interface 缉毒able { public abstract void 缉毒(); } class 缉毒犬 extends 犬 implements 缉毒able { public void 吼叫(){code..} public void 吃饭(){} public void 缉毒(){} }
总结：
1，抽象类是描述事物的基本功能，可以定义非抽象的方法。
接口中定义只能是抽象方法，负责功能的扩展。
2，类与类之间是继承关系 is a关系。
类与接口之间是实现关系 like a 关系。
门 open(); close(); 报警门。 class 门 { } interface 报警 { } class { public static void main(String[] args) { System.out.println("Hello World!"); } }