Java学习day012（面向对象三大特征补充）

文章目录

多态
- 多态的成员访问的特点
- 多态的好处和弊端
- 多态中的转型
抽象类
- 抽象类特点
- 抽象类的成员特点
接口
- 接口特点
- 接口的成员特点
- 类和接口的关系
- 抽象类和接口的关系
内部类
- 成员内部类
- 局部内部类
- 匿名内部类

多态

同一个对象在不同时刻表现出来的不同状态

举 :猫
猫是猫: 猫 cat = new 猫();
猫是动物: 动物 cat = new 猫();
猫在不同时刻体现出来了不同状态，这个就是多态

多态的前提和体现
1.有继承/实现关系
2.有方法重写
3.有父类引用指向子类对象

For example

定义三个类
Animal
Cat
AnimalDemo  // 测试类

package com.study_01;
public class Animal {public void eat() {System.out.println("动物吃东西");}
}
-----
package com.study_01;
// 多态前提第一步  继承关系
public class cat extends Animal{// 第二步  eat()方法重写@Overridepublic void eat() {System.out.println("猫吃鱼");}
}
-----
package com.study_01;
public class AnimalDemo {public static void main(String[] args) {// 第三步 有父类引用指向子类对象Animal a = new cat();a.eat(); // 猫吃鱼}
}

多态的成员访问的特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边

Question:为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写，而成员变量没有

For example

定义三个类
Animal
Cat
AnimalDemo  // 测试类

package com.study_02;public class Animal {// 父类的成员变量public int age = 40;public void eat() {System.out.println("动物吃东西");}
}
-----
package com.study_02;
// 有继承
public class Cat extends Animal{public int age = 20;public int weight = 10;// 有方法重写@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame() {System.out.println("猫捉迷藏");}
}
-----
package com.study_02;public class AnimalDemo {public static void main(String[] args) {// 有父类引用指向子类对象Animal a  = new Cat();System.out.println(a.age); // 40// 成员变量  编译看左边,运行看左边// 最终呈现的其实是动物类里面age变量的值
//        System.out.println(a.weight); // 编译看左边,动物类里面并没有weight变量,所以报错a.eat(); // 猫吃鱼// 成员方法  编译看左边,运行看右边
//        a.playGame;// 编译看左边,动物里面没有playGame()方法,该方法时Cat类特有的}
}

多态的好处和弊端

好处：提高了程序的扩展性

具体体现：定义方法的时候，使用父类类型作为参数，将来在使用的时候，使用具体的子类型参与操作

弊端：不能使用子类的特有功能

For example

定义五个类
Animal
Cat
Dog
AnimalOperateor  // 操作类
AnimalDemo  // 测试类

package com.study_03;
public class Animal {public void eat() {System.out.println("动物吃东西");}
}
-----
package com.study_03;
// 继承父类
public class Cat extends Animal {// 重写父类方法@Overridepublic void eat() {System.out.println("猫吃鱼");}
}
-----
package com.study_03;
public class Dog extends Animal{// 重写父类方法@Overridepublic void eat() {System.out.println("狗吃骨头");}public void lookDoor() {System.out.println("狗看门");}
}
------
package com.study_03;
/*动物操作类
*/
public class AnimalOperator {/* // 这样写较为复杂public void useAnimal(Cat c) { // Cat c = new Cat();c.eat();}public void useAnimal(Dog d) {d.eat();}*/// 这样写毕竟好public void useAnimal(Animal a) {// Animal a = new Cat();// Animal a = new Dog();a.eat();// 不能使用子类的特有功能
//         a.lookDoor();}
}
-----
package com.study_03;
public class AnimalDemo {public static void main(String[] args) {// 创建动物操作类的对象,调用方法AnimalOperator ao =new AnimalOperator();Cat c = new Cat();ao.useAnimal(c);Dog d = new Dog();ao.useAnimal(d);}
}

多态中的转型

向上转型

从子到父
父类引用指向子类对象

向下转型

从父到子
父类引用转为子类对象

For example

定义三个类
Animal
Cat
AnimalDemo  // 测试类

package com.study_04;
public class Animal {public void eat() {System.out.println("动物吃东西");}
}
-----
package com.study_04;
public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}public void playGame() {System.out.println("猫捉迷藏");}
}
-----
package com.study_04;
public class AnimalDemo {public static void main(String[] args) {// 多态Animal a  = new Cat(); // 向上转型a.eat();
//        a.playGame(); // 编译看左边,Animal中没有playGame()这个方法/*Cat c = new Cat();c.eat();c.playGame();*/// 向下转型,这样就可以调用Cat类里面特有的方法了Cat c = (Cat) a;c.eat();c.playGame();}
}

抽象类

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

抽象类特点

抽象类和抽象方法必须使用abstract关键字修饰

public abstract class  类名()
public abstract void eat();

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

抽象类不能实例化

Question:抽象类如何实例化呢?
参照多态的方式，通过子类对象实例化，这叫抽象类多态

抽象类的子类
1.要么重写抽象类中的所有抽象方法
2.要么是抽象类

For example

定义四个类
Animal
Cat
Dog
AnimalDemo  // 测试类

package com.study_02;
/*
*   抽象类
* */
public abstract class Animal { // 使用abstract关键字,抽象类// 定义一个抽象方法  public abstract void eat(); // 使用abstract关键字,抽象方法public void sleep() {System.out.println("睡觉");}
}
-----
package com.study_02;
// 定义一个猫类继承于动物类
public class Cat extends Animal {// 因为猫类不是抽象类，所以要重写动物类中的所有抽象方法@Overridepublic void eat() {System.out.println("猫吃鱼");}// 猫类自己的方法public void play() {System.out.println("猫小乐");}
}
-----
package com.study_02;public abstract class Dog extends Animal{}
------
package com.study_02;public class AnimalDemo {public static void main(String[] args) {//        Animal a = new Animal(); // 是抽象类,不是具体的,抽象类不能被实例化Animal a = new Cat(); // 通过子类对象进行实例化a.eat();a.sleep();// 向下转型Cat c = (Cat) a; c.play(); // 如果不进行转型,a是调用不了Cat类中特有的play()方法// 因为编译看左边,但是左边Animal类中并没有play()这个方法 }
}

抽象类的成员特点

成员变量
可以是变量
也可以是常量

构造方法
有构造方法，但是不能实例化

Question:构造方法的作用是什么呢?
用于子类访问父类数据的初始化

成员方法
可以有抽象方法:限定子类必须完成某些动作
也可以有非抽象方法:提高代码复用性

For example

定义三个类
Animal
Cat
AnimalDemo  // 测试类

package com.study_03;
/*
*   抽象类
* */
public abstract class Animal {private int age = 20;private final String city = "Nanjing";// 有构造方法，但是不能实例化public Animal(){}// 用于子类访问父类数据的初始化public Animal(int age) {this.age = age;}// 非抽象方法,提高代码复用性public void show() {age = 40;System.out.println(age);System.out.println(city);}// 抽象方法,限定子类必修要完成eat()方法public abstract void eat();
}
-----
package com.study_03;
public class Cat extends Animal{// 重写父类中的抽象方法@Overridepublic void eat() {System.out.println("猫吃鱼");}
}
-----
package com.study_03;
public class AnimalDemo {public static void main(String[] args) {Animal a = new Cat();a.eat();a.show();}
}

接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用Java中的接口更多的体现在对行为的抽象

接口特点

接口用关键字interface修饰

public interface 接口名 {}

类实现接口用implements表示

public class 类名 implements 接口名{}

接口不能实例化

Question:接口如何实例化呢?
参照多态的方式，通过实现子类对象实例化，这叫接口多态。

多态的形式:具体类多态，抽象类多态，接口多态

多态的前提
1.有继承或者实现关系;
2.有方法重写;
3.有父(类/接口)引用指向(子/实现)类对象

接口的实现类
1.要么重写接口中的所有抽象方法
2.要么是抽象类

接口的成员特点

成员变量
只能是常量
默认修饰符:public static final

构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在
一个类如果没有父类，默认继承自Object类

成员方法
只能是抽象方法
默认修饰符: public abstract
关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

For example

package com.study_02;
public interface Inter {public int num = 10;public final  int num2 = 20;// 接口中是没有构造方法的, 因为接口是对行为进行描述
//    public Inter(){}//    public void  show(){} // 接口里面不能有非抽象方法public abstract void method();// 接口里面 方法默认就是 public abstractvoid show();
}
-----
package com.study_02;
// 下面表示接口实际表现,但是系统隐藏了
//public class InterImpl implements Inter{public  class InterImpl  extends Object implements Inter{ // public InterImpl() {super();}// 重写接口里面的方法@Overridepublic void method() {System.out.println("method");}@Overridepublic void show() {System.out.println("show");}
}
-----
package com.study_02;
/*接口测试类*/
public class InterfaceDemo {public static void main(String[] args) {// 参考多态实例的实现方式Inter i = new InterImpl();
//        i.num = 20; // 接口中成员变量默认被final修饰System.out.println(i.num);System.out.println(i.num2);System.out.println(Inter.num); // 接口中的成员变量默认静态修饰}
}

类和接口的关系

类和类的关系
继承关系，只能单继承，但是可以多层继承

类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口和接口的关系
继承关系，可以单继承，也可以多继承

抽象类和接口的关系

成员区别

抽象类
变量,常量;有构造方法;有抽象方法,也有非抽象方法

接口
常量;抽象方法

关系区别

类与类
继承，单继承

类与接口
实现，可以单实现，也可以多实现

接口与接口
继承，单继承，多继承

设计理念区别

抽象类
对类抽象，包括属性、行为

接口
对行为抽象，主要是行为

举个例子:
门和警报
所有门都有开门和关门的功能，部分们有警报的功能
那么就可以把开门关门功能写在门类中，警报功能写在接口中

内部类

内部类:就是在一个类中定义一个类。

举例:在一个类A的内部定义一个类B，类B就被称为内部类

内部类的访问特点
1.内部类可以直接访问外部类的成员，包括私有
2.外部类要访问内部类的成员，必须创建对象

内部类的定义格式

public class 类名 {修饰符 class 类名{}
}

For example

package com.study_01;
public class Outer {private int num = 10;// 简简单单调用一个内部类public class Inner {public void show() {System.out.println(num);}}// 通过方法调用内部类里面的方法public void  method(){// 外部类调用内部类,必修要创建对象Inner i  = new Inner();i.show();}
}

成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式
1.在类的成员位置:成员内部类
2.在类的局部位置:局部内部类

成员内部类，外界如何创建对象使用呢?

格式:  外部类名.内部类名对象名=外部类对象.内部类对象;
范例:  Outer.Inner oi = new Outer().new Inner();

package com.study_02;
public class Outer {public int num = 10;/*public class Inner{public void show() {System.out.println(num);}}*/private class Inner{public void show() {System.out.println(num);}}public void method() {Inner i = new Inner();i.show();}
}
-----
package com.study_02;
/*
* 测试类
* */
public class InnerDemo {public static void main(String[] args) {// 创建内部类对象，并调用方法// 调用public修饰的内部类
//        Outer.Inner oi = new Outer().new Inner();  // 不能私有的内部类
//        oi.show();// 调用private修饰的内部类Outer o = new Outer();o.method();}
}

局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用该类可以直接访问外部类的成员，也可以访问方法内的局部变量

For example

package com.study_03;
public class Outer {public int num = 10;public void method() {int num2 = 20;// 内部类写在外部类的方法里面class Inner {public void show(){System.out.println(num);System.out.println(num2);}}Inner i = new Inner();i.show();}}
-----
package com.study_03;
public class OuterDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}
}

匿名内部类

前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类
本质:是一个继承了该类或者实现了该接口的子类匿名对象

new 类名或者接口名() {重写方法
};

For example

package com.study_04;
// 存在的接口
public interface Inter {void show();
}
-----
package com.study_04;public class Outer {public void method() {/* new Inter(){@Overridepublic void show() {System.out.println("匿名内部类");}};*///        show()/*new Inter() {@Overridepublic void show() {System.out.println("匿名内部类");}}.show();*/Inter i =  new Inter() {@Overridepublic void show() {System.out.println("匿名内部类");}};i.show();}
}
-----
package com.study_04;
public class OuterDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}
}