JAVA day08:多态和接口笔记

一、多态：

定义：

一个对象具有多种状态的行为

实现：

//1.要有继承，子类继承父类

 //2.要有重写，子类重写父类方法

//3.父类的引用指向子类的对象

代码举例：

//父类
public class Animal {
	public void speak(){
		System.out.println("动物都叫");
	}
}

//子类1
public class Cat extends Animal{
    @Override
	public void speak(){
		System.out.println("喵喵喵");
	}
}

//子类2
public class Dog extends Animal{
	@Override
	public void speak(){
		System.out.println("汪汪汪");
	}
}

//子类3
public class Person extends Animal{
    @Override
	public void speak(){
		System.out.println("啊啊啊啊");
	}
}

//测试类
public class Test {
	public static void main(String[] args) {
		Dog d=new Dog();
		Cat c=new Cat();
		Person p=new Person();
		//父类方法不适用需要子类
		d.speak();
		c.speak();
		p.speak();
		
		Animal a=new Animal();
		System.out.println(a.toString());
		
		//1.要有继承，子类继承父类
		//2.要有重写，子类重写父类方法
		3.父类的引用指向子类的对象
		Animal anl=new Animal();
		anl=new Person();
		anl.speak();
		anl=new Dog();
		anl.speak();
		anl=new Cat();
		anl.speak();
	}
}

多态好处：

易于扩展 编写变得很简单 

二、向上转型和向下转型

分类：

向上转型和向下转型

自动性：

向上转型是子转父（自动）

向下转型是父转子（强制，且必须是向上转型过的才能向下）

区别：

向上转型，父类引用只能调用子类重写的方法，不能调用子类特有的方法，如果想调用必须向下转型

向下转型后可以调用子类特有的方法。

写法：

//向上转型：父类类型 对象名=new 子类类型();

Animal a=new Cat()

Animal a=new Dog()

//向下转型：子类类型 对象名=(子类类型)父类对象名

Animal a=new Cat();

Cat c=(Cat)a;

作用：

向上转型是java多态中的一个重要内容，多态是编写易于维护、扩展的程序的重要底层支撑。

向下转型一般是为了重新获得因为向上转型而丢失的子类特性而存在；因此，通常在向下转型前常有向上转型，而向下转型通常也会结合instanceof一起使用。借由向下转型，可以在灵活应用多态的基础上，同时兼顾子类的独有特征。

instanceof关键字，用于进行对象类型校验

为了避免ClassCastException的发生，Java提供了instanceof关键字，用于进行对象类型校验

用法：对象名 instanceof 数据类型

如果对象属于该类型，返回是true

如果对象不属于该型，返回是false

三、父类子类成员重名时的访问

当父类的对象引用指向子类的对象时，假设父类为Person，子类为Student，有下面的两行定义:;
student sTest = new student();
Person pTest = sTest;
其中，pTest就是父类的对象引用，sTest是子类的对象引用; pTest和sTest指向了同一个子类对象。那么，

1.成员变量;

如果子类的成员变量与父类的成员变量的类型及名称都相同，则用sTesti访问时，访问到的是子类的成员变量;用pTest访问时，访问到的是父类的成员变量;

2.静态成员变量

如果子类的静态成员变量与父类的静态成员变量的类型及名称都相同，则用sTest访问时，访问到的是子类的静态成员变量;用pTest访问时，访问到的是父类的静态成员变量;

3.静态成员方法

如果子类的静态成员方法重写了父类的静态成员方法，则用sTest调用时，调用的是子类的静态成员方法;用pTest调用时，调用的是父类的静态成员方法;

4.成员方法

如果子类的成员方法重写了父类的成员方法，则用sTest调用时，调用到的是子类的成员方法;用pTest调用时，调用的也是子类的成员方法;此时称为覆盖，即使父类对象引用调用时也只能看到子类重写后的方法;

二、接口 

 右键->new->Interface

定义

接口(interface) 是Java语言中一种引用类型, 是方法集合，如果说类封装了成员变量，成员方法和构造方法，那么接口封装了方法（没有构造方法，有属性 ，但不是重点）

目的

接口的目的就是为了实现多态（父类的方法子类重写之后 ，有多种实现方式）

接口使用

它不能创建对象，使用接口必须由子类实现（implements)，

子类必须必须要实现接口所有抽象方法。

接口就是确保多态实现的固定的语法格式（多态-子类方法重写->方法集合固定语法格式-接口）

抽象类（确保继承 abstract class 父类 abstract method 抽象方法 延迟到子类方法重写）

实现的概述

类与接口关系为实现关系，即类实现接口，该类可以被称之叫接口实现类，也可以称接口的子类， 实现的动作：就是继承 ，只不过，关键字 extends implements

package JieKou;
//防火的接口
//接口中的方法都是公共的抽象方法
public interface Fire {
	//防火的功能
	public abstract void fangHuo();
}

public interface Bullet {
	//防子弹的功能
	public abstract void fangDan();
}

public interface Water {
	//防水的功能
	public abstract void fangShui();
}

package JieKou;
//接口不用extends,用implements，相当于实现多继承,不同接口用逗号隔开
public class Door implements Fire,Water,Bullet{
	public void open(){
		System.out.println("能开门");
	}
	public void close(){
		System.out.println("能关门");
	}
	@Override
	public void fangHuo() {
		System.out.println("能防火");
	}
	@Override
	public void fangShui() {
		System.out.println("能防水");
	}
	@Override
	public void fangDan() {
		System.out.println("能防弹");
	}
}

public class Test {
	public static void main(String[] args) {
		Door d=new Door();
		d.fangHuo();
		d.fangShui();
		d.fangDan();
	}
}