day12

1.抽象类的声明
abstract class  类名 {
	普通的成员方法;
	抽象方法;
}
2.关于声明和使用抽象类得注意事项（共9条）
	1.使用abstarct修饰的类叫抽象类
	2.抽象类下面有抽象方法和普通方法
	3.抽象方法是没有方法体的
	4.抽象累不能被实例化
	5.写一个普通类去继承它
	6.去实现所有抽象方法
	7.非抽象方法也可以重写
	8.一个抽象类可以继承另外一个抽象类的
	9.抽象类可以继承非抽象类
3.final关键字（5tiao）
	1.final修饰成员变量
	2.final修饰局部变量
	3.final修饰成员方法
	4.final修饰类
	5.final对象引用
4.接口得声明语法格式
5.关于声明和使用接口的注意事项（共9条）
6.super关键字得使用
	super调用父类的属性和方法
	super调用父类构造方法

回顾

掌握到什么程度：
	1.抽象类
	2.final
	3.接口
1.抽象类
abstract class Person {
	public abstract void eat ();
	public abstract void sleep();
	public void work() {
	sout();
	}
}
class Man extends Perso {
	public void eat () {
	
	}
	public void sleep() {
	
	}
	
}
main {
	Man man = new Man ();
	man.eat();
	man.sleep();
	man.work();
}

2.接口
interface A {
	void eat();
	void sleep();
	
}
class TestA implements A, B {
	public void eat () {
	
	}
	public void sleep() {
	
	}
}
main {
	
}

今天的内容

1.多态

1.Java中的多态

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

多态: 多种形态。是面向对象的三大特性之一。多态是建立在封装和继承之上

1.1方法的多态【非重点】

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

package com.qfedu.a_fun;

class Person {
	public void eat () {
		System.out.println("吃饭");
	}
	public void eat (String food) {
		System.out.println("吃" + food);
	}
}
class Man extends Person {
	@Override
	public void eat() {
		System.out.println("吃枸杞");
	}
	@Override
	public void eat(String food) {
		System.out.println("吃"+ food);
	}
}
public class Demo1 {
	public static void main(String[] args) {
		
	}

}

1.2对象的多态【重点】

1.一个对象 的编译类型和运行类型是不一样
2.编译类型是在定义对象的时候，就已经确定好的
3.运行类型是可以改变的
4.编译类型看=的左边  运行类型看 =的右边
Person person = new Person();

多态: 父类引用指向子类的对象

Animal animal = new Dog();

Animal anima1 = new Cat();

package com.qfedu.b_duotai;

class Animal {
	public void cry () {
		System.out.println("动物在叫......");
	}
}
class Dog extends Animal {
	@Override
	public void cry() {
		System.out.println("汪汪汪......");
	}
	//自己独有的方法
	public void eat () {
		System.out.println("狗吃shit");
	}
}
class Cat extends Animal {
	@Override
	public void cry() {
		System.out.println("喵喵喵.....");
	}
	public void sleep () {
		System.out.println("睡觉打呼噜");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		//多态   父类的引用指向子类的对象
		Animal animal = new Dog();
		animal.cry();
		//父类的引用是指向不了子类独有的方法的，就意味着
		//父类的引用不能调用子类独有的方法
		//animal.eat();
		Animal animal2 =  new Cat();
		animal2.cry();
		//animal2.sleep();
	}

}

注意事项：

? 多态：

1.必须有继承

2.必须有重写

3.=左边是父类引用 =右边是子类的对象

1.3父类的引用指向子类的对象在开发中如何使用

之前有一个作业 : 人喂狗，狗吃饭。 人喂猫，猫吃饭

package com.qfedu.c_duotai;

class Person {
//	public void feed (Dog dog) {
//		dog.eat();
//	}
//	public void feed (Cat cat) {
//		cat.eat();
//	}
	//在开发中，一个方法的参数是父类的引用。但是真正传的值是子类的对象
	
