------Java EE培训、Android培训、iOS培训、期待与您交流！ -------
继承通过 extends 关键字让类与类之间产生继承关系。 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。 多个类可以称为子类，单独这个类称为父类或者超类。 注意： ①子类可以直接访问父类中的非私有的属性和行为。 ②子类无法继承父类中私有的内容。③父类怎么来的？共性不断向上抽取而来的。 ExtendDemo.java class Person{ String name; int age ; } class Student extends Person{ void study(){ System. out.println("student study..." + age); } } class Worker extends Person{ void work(){ System. out.println("worker work..." + age); } } class ExtendDemo{ public static void main(String[] args){ Student s = new Student(); s. name = "zhangsan" ; s. age = 20; s.study(); Worker w = new Worker(); w. name = "lisi" ; w. age = 30; w.work(); } } 好处： 继承的出现提高了代码的复用性。继承的出现让类与类之间产生了关系，提供了多态的前提。 继承的特点 Java只支持单继承，不支持多继承。一个类只能有一个父类，不可以有多个父类。 原因： 因为多继承容易出现问题。 两个父类中有相同的方法。子类到底要执行哪一个是不确定的。 class A{ void show(){ System. out.println("a" ); } } class B{ void show(){ System. out.println("b" ); } } class C extends B,A{ } 那么创建类C的对象，调用show方法就不知道调用类A中的show方法还是类B中的show方法。 所以java是不支持多继承，但将这种机制以另一种安全的方式来体现，也就是多实现。 Java支持多层继承(继承体系) C继承B，B继承A，就会出现继承体系。 多层继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象，即可使用该体系功能。 定义继承需要注意： 不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属( "is a")关系。 super关键字 & 函数覆盖 在子父类中，成员的特点体现：①成员变量 this和super的用法很相似。 this代表本类对象的引用。super代表父类的内存空间的标识。 当本类的成员和局部变量同名用this区分。当子父类中的成员变量同名用super区分父类。 1 //ExtendDemo.java 2 class Fu{ 3 private int num = 4; 4 public int getNum(){ 5 return num ; 6 } 7 } 8 9 class Zi extends Fu{ 10 private int num = 5; 11 void show(){ 12 System. out.println(this.num + "..." + super.getNum()); 13 } 14 } 15 16 class ExtendDemo{ 17 public static void main(String[] args){ 18 Zi z = new Zi(); 19 z.show(); 20 } 21 } ②成员函数 当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作，这是函数在子父类中的特性。 在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。 函数两个特性： 1、重载，同一个类中。2、覆盖，子类中，覆盖也称为重写，覆写，override。 class Fu{ public void show(){ System. out.println("fu show run" ); } } class Zi extends Fu{ public void show(){ System. out.println("zi show run" ); } } class ExtendDemo{ public static void main(String[] args){ Zi z = new Zi(); z.show(); } } 什么时候使用覆盖操作？ 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。 class Phone{ void call(){} void show(){ System. out.println("number" ); } } class NewPhone extends Phone{ void show(){ System. out.println("name" ); System. out.println("pic" ); super.show(); } } class ExtendDemo{ public static void main(String[] args){ NewPhone p = new NewPhone(); p.show(); } } 注意： ①父类中的私有方法不可以被覆盖。②父类为static的方法无法覆盖。③覆盖时，子类方法权限一定要大于等于父类方法权限。 class Fu{ public void show(){ System. out .println("fu show run" ); } } class Zi extends Fu{ private void show(){ System. out .println("zi show run" ); } } class ExtendDemo{ public static void main(String[] args){ Zi z = new Zi(); z. show(); } } ③构造函数 子父类中构造函数的特点： 在子类构造函数执行时，发现父类构造函数也运行了。原因：在子类的构造函数中，第一行有一个默认的隐式语句：super();。 注意：如果使用super(4);语句调用父类的其他构造函数，那么默认的父类构造函数将不会再被调用。 class Fu{ int num ; Fu(){ num = 10; System. out.println("A fu run" ); } Fu( int x){ System. out.println("B fu run..." + x); } } class Zi extends Fu{ Zi(){ //super();//默认调用的就是父类中的空参数的构造函数 System. out.println("C zi run " + num); } Zi( int x){ super(4); System. out.println("D zi run " + x); } } class ExtendDemo{ public static void main(String[] args){ new Zi(); System. out.println("-------------------" ); new Zi(6); } }
--------------------------------------------------------------------------------------------------------------------
子类的实例化过程 子类中所有的构造函数默认都会访问父类中空参数的构造函数。 因为每一个构造函数的第一行都有一条默认的语句super();。 子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。 为什么子类实例化的时候要访问父类中的构造函数呢？那是因为子类继承了父类，获取到了父类中内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。 注意： ①当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。 ②子类构造函数中如果使用this调用了本类构造函数，那么默认的super();就没有了，因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。 ③super语句必须要定义在子类构造函数的第一行！因为父类的初始化动作要先完成。 ExtendDemo.java class Fu{ Fu() { super(); show(); return; } void show(){ System. out.println("fu show" ); } } class Zi extends Fu{ int num = 8; Zi(){ super(); //通过super初始化父类内容时，子类的成员变量并未显示初始化，等super()父类初始化完毕后，才进行子类的成员变量显示初始化 return; } void show(){ System. out.println("zi show..." + num); } } class ExtendDemo{ public static void main(String[] args){ Zi z = new Zi();//调用的是子类的show方法，此时其成员变量 num还未进行显示初始化 z.show(); } }不正确的案例：
class fu { fu(int num) { show(); return; } void show() { System.out.println("fu show"); } } class zi extends fu { int num = 9; zi() {return; } void show() { System.out.println("zi show"+num); } } 总结： 一个对象实例化过程，以Person p = new Person();为例： 1、JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）。 2、在内存中开辟空间，并分配地址。 3、并在对象空间中，对对象的属性进行默认初始化。 4、调用对应的构造函数进行初始化。 5、在构造函数中，第一行会先到调用父类中构造函数进行初始化。 6、父类初始化完毕后，再对子类的属性进行显示初始化。 7、再进行子类构造函数的特定初始化。 8、初始化完毕后，将地址值赋值给引用变量。 -------------------------------------------------------------------------------------------------------------------------- final关键字 final可以修饰类，方法，变量。 final修饰的类不可以被继承。 final修饰的方法不可以被覆盖。 final修饰的变量是一个常量，只能被赋值一次。为什么要用final修饰变量，其实在程序中如果一个数据是固定的。那么直接使用这个数据就可以了，但是这种阅读性差，所以应该给数据起个名称。 而且这个变量名称的值不能变化，所以加上final固定。 写法规范：常量所有字母都大写，多个单词，中间用_连接。 FinalDemo.java //继承弊端：打破了封装性 class Fu{ void method(){ } } class Zi extends Fu{ public static final double PI = 3.14; void method(){ System. out.println(PI); } } class FinalDemo{ public static void main(String[] args){ Zi zi = new Zi(); zi.method(); } } 1 //FinalDemo.java 2 class FinalDemo{ 3 public static void main(String[] args){ 4 final int x = 4; 5 x = 5; 6 } 7 }---------------------------------------------------------------------------------------------------------
抽象类 概述 抽象定义： 抽象就是从多个事物中将共性的，本质的内容抽取出来。 例如：猫和虎共性都是猫科，猫科就是抽象出来的概念。抽象类： Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。 抽象方法的由来： //AbstractDemo.java abstract class Demo{ abstract void show(); } class DemoA extends Demo{ void show(){ System. out.println("demoa show" ); } } class DemoB extends Demo{ void show(){ System. out.println("demob show" ); } } class AbstractDemo{ public static void main(String[] args){ DemoA demoA = new DemoA(); demoA.show(); DemoB demoB = new DemoB(); demoB.show(); } } 多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。 例如：猫和虎都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的猫科虽然有吼叫功能，但是并不明确吼叫的细节。 ------------------------------------------------------------------------------------------------------------------- 抽象类举例代码讲解雇员示例 需求： 公司中程序员有姓名，工号，薪水，工作内容。 项目经理除了有姓名，工号，薪水，还有奖金，工作内容。 分析： 在这个问题领域中，通过名词提炼法： 程序员： 属性：姓名，工号，薪水。 行为：工作。经理： 属性：姓名，工号，薪水，奖金。 行为：工作。 程序员和经理不存在着直接继承关系。 但是，程序员和经理却具有共性内容，可以进行抽取，因为他们都是公司的雇员。 可以将程序员和经理进行抽取，建立体系。 //描述雇员。 abstract class Employee{ private String name ; private String id ; private double pay ; Employee(String name,String id, double pay){ this.name = name; this.id = id; this.pay = pay; } public abstract void work(); } //描述程序员 class Programmer extends Employee{ Programmer(String name,String id, double pay){ super(name,id,pay); } public void work(){ System. out.println("code..." ); } } //描述经理 class Manager extends Employee{ private int bonus ; Manager(String name,String id, double pay,int bonus){ super(name,id,pay); this.bonus = bonus; } public void work(){ System. out.println("manage" ); } }--------------------------------------------------------------------------------------------------
抽象类相关问题 抽象类中是否有构造函数？ 答：有，用于给子类对象进行初始化。 抽象关键字abstract不可以和哪些关键字共存？ 答：private、static、final。 抽象类中可不可以没有抽象方法？ 答：可以，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。 abstract class Demo{ void show1(){} void show2(){} } 抽象类和一般类的区别？ 答： 相同点： 抽象类和一般类都是用来描述事物的，都在内部定义了成员。 不同点： ①一般类有足够的信息描述事物。 抽象类描述事物的信息有可能不足。 ②一般类中不能定义抽象方法，只能定义非抽象方法。 抽象类中可定义抽象方法，同时也可以定义非抽象方法。 ③一般类可以被实例化。抽象类不可以被实例化。 抽象类一定是个父类吗？ 答：是的，因为需要子类覆盖其方法后才可以对子类实例化。 ------------------------------------------------------------------------------------------------------------------ 接口 当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。 格式：interface {} 接口中的成员修饰符是固定的： 成员常量：public static final 成员函数：public abstract 由此得出结论，接口中的成员都是公共的权限。接口是对外暴露的规则。接口是程序的功能扩展。 注意： ①虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。 ②类与类之间是继承关系，类与接口直接是实现关系。 ③接口不可以实例化,只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。 interface Demo{ public static final int NUM = 4; public abstract void show1(); public abstract void show2(); } class DemoImpl implements /*实现*/Demo{ public void show1(){} public void show2(){} } class InterfaceDemo{ public static void main(String[] args){ DemoImpl d = new DemoImpl(); System. out.println(d.NUM); System. out.println(DemoImpl.NUM); System. out.println(Demo.NUM); } } 接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。 在java中不直接支持多继承，因为会出现调用的不确定性。 所以，java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。 接口的出现避免了单继承的局限性。 interface A{ public void show(); } interface Z{ public void show(); } //多实现 class Test implements A,Z{ public void show(){ System.out.println("Test"); } } class InterfaceDemo{ public static void main(String[] args){ Test t = new Test(); t.show(); } }一个类在继承另一个类的同时，还可以实现多个接口。
interface A{ public void show(); } interface Z{ public void show(); } class Q{ public void method(){ } } abstract class Test2 extends Q implements A,Z{ }
interface CC{ void show(); } interface MM{ void method(); } //接口与接口之间是继承关系，而且接口可以多继承 interface QQ extends CC,MM{ public void function(); } class WW implements QQ{ //覆盖3个方法 public void show(){} public void method(){} public void function(){} }
抽象类和接口的异同点？相同点： 都是不断向上抽取而来的。不同点： ①抽象类需要被继承，而且只能单继承。 接口需要被实现，而且可以多实现。 ②抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。 接口中只能定义抽象方法，必须由子类去实现。 ③抽象类的继承，是is a关系，定义该体系的基本共性内容。 接口的实现是like a关系。
接口应用综合案例：
/* 笔记本电脑使用。 为了扩展笔记本的功能，但日后出现什么功能设备不知道。 因此需要定义一个规则，只要日后出现的设备都符合这个规则就可以了。 规则在java中就是接口。 */ interface USB{//暴露的原则 public void open(); public void close(); } //实现原则 //这些设备和电脑的耦合性降低了 class UPan implements USB{ public void open(){ System. out.println("upan open" ); } public void close(){ System. out.println("upan close" ); } } class UsbMouse implements USB{ public void open(){ System. out.println("usbMouse open" ); } public void close(){ System. out.println("usbMouse close" ); } } class BookPC{ public static void main(String[] args){ //功能扩展了 useUSB(new UPan()); } //使用原则 public static void useUSB(USB u){//接口类型的引用，用于接收（指向）接口的子类对象 if(u != null ){ u.open(); u.close(); } } }
-------------------------------------------------------------------------------------------------------------
多态 定义：某一类事物的多种存在形态。 例：动物中猫，狗。 猫这个对象对应的类型是猫类型：猫 x = new 猫(); 同时猫也是动物中的一种，也可以把猫称为动物：动物 y = new 猫(); 动物是猫和狗具体事物中抽取出来的父类型。 父类型引用指向了子类对象。 多态性简单说就是一个对象对应着不同类型。 体现： 父类或者接口的引用指向或者接收自己的子类对象。作用： 多态的存在提高了程序的扩展性和后期可维护性。 前提： ①需要存在继承或者实现关系。 ②需要有覆盖操作。 好处： 提高了代码的扩展性，前期定义的代码可以使用后期的内容。弊端： 前期定义的内容不能使用（调用）后期子类的特有内容。 DuoTaiDemo.java abstract class Animal{ abstract void eat(); } class Dog extends Animal{ void eat(){ System. out.println("啃骨头" ); } void lookHome(){ System. out.println("看家" ); } } class Cat extends Animal{ void eat(){ System. out.println("吃鱼" ); } void catchMouse(){ System. out.println("抓老鼠" ); } } class Pig extends Animal{ void eat(){ System. out.println("饲料" ); } void gongdi(){ System. out.println("拱地" ); } } class DuoTaiDemo{ public static void main(String[] args){ Cat c = new Cat(); Dog d = new Dog(); method(c); method(d); method(new Pig()); } public static void method(Animal a){ a.eat(); } } class DuoTaiDemo{ public static void main(String[] args){ //自动类型提升，猫对象提升了动物类型。但是特有功能无法访问，作用就是限制对特有功能的访问。 //专业讲：向上转型，将子类型隐藏。就不能使用子类的特有方法了。 Animal a = new Cat(); a.eat(); //a.catchMouse();//报错 //如果还想用具体动物猫的特有功能。 //你可以将该对象进行向下转型。 Cat c = (Cat)a; //向下转型的目的是为了能够使用子类中的特有方法。 c.eat(); c.catchMouse(); //注意：对于转型，自始至终都是子类对象在做类型的变化。 //Animal a = new Dog(); //Cat c = (Cat)a;//但是类型不能随意转换，否则可能会报出ClassCastException的异常 } public static void method(Animal a){ a.eat(); } /* 毕老师和毕姥爷的故事 */ class 毕姥爷{ void 讲课(){ System. out.println("管理" ); } void 钓鱼(){ System. out.println("钓鱼" ); } } class 毕老师 extends 毕姥爷{ void 讲课(){ System. out.println("Java" ); } void 看电影(){ System. out.println("看电影" ); } } class DuoTaiDemo{ public static void main(String[] args){ 毕老师 x = new 毕老师(); x.讲课(); //Java x.看电影(); //看电影 毕姥爷 y = new 毕老师(); y.讲课(); //Java y.钓鱼(); //钓鱼 毕老师 z = (毕老师)y; z.看电影(); //看电影 } } 注意： instanceof ：用于判断对象的具体类型，只能用于引用数据类型判断，通常在向下转型前用于健壮性的判断。 class DuoTaiDemo{ public static void main(String[] args){ } public static void method(Animal a){ a.eat(); if(a instanceof Cat){ Cat c = (Cat )a; c.catchMouse(); } else if (a instanceof Dog){ Dog d = (Dog )a; d.lookHome(); } } } 多态时，成员的特点：①成员变量 编译时：参考引用型变量所属的类中是否有调用的成员变量。有，编译通过，没有，编译失败。 运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。 简单说：编译和运行都参考等号的左边。 class Fu{ int num = 3; } class Zi extends Fu{ int num = 4; } class DuoTaiDemo{ public static void main(String[] args){ Zi f1 = new Zi(); System. out.println(f1.num ); Fu f2 = new Zi(); System. out.println(f2.num ); } }②成员函数（非静态） 编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过。没有，编译失败。 运行时：参考的是对象所属的类中是否有调用的函数。 简单说：编译看左边，运行看右边。
DuoTaiDemo.java class Fu{ void show(){ System. out.println("fu show" ); } } class Zi extends Fu{ void show(){ System. out.println("zi show" ); } } class DuoTaiDemo{ public static void main(String[] args){ Fu f = new Zi(); f.show(); } }③静态函数 编译时：参考的是对象所属的类中是否有调用的函数。 运行时：参考的是对象所属的类中是否有调用的函数。 简单说：编译和运行都看左边。
class Fu{ static void method(){ System. out.println("fu static method" ); } } class Zi extends Fu{ static void method(){ System. out.println("zi static method" ); } } class DuoTaiDemo{ public static void main(String[] args){ Fu f = new Zi(); f.method();// fu static method Fu. method(); } }
内部类的设计： InnerClassDemo.java /* 内部类的设计： 分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时候就定义内部类。 */ class Outer{ private int num = 3; class Inner //内部类 { void show(){ System. out.println("show run..." + num); } } public void method(){ Inner in = new Inner(); in.show(); } } class InnerClassDemo{ public static void main(String[] args){ Outer out = new Outer(); out.method(); } } class Outer{ private int num = 3; class Inner { void show(){ System. out.println("show run..." + num); } } } class InnerClassDemo{ public static void main(String[] args){ //直接访问外部类中的内部类中的成员 Outer.Inner in = new Outer().new Inner(); in.show(); } } 内部类的位置 内部类定义在成员位置上,可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。 class Outer{ private static int num = 3; static class Inner { void show(){ System. out.println("show run..." + num); } } } class InnerClassDemo{ public static void main(String[] args){ //如果内部类是静态的，相当于一个外部类 Outer.Inner in = new Outer.Inner(); in.show(); } } class Outer{ private static int num = 3; static class Inner { static void show(){ System. out.println("show run..." + num); } } } class InnerClassDemo{ public static void main(String[] args){ Outer.Inner.show(); } } 注意： ①如果内部类中定义了静态成员，该内部类也必须是静态的！ class Outer{ private static int num = 3; static class Inner { static void show(){ System. out.println("show run..." + num); } } }
②为什么内部类能直接访问外部类中的成员呢？ 那是因为内部类持有了外部类的引用，外部类名.this。
InnerClassDemo.java class Outer{ int num = 3; class Inner{ int num = 4; void show(){ int num = 5; System. out.println(num); System. out.println(this.num); System. out.println(Outer.this.num); } } void method(){ new Inner().show(); } } class InnerClassDemo{ public static void main(String[] args){ new Outer().method(); } }
③内部类定义在局部位置上，也可以直接访问外部类中的成员。 同时可以访问所在局部中的局部变量，但必须是被final修饰的。 class Outer{ int num = 3; void method(final int y){ final int x = 9; class Inner{ void show(){ System. out.println("show..." + x + "," + y); } } Inner in = new Inner(); in.show(); } } class InnerClassDemo{ public static void main(String[] args){ new Outer().method(4); } } 匿名内部类 定义： 就是内部类的简化写法。前提： 内部类可以继承或实现一个外部类或者接口。格式： new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)} 简单理解： 就是建立一个带内容的外部类或者接口的子类匿名对象。 什么时候使用匿名内部类呢？ 通常在使用方法是接口类型参数，并且该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。好处： 增强阅读性。 abstract class Demo{ abstract void show(); } class Outer{ int num = 4; void method(){ new Demo(){//匿名内部类 void show(){ System. out.println("show......" + num); } }.show(); } } class InnerClassDemo{ public static void main(String[] args){ new Outer().method(); } } interface Inter{ void show1(); void show2(); } class Outer{ public void method(){ Inter in = new Inter(){ public void show1(){ System. out.println("...show1...." ); } public void show2(){ System. out.println("...show2...." ); } }; in.show1(); in.show2(); } } class InnerClassDemo{ public static void main(String[] args){ new Outer().method(); } } interface Inter{ void show1(); void show2(); } /* 通常的使用场景之一： 当函数参数是接口类型时，而且接口中的方法不超过三个。 可以用匿名内部类作为实际参数进行传递。 */ class InnerClassDemo{ public static void main(String[] args){ show(new Inter(){ public void show1(){ System. out.println("...show1..." ); } public void show2(){ System. out.println("...show2..." ); } }); } public static void show(Inter in){ in.show1(); in.show2(); } } 对象的初始化过程实例： class Fu{ int num = 9; { System. out.println("Fu" ); } Fu(){ super();//Object //显示初始化 //构造代码块初始化 show(); } void show(){ System. out.println("fu show " + num);//被覆盖，运行子类的 } } class Zi extends Fu{ int num = 8; { System. out.println("Zi" ); } Zi(){ super(); //显示初始化 //构造代码块初始化 show(); } void show(){ System. out.println("zi show " + num); } } public class Demo{ public static void main(String[] args){ new Zi(); } }
转载于:https://www.cnblogs.com/tozr/p/4184562.html
