1.多态
同类型的对象,执行同一个行为,会表现出不同的行为特征
多态的常见形式
父类类型 对象名称 = new 子类构造器;
接口 对象名称 = new 实现类构造器;
public abstract class Animal {
public String name = "父类";
public abstract void run();
}
public class Cat extends Animal{
public String name = "子类猫";
@Override
public void run() {
System.out.println("猫跑路了");
}
}
public class Rabbit extends Animal{
public String name = "子类兔子";
@Override
public void run() {
System.out.println("兔子跑路了");
}
}
public class Test {
public static void main(String[] args) {
// 1.多态的形式
Animal a = new Cat();
a.run();
System.out.println(a.name); // 编译看左,运行也看左
Animal b = new Rabbit();
b.run();
}
}
多态成员访问特点
方法调用:编译看左边,运行看右边
变量调用:编译看左边,运行也看左边(多态侧重行为多态)
优势
在动态形式下,右边对象可以实现解耦合,便于扩展和维护
Animal a = new Dog();
a.run(); // 后续业务行为随对象而变,后续代码无需修改
定义方法的时候,使用父类类型作为参数,该方法就可以接收这父类的一切子类对象,体现出多态的扩展性与便利
public class Test {
public static void main(String[] args) {
// 1.多态的形式
Animal a = new Cat();
Animal b = new Rabbit();
go(a);
go(b);
}
/*
* 需求,所有动物都可以比赛
* */
public static void go(Animal a) {
System.out.println("-------");
a.run();
System.out.println("--------");
}
}
多态下会产生一个问题
多态下不能使用子类独有功能
public class Cat extends Animal{
public String name = "子类猫";
@Override
public void run() {
System.out.println("猫跑路了");
}
public void sleep() {
System.out.println("猫睡觉");
}
}
public class Test {
public static void main(String[] args) {
// 1.多态的形式
Animal a = new Cat();
// a.sleep(); // 多态下不能访问子类独有功能
}
}
自动类型转换(从子到父):子类对象赋值给父类类型的变量指向
强制类型转换(从父到子)
此时必须进行强制类型转换: 子类 对象变量=(子类)父类类型的变量
作用:可以解决多态下的劣势,可以实现调用子类独有的功能
注意:如果转型后的类型和对象真是类型不是同一种类型,那么转换的时候就会出现ClassCastException
Java建议强制转换前使用instanceof判断当前对象的真是类型,再进行强制转换
变量名 instanceof 真实类型
判断关键字左边的变量指向的对象的真是类型,是否是右边的类型或者是其子类类型,是则返回true
public class Test {
public static void main(String[] args) {
// 自动类型转换
Animal a = new Cat();
a.run();
// 强制类型转换
Animal a2 = new Cat();
a2.run();
// Cat r = (Cat) a2; // 从父类类型到子类类型,必须强制类型转换 有继承或者实现关系编译阶段可以强制,运行时可能出错
// r.sleep();
if(a2 instanceof Cat) {
Cat c = (Cat) a2;
c.sleep();
} else if(a2 instanceof Rabbit) {
Rabbit ra = new Rabbit();
ra.run();
}
}
}
2.多态案例
需求:使用面向对象编程模拟:设计一个电脑对象,可以安装2个USB设备
鼠标:被安装时可以完全接入、调用点击功能、拔出功能
键盘:被安装时可以完成接入、调用打字功能、拔出功能
public interface USB {
void connect();
void unConnect();
}
public class KeyBoard implements USB{
private String name;
public KeyBoard(String name) {
this.name = name;
}
public KeyBoard() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void keyUp() {
System.out.println("键盘被敲击");
}
@Override
public void connect() {
System.out.println(name+"接入");
}
@Override
public void unConnect() {
System.out.println(name+"拔出");
}
}
public class Mouse implements USB{
private String name;
public Mouse(String name) {
this.name = name;
}
public Mouse() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void bdClick() {
System.out.println(name+"双击");
}
@Override
public void connect() {
System.out.println(name+"接入");
}
@Override
public void unConnect() {
System.out.println(name+"拔出");
}
}
public class Component {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void start() {
System.out.println(name+"开机");
}
public void installUSB(USB usb) {
// 多态 usb可能是鼠标也可能是键盘
usb.connect();
if(usb instanceof KeyBoard) {
KeyBoard k = (KeyBoard) usb;
k.keyUp();
}else if(usb instanceof Mouse) {
Mouse m = (Mouse) usb;
m.bdClick();
}
usb.unConnect();
}
public Component() {
}
public Component(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
Component c = new Component("戴尔");
c.start();
USB k = new KeyBoard("阿米洛花旦娘");
c.installUSB(k);
USB m = new Mouse("雷蛇");
c.installUSB(m);
}
}
3.内部类
内部类就是定义在一个类里面的类,里面的类可以理解成(寄生),外部类可以理解成(宿主)
public class People{
// 内部类
public class Heart {
}
}
内部类的使用场景、作用
当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完成结构又只为外部事物提供服务,那么整个内部的完成结构可以选择使用内部类来设计
内部类通常可以方便访问外部类的成员,包括私有的成员
内部类提供了更好的封装性,内部类本身就可以用private protected等修饰,封装性可以做更多控制
内部类的分类
静态内部类
成员内部类(非静态内部类)
局部内部类
匿名内部类
静态内部类
由static修饰,属于外部类本身
它的特点和使用与普通类是完全一样的,类有的成分他都有
public class Outer{
// 静态成员内部类
public static class Inner{
}
}
静态内部类创建对象的格式
格式:外部类名.内部类名 对象名 = new 外部类名.内部类构造器;
Outer.Inner in = new Outer.Inner();
静态内部类中是否可以直接访问外部类的静态成员
可以,外部类的静态成员只有一份可以被共享访问
静态内部类中是否可以直接访问外部类的实例成员
不可以,外部类的实例成员必须用外部类对象访问
成员内部类
无static修饰,属于外部类的对象
JDK16之前,成员内部类中不能定义静态成员,JDK16开始也可以定义静态成员了
public class Outer {
public class Inner{}
}
成员内部类创建对象的格式
格式:外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器();
Outer.Inner in = new Outer().new Inner();
成员内部类中是否可以直接访问外部类的静态成员
可以,外部类的惊天成员只有一份可以被共享访问
成员内部类的实例方法中是否可以直接访问外部类的实例成员
可以,必须现有外部类对象,才能有成员内部类对象,所以可以直接访问外部类对象的实例成员
成员内部类案例:
观察如下代码,写出合适的代码对应其注释要求输出的结果
class People {
private int heartbeat = 150;
public class Heart {
private int heartbear = 120;
public void show() {
int heartbeat = 70;
System.out.println(heartbeat); // 70
System.out.println(this.heartbear); // 120
System.out.println(People.this.heartbeat); // 150
}
}
}
注意:在成员内部类中访问所在内部类对象,格式:外部类名.this
局部内部类(了解)
局部内部类放在方法、代码块、构造器等执行体中
局部内部类的类文件名为:外部类$N内部类.class
public class Test {
public static void main(String[] args) {
class Dog {
}
}
}
匿名内部类
本质上是一个没有名字的局部内部类,定义在方法中、代码块中、等
作用:方便创建子类对象,最终目的是为了简化代码编写
格式
new 类|抽象类|或者接口名() {
重写方法
}
Employee a = new Employee() {
public void work() {}
}
a.work();
** 特点 **
匿名内部类是一个没有名字的内部类
匿名内部类写出来就会产生一个匿名内部类对象
匿名内部类的类型相当于当前new的那个类型的子类类型
public class Test {
public static void main(String[] args) {
Animal a = new Animal() {
@Override
public void run() {
System.out.println("run");
}
};
a.run();
}
}
abstract class Animal{
public abstract void run();
}
匿名内部类可以作为方法的实际参数进行传参
public class Test2 {
public static void main(String[] args) {
go(new Swiming() {
@Override
public void swim() {
System.out.println("学生蛙泳");
}
});
}
/*
* 学生、老师、运动员一起参加游泳比赛
* */
public static void go(Swiming s) {
System.out.println("开始");
s.swim();
System.out.println("结束");
}
}
interface Swiming {
void swim();
}