多态
同一个对象在不同时刻表现出来的不同状态
举 :猫
猫是猫: 猫 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()方法重写
@Override
public 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;
// 有方法重写
@Override
public 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 {
// 重写父类方法
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
-----
package com.study_03;
public class Dog extends Animal{
// 重写父类方法
@Override
public 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 {
@Override
public 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 {
// 因为猫类不是抽象类,所以要重写动物类中的所有抽象方法
@Override
public 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{
// 重写父类中的抽象方法
@Override
public 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 abstract
void show();
}
-----
package com.study_02;
// 下面表示接口实际表现,但是系统隐藏了
//public class InterImpl implements Inter{
public class InterImpl extends Object implements Inter{ //
public InterImpl() {
super();
}
// 重写接口里面的方法
@Override
public void method() {
System.out.println("method");
}
@Override
public 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(){
@Override
public void show() {
System.out.println("匿名内部类");
}
};*/
// show()
/*new Inter() {
@Override
public void show() {
System.out.println("匿名内部类");
}
}.show();*/
Inter i = new Inter() {
@Override
public 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();
}
}