	public void feed (Animal animal) {
		animal.eat();
	}
}
interface Animal {
	public void eat ();
}
class Dog implements Animal{
	@Override
	public void eat () {
		System.out.println("狗在吃骨头......");
	}
}
class Cat implements Animal{
	@Override
	public void eat () {
		System.out.println("猫吃鱼......");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		
		Person person = new Person();
		/**
		 * Animal animal = new Cat();
		 * public void feed (Animal animal) {
				animal.eat();
			}
		 */
		person.feed(new Cat());
		/**
		 * Animal animal = new Dog();
		 * public void feed (Animal animal) {
				animal.eat();
			}
		 */
		person.feed(new Dog());
	}

}

Person类
Student类 千锋学员
	方法  执行学生手册
Teacher类  千锋讲师
	方法 执行讲师手册
Employee  千锋的员工
	方法  执行员工手册
Manager 管理层
	管理学生  讲师  员工
	manage();

package com.qfedu.c_duotai;

class Manager {//管理层 去管理学员  讲师 员工
	public void manage (Person1 person1) {
		person1.excute();
	}
//	public void manage (Teacher tea) {
//		tea.excute();
//	}
//	public void manage (Employee emp) {
//		emp.excute();
//	}
}
interface Person1 {
	void excute();
}
class Student implements Person1{
	public void excute () {
		System.out.println("执行学员手册。。。。");
	}
}
class Teacher implements Person1{
	public void excute () {
		System.out.println("执行讲师手册。。。。。");
	}
}
class Employee implements Person1{
	public void excute () {
		System.out.println("执行员工手册。。。。。");
	}
}
public class Demo2 {
	public static void main(String[] args) {
		Person1 person1 = new Student();
		Manager manager = new Manager();
		manager.manage(person1);
	}

}

案例

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

实现思路及关键代码

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

2) 定义比萨类

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

4) 方法：展示

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

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

package com.qfedu.c_duotai;

class Pizza {
	private String name;//名字
	private double price;//价格
	private double size;//尺寸
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public double getSize() {
		return size;
	}
	public void setSize(double size) {
		this.size = size;
	}
	
	//展示方法
	public void getInfo () {
		
	}
}
class BaconPizza extends Pizza{
	@Override
	public void getInfo() {
		System.out.println("披萨的名字为:" + getName() + ",披萨的价格:" + getPrice() + ",披萨的尺寸:" + getSize());
	}
}
class SeaPizza extends Pizza {
	@Override
	public void getInfo() {
		System.out.println("披萨的名字为:" + getName() + ",披萨的价格:" + getPrice() + ",披萨的尺寸:" + getSize());
	}
}
//披萨的生产工厂
class PizzaFactory {
	//生产披萨的方法
	public void createPizza (Pizza pizza) {
		pizza.getInfo();
	}
	
}
public class Demo3 {
	public static void main(String[] args) {
		Pizza pizza = new SeaPizza();
		pizza.setName("海鲜披萨");
		pizza.setPrice(78.9);
		pizza.setSize(6.7);
		PizzaFactory pizzaFactory = new PizzaFactory();
		pizzaFactory.createPizza(pizza);
		//生产培根披萨
		Pizza pizza2 = new BaconPizza();
		pizza2.setName("培根披萨");
		pizza2.setPrice(45.9);
		pizza2.setSize(7.2);
		pizzaFactory.createPizza(pizza2);
	}

}

1.4多态的转型【重点】

1.4.1多态的向上转型

本质就是：父类的引用指向子类对象

语法格式：

? 父类 父类引用 = new 子类（）；

将子类的对象赋值给了父类的引用。小范围（子类） 转为大范围（父类）自动转

父类的引用可以调用父类的所有成员方法，可以调用子类的重写父类的方法，但是不能调用子类独有的方法。

package com.qfedu.d_duotai;

