Java基础_12接口【重点】和多态【重点】

今天的内容

1.接口【重点】

2.多态【重点】

1.接口【重点】

1.1生活中的接口

USB, 插排，等

起到的是扩展功能

咱们的电脑预留很多的接口，目的用来扩展硬件设备功能的。

1.2Java中的接口

语法格式：

interface 接口的名字{//和类特别像
    变量
    方法
}

入门案例

package com.qf.a_interface;

interface Knife {//水果刀接口
	//the blank final field size may not have been initialized
	//在接口中所有的属性都应该是常量   默认的
	//接口下面的属性很少用
	int SIZE = 3;
	 
	 //方法  Abstract methods do not specify a body
	//在接口中抽象的方法 居多  他把abstract 关键字 给省去了
	//  public abstract void cutFruit();
	void cutFruit ();
}
interface AK47 {
	void shootLions();
}
//发现接口暂时不能实例化，咋办？
//一定要新建一个类去实现（implements）接口
class Person implements Knife, AK47{

	@Override
	public void cutFruit() {
		// TODO Auto-generated method stub
		System.out.println("拿刀切水果");
	}

	@Override
	public void shootLions() {
		// TODO Auto-generated method stub
		System.out.println("射狮子");
	}
	
}
public class Demo1 {
	public static void main(String[] args) {
		//Knife knife = new Knife();
		Person person1 = new Person();
		person1.cutFruit();
		person1.shootLions();
	}
}

1.3Java接口中细节

1.接口的声明使用关键字interface

2.接口是有属性和方法

​ 属性是 static final 修饰的常量 默认的 可以不用写

​ 方法 是抽象的方法 public abstract 省去了

3.接口没有构造方法，无法进行实例化

4.无法进行实例化，新建一个普通类去实现（implements）接口，必须重写所有抽象的方法

5.自从jdk1.8之后，接口下面的方法有一些新的特性，方法可以带方法体只不过是默认（default修饰的）的方法，凡是带有方法体的方法，不需要必须重写的！！！

6.一个类能不能实现多个接口？ 可以的 在implments 后面 接多个接口 使用逗号隔开

7.一个接口可以去继承（extends） ，可以使用多继承

​ 类 和接口 之间用 implements

​ 接口和接口之间用 extends

package com.qf.a_interface;


interface A {
	void testA ();
}


interface B extends A, C{//一个接口 可以继承多个接口的   
	int a = 34;//a就是常量  必须得先赋值的  因为 final  用的很少
	
	void testB ();
	
	default void test () {//jdk1.8的新特性
		System.out.println("测试方法B");
	}
	
}
interface C {
	void testC ();
}
class D implements B, C {

	@Override
	public void testB() {
		// TODO Auto-generated method stub
		System.out.println("执行中testB方法");
	}
	@Override
	public void test() {
		System.out.println("测试方法d");
	}
	@Override
	public void testC() {
		// TODO Auto-generated method stub
		System.out.println("执行cz中testc方法");
	}
	@Override
	public void testA() {
		// TODO Auto-generated method stub
		
	}
}
public class Demo2 {
	public static void main(String[] args) {
		D d = new D();
		d.test();
	}
}

案例:

电脑类:

​ 三个接口: 鼠标 键盘 网络接口

package com.qf.a_interface;

interface Mouse {
	void mouse();//插鼠标功能
}
interface KeyBoard {
	void keydown();//连接键盘
}
interface Net{
	void inNet();//联网的功能
}
class Computer implements Mouse, KeyBoard, Net{

	@Override
	public void inNet() {
		// TODO Auto-generated method stub
		System.out.println("电脑可以连接网络");
	}

	@Override
	public void keydown() {
		// TODO Auto-generated method stub
		System.out.println("电脑链接键盘");
	}

	@Override
	public void mouse() {
		// TODO Auto-generated method stub
		System.out.println("电脑插入鼠标");
	}
	
}
public class Demo3 {
	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.inNet();
		computer.mouse();
		computer.keydown();
	}
}

回顾上午的内容

1.
interface A {
	void test();
}
class TestA implments A {
	public void test () {
		System.out.println("hello TestA");
	}
}

2.多态【重点】

Java有三大特性: 封装 继承 多态

2.1多态的概念

通俗来说，多种形态。具体完成某一个行为。当不同的对象去完成时候，会产生不同的状态。

总的来说: 同一件事情，发生在不同的对象上面，会有不同的结果。

2.2多态

1.方法的多态

2.对象的多态

2.2.1方法的多态

方法的重载和重写就是多态的体现形式

package com.qf.b_duotai;

class Person {
	String name;
	public void eat () {
		System.out.println("吃吧嘻嘻");
	}
	public void eat(String name) {
		System.out.println(name + "吃吧嘻嘻");
	}
}
class Man extends Person {
	@Override
	public void eat() {
		System.out.println("儿子吃吧嘻嘻");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		
	}
}

2.2.2对象的多态

父类的引用 指向子类的对象,也叫向上转型。

语法格式:

父类 对象名 = new  子类();

package com.qf.b_duotai;

class Father {
	public void eat () {
		System.out.println("吃窝窝头");
	}
	
}
class Son1 extends Father {
	@Override
	public void eat() {
		System.out.println("吃面条");
	}
	public void test() {
		System.out.println("哈哈");
	}
}
class Son2 extends Father {
	@Override
	public void eat() {
		System.out.println("吃大米饭");
	}
}
public class Demo2 {
	public static void main(String[] args) {
		//父类的引用指向子类的对象
		//父类 对象 = new 子类();
		// 同一件事情，发生在不同的对象上面，会有不同的结果
		Father father1 = new Son1();
		father1.eat();
		//父类的引用是指向不了子类独有的方法的！！！
		//只能调用 重写父类的方法
		//father1.test();
		Father father2 = new Son2();
		father2.eat();
		
		//总结： 多态的前提条件:
		//1.必须在继承体系下面
		//2.子类必须去重写父类的方法
		//3.父类的引用去调用子类重写方法
	}
}

真实开发的时候:

方法的参数（形参）是父类的引用，但是调用方法的传的实参是 子类的真实对象

案例:

​ 人喂狗，狗吃

​ 人喂猫，猫吃

package com.qf.b_duotai;

class People {
	//方法的参数是父类的引用，实参是子类的对象
//	public void feed (Dog dog) {
//		dog.eat();
//	}
//	public void feed (Cat cat) {
//		cat.eat();
//	}
	
	//总结： 多态的前提条件:
			//1.必须在继承体系下面
			//2.子类必须去重写父类的方法
			//3.父类的引用去调用子类重写方法
	
	//
	public void feed (Animal animal) {
		animal.eat();
	}
}
class Animal {
	public void eat () {
		System.out.println("动物在吃");
	}
}
class Dog extends Animal{
	@Override
	public void eat () {
		System.out.println("狗吃狗粮");
	}
}
class Cat extends Animal{
	@Override
	public void eat () {
		System.out.println("猫吃老鼠");
	}
}

public class Demo3 {
	public static void main(String[] args) {
		People people = new People();
		
		people.feed(new Dog());
		people.feed(new Cat());
		
		/**(
		 * public void feed (Animal animal) {
				animal.eat();
			}
			实参是  new Dog() 对象
			形参是  Animal animal
			Animal animal = new Dog();
			animal.eat()
			
			实参是new Cat() 对象
			形参是  Animal animal
			将实参赋值给形参
			
			Animal animal = new Cat();
			animal.eat();
		 */
	}
}

总结：

1.得有继承
2.得有重写
3.方法的形参呢是父类的引用
4.调用方法的时候是子类的真实对象====》父类的引用指向了子类的对象

练习:

三个类:

​ 1.学生类

​ 2.老师类

​ 3.普通员工类

以上三个都有一个共同的行为: 执行手册

老板去管理这些人