class Person {
	public void eat () {
		
	}
}
class Student extends Person {
	@Override
	public void eat() {
		System.out.println("学生吃饭，吃披萨");
	}
	public void sleep () {
		System.out.println("中午不谁下午崩溃！！！");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Person person = new Student();//向上转型
		person.eat();
		//person.sleep();
	}

}

1.4.2多态向下转型

语法格式：

父类类型 父类引用 = new  子类();
子类类型 子类引用 = (子类类型)父类的引用;向下转型

需要强转

package com.qfedu.d_duotai;

class TestA {
	//Object 是所有类的父类
	public void test (Object obj ) {
		//必须给我打印一个String类型的狗蛋，我不要Object类型的狗蛋
//		String str = (String) obj; 
//		System.out.println(str);
		int i1 = (int)obj;
		System.out.println(i1);
		
	}
}
public class Demo4 {
	public static void main(String[] args) {
		TestA testA = new TestA();
		//testA.test("狗蛋");
		Object object = "狗蛋";
		testA.test(98);
		testA.test('狗');
	}

}

回顾上午的

1.多态
	父类的引用指向子类的对象
	父类引用  对象 =  new  子类();
	
	真实的开发的时候，一个方法的参数传的是一个类的父类对象形参。但是真正调用这个
	方法的时候，传的是子类对象。实参
2.
	向上转型=====》 父类引用指向了子类的对象  子类赋值给父类引用
	向下转型=====》将父类的引用赋值给子类    父类赋值给子类引用
		注意点:
			先向上转型，再向下转型

1.5instanceof 关键字

比较操作符，返回值是布尔类型的数据

语法格式:

对象引用  instanceof  运行类型

用来判断对象的运行类型（=右边）， 是否是xx类型或者xx类型的子类

目的是为了在强转的时候不出现问题

package com.qfedu.e_instanceof;

class AA {}
class BB extends AA {}
public class Demo1 {
	public static void main(String[] args) {
		BB bb = new BB();
		BB bb1 = new BB();
		AA aa = new AA();
		//instanceof  的左边放的对象的引用，右边是类
		System.out.println(bb instanceof BB);//true
		System.out.println(bb1 instanceof BB);//true
		//判断对象bb是否是AA的对象或者子类的对象
		System.out.println(bb instanceof AA);//true
		System.out.println(aa instanceof AA);//true
		System.out.println(aa instanceof BB);//false
		//总结： 左边 的辈分小（对象的引用）  右边辈分大（类）  屡试不爽
		AA aa2 = new BB();
		System.out.println(aa2 instanceof AA);//true
		System.out.println(aa2 instanceof BB);//true
		
		//
		Object object = new Object();
		System.out.println(object instanceof AA);//false
		System.out.println(object instanceof Object);//true
		
		String string = "qwer";
		System.out.println(string instanceof Object);//true
	}
}

package com.qfedu.e_instanceof;

class Employee {}
class Monkey {
	//这个方法的返回值是一个字符串
	public String xixi(Object obj) {
		//Object obj = new String("狗蛋");
		//obj  instanceof String
		if (obj instanceof String) {
			String string = (String)obj;
			return "传给我的 参数是字符串类型的数据";
		}  else if (obj instanceof Integer) {
			Integer i1 = (Integer)obj;
			return "传给我的 参数是int类型的数据";
		} else if (obj instanceof Employee) {
			Employee employee = (Employee)obj;
			return "传给我的参数是一个Employee对象";
		}
		else {
			return "参数不合法";
		}
		
		
	}
}
public class Demo3 {
	public static void main(String[] args) {
		Monkey monkey = new Monkey();
		//System.out.println(monkey.xixi("狗蛋"));
		
		//System.out.println(monkey.xixi(89));
		Employee employee = new Employee();
		System.out.println(monkey.xixi(employee));
		String string = new String();
	}

}

作业：

1.把昨天的抽象类 接口  多态  好好总结一下。查一些博客
2.今天的多态也要写博客或者知乎文章
3.等会我发作业