Boss manage 学生，学生执行手册

Boss manage 老师，老师执行手册

Boss manage 普通员工，普通员工执行手册

使用多态。

package com.qf.b_duotai;

class ManKind {//人类
	public void execute() {
		System.out.println("守规矩");
	}
}
class Student extends ManKind{
	public void execute() {
		System.out.println("执行学员手册");
	}
}
class Teacher extends ManKind{
	public void execute() {
		System.out.println("执行教师手册");
	}
}
class Employee extends ManKind{
	public void execute() {
		System.out.println("执行员工手册");
	}
}
class Boss {
	//方法的形参是父类的引用
	public void manager (ManKind manKind) {
		manKind.execute();
	}
	
}
public class Demo4 {
	public static void main(String[] args) {
		Boss boss = new Boss();
		boss.manager(new Student());
		boss.manager(new Teacher());
		boss.manager(new Employee());
	}
}

编写程序实现比萨制作。需求说明编写程序，可供选择的比萨有：培根比萨和海鲜比萨。

实现思路及关键代码

1. 分析培根比萨和海鲜比萨

2. 定义比萨类

3. 属性：名称、价格、大小

4. 方法：展示

5. 定义培根比萨和海鲜比萨继承自比萨类

6. 定义比萨工厂类，根据输入信息产生具体的比萨对象
   PizzaFactory {
   createPizza(Pizza pizza);//如果传的参数培根披萨就是生产培根披萨 如果传的是海鲜披萨就是生产的海鲜披萨
   }

使用多态

以上讲的的多态的核心

2.2.3多态的转型

1.多态的向上转型

2.多态的向下转型

2.2.3.1多态的向上转型

本质： 本质 就是 父类的引用指向子类的对象。Person p= new Student(); Person是student类的父类

会自动转。 将子类的对象赋值给父类的引用。 小范围(Student) 转为 大范围(Person),可以自动转换

小杯子里面倒入大杯子 不会溢出 是安全的。所以可以自动。

2.2.3.2多态的向下转型

语法格式:

父类   父类的引用 = new 子类;
子类  对象 = (子类)父类引用;

package com.qf.c_duotai;

class Person{
	public void eat () {
		System.out.println("人在吃饭");
	}
}
class Student extends Person {
	@Override
	public void eat() {
		System.out.println("学生吃的好");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		//java.lang.ClassCastException: 类转换异常 
		//com.qf.c_duotai.Person cannot be cast to com.qf.c_duotai.Student
		//Person类不能转为 student类
		//大范围转小范围 是会出错的。 咋办？
		//1.先向上转型 再向下转型！！！
		Person person = new Student();//向上转型
		Student student = (Student) person;//向下转型
		
		
		Student  stu = new Student();
		
	}
}

package com.qf.c_duotai;

class People {
	String str = "12";
	public  void feed (Animal animal) {
		animal.eat();
		Cat cat = (Cat)animal;//向下转型
		cat.sleep();
	}
}
class Animal {
	public void eat() {
		System.out.println("吃饭");
	}
}
class Dog extends Animal{
	public void eat() {
		System.out.println("吃饭");
	}
	//sleep是子类独有的方法
	public void sleep() {
		System.out.println("狗睡吧睡吧");
	}
}
class Cat extends Animal {
	public void eat() {
		System.out.println("吃饭");
	}
	//sleep是子类独有的方法
		public void sleep() {
			System.out.println("猫睡吧睡吧");
		}
}
public class Demo2 {
	public static void main(String[] args) {
		People people = new People();
		/**
		 * public  void feed (Animal animal) {
			animal.eat();//因为是eat是重写方法
			Dog dog = (Dog)animal;//向下转型
			dog.sleep();
	}		
		实参是   new  Dog()
		形参是  Animal  animal
		实参赋值形参   Animal  animal =  new  Dog(); 向上转型
	Dog dog = (Dog)animal;//向下转型
	
		 */
		people.feed(new Cat());
	}
}

instanceof