09 面向对象_多态&抽象类&接口

09.01_面向对象(多态的概述及其代码体现)

A:多态(polymorphic)概述
- 事物存在的多种形态
B:多态前提
- a:要有继承关系。
- b:要有方法重写。
- c:要有父类引用指向子类对象。
C:案例演示
- 代码体现多态

class Demo1_Polymorphic {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.eat();

		Animal a = new Cat();				//父类引用指向子类对象
		a.eat();  //猫吃鱼
	}
}

class Animal {
	public void eat() {
		System.out.println("动物吃饭");
	}
}

class Cat extends Animal {
	public void eat() {  //方法重写
		System.out.println("猫吃鱼");
	}
}

09.02_面向对象(多态中的成员访问特点之成员变量)

成员变量
- 编译看左边(父类)，运行看左边(父类)。
  
  f.num输出10，s.num输出20

09.03_面向对象(多态中的成员访问特点之成员方法)

成员方法
- 编译看左边(父类)，运行看右边(子类)。动态绑定

编译的时候看父类中有没有print方法，如果有，运行的时候执行的是子类中的print方法，如果没有就会直接报错

09.04_面向对象(多态中的成员访问特点之静态成员方法)

静态方法
- 编译看左边(父类)，运行看左边(父类)。
- (静态和类相关，算不上重写，所以，访问还是左边的)
- 只有非静态的成员方法,编译看左边,运行看右边

09.05_面向对象(超人的故事)

A:案例分析
- 通过该案例帮助学生理解多态的现象

09.06_面向对象(多态中向上转型和向下转型)

/*
		基本数据类型自动类型提升和强制类型转换
		*/
		int i = 10;
		byte b = 20;
		//i = b;						//自动类型提升（小的提升为大的，byte类型2个字节，int类型分配4个字节）
		//b = (byte)i;					//强制类型转换（精度降低）

A:案例演示
- 详细讲解多态中向上转型和向下转型
  Person p = new SuperMan();向上转型
  SuperMan sm = (SuperMan)p;向下转型

class Demo3_SuperMan {
	public static void main(String[] args) {
		Person p = new SuperMan();			//父类引用指向子类对象,超人提升为了人
											//父类引用指向子类对象就是向上转型
		System.out.println(p.name);
		p.谈生意();
		SuperMan sm = (SuperMan)p;			//向下转型
		sm.fly();
		//p.fly() 会出错，父类中没有，编译时会出错
		
		
	}
}

class Person {
	String name = "John";
	public void 谈生意() {
		System.out.println("谈生意");
	}
}

class SuperMan extends Person {
	String name = "superMan";

	public void 谈生意() {
		System.out.println("谈几个亿的大单子");
	}

	public void fly() {
		System.out.println("飞出去救人");
	}
}

向下转型以后，p的地址直接复制给了sm

09.07_面向对象(多态的好处和弊端)

A:多态的好处
- a:提高了代码的维护性(继承保证)
- b:提高了代码的扩展性(由多态保证)
B:案例演示
- 多态的好处
- 可以当作形式参数,可以接收任意子类对象
C:多态的弊端
- 不能使用子类的特有属性和行为。
D:案例演示
method(Animal a)
method(Cat c)

class Demo4_Animal {
	public static void main(String[] args) {
		method(new Cat());
		method(new Dog());

		//Animal a = new Cat();			开发的是很少在创建对象的时候用父类引用指向子类对象,
	                                    	//直接创建子类对象更方便,可以使用子类中的特有属性和行为
	}
	
	//Cat c = new Dog();狗是一只猫,这是错误的
	/*public static void method(Cat c) {			
		c.eat();
	}

	public static void method(Dog d) {
		d.eat();
	}*/
	
	//如果把狗强转成猫就会出现类型转换异常,ClassCastException
	public static void method(Animal a) {	//当作参数的时候用多态最好,因为扩展性强
		//关键字 instanceof 判断前边的引用是否是后边的数据类型
		if (a instanceof Cat) {
			Cat c = (Cat)a;//如果要调用子类特有方法，需要强制类型转换
			c.eat();
			c.catchMouse();
		}else if (a instanceof Dog) {
			Dog d = (Dog)a;
			d.eat();
			d.lookHome();
		}else {
			a.eat();
		}
	}
}

class Animal {
	public void eat() {
		System.out.println("动物吃饭");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}

	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}

	public void lookHome() {
		System.out.println("看家");
	}
}

09.08_面向对象(多态中的题目分析题)

A:看下面程序是否有问题，如果没有，说出结果

  class Fu {
  	public void show() {
  		System.out.println("fu show");
  	}
  }

  class Zi extends Fu {
  	public void show() {
  		System.out.println("zi show");
  	}

  	public void method() {
  		System.out.println("zi method");
  	}
  }

  class Test1Demo {
  	public static void main(String[] args) {
  		Fu f = new Zi();//编译看左边，运行看右边
  		f.method();//编译时出错
  		f.show();//zi show
  	}
  }

B:看下面程序是否有问题，如果没有，说出结果

  class A {
  	public void show() {
  		show2();
  	}
  	public void show2() {
  		System.out.println("我");
  	}
  }
  class B extends A {
  	public void show2() {
  		System.out.println("爱");
  	}
  }
  class C extends B {
  	public void show() {
  		super.show();
  	}
  	public void show2() {
  		System.out.println("你");
  	}
  }
  public class Test2DuoTai {
  	public static void main(String[] args) {
  		A a = new B();//编译看左边有show方法则编译通过，执行看右边，执行子类中的show方法，
  		//此show方法时继承父类的，父类中的show方法中有个show2方法调用的是子类的show2，故输出“爱”
  		a.show();
  		
  		B b = new C();
  		b.show();
  	}
  }

09.09_面向对象(抽象类的概述及其特点)

A:抽象类概述
- 抽象就是看不懂的
B:抽象类特点
- a:抽象类和抽象方法必须用abstract关键字修饰
  - abstract class 类名 {}
  - public abstract void eat();//直接分号没有大括号
- b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
- c:抽象类不能实例化那么，抽象类如何实例化呢?
  - 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。（父类引用指向子类对象）
- d:抽象类的子类
  - 要么是抽象类
  - 要么重写抽象类中的所有抽象方法

class Demo1_Abstract {
	public static void main(String[] args) {
		//Animal a = new Animal();			//错误: Animal是抽象的; 无法实例化
		Animal a = new Cat();				//父类引用指向子类对象
		a.eat();
	}
}

abstract class Animal {						//抽象类
	public abstract void eat();				//抽象方法

	public Animal() {
		System.out.println("父类空参构造");
	}
}

class Cat extends Animal {
	public Cat() {
		super();
	}
	public void eat() {//重写抽象类方法
		System.out.println("猫吃鱼");
	}
}

09.10_面向对象(抽象类的成员特点)

A:抽象类的成员特点
- a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
- b:构造方法：有。
  - 用于子类访问父类数据的初始化。
- c:成员方法：既可以是抽象的，也可以是非抽象的。
B:案例演示
- 抽象类的成员特点
C:抽象类的成员方法特性：
- a:抽象方法 强制要求子类做的事情。
- b:非抽象方法子类继承的事情，提高代码复用性。

09.11_面向对象(葵花宝典)

案例演示
- 抽象类的作用

09.12_面向对象(抽象类练习猫狗案例)

A:案例演示
- 具体事物：猫，狗
- 共性：姓名，年龄，吃饭
- 猫的特性:抓老鼠
- 狗的特性:看家

public class Demo2_Dollection {
	public static void main(String[] args) {
		Cat c = new Cat("加菲", 8);
		System.out.println(c.getName() + ".." + c.getAge());
		c.eat();
		c.catchMouse();
		
		Dog d=new Dog("八公",30);
		System.out.println(d.getName() + ".." + d.getAge());
		d.eat();
		d.lookHome();
	}
}

abstract class Animal {
	private String name;
	private int age;

	public Animal() {
	}

	public Animal(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return this.name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return this.age;
	}

	public abstract void eat();
}

class Cat extends Animal {
	public Cat() {
	}

	public Cat(String name, int age) {
		super(name, age);
	}

	public void eat() {
		System.out.println("猫吃鱼");
	}

	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public Dog() {
	}

	public Dog(String name, int age) {
		super(name, age);
	}

	public void eat() {
		System.out.println("狗吃肉");
	}

	public void lookHome() {
		System.out.println("看家");
	}
}

09.13_面向对象(抽象类练习老师案例)

A:案例演示
- 具体事物：基础班老师，就业班老师
- 共性：姓名，年龄，讲课。
- 具体事物:基础班学生,就业班学生
- 共性:姓名,年龄,学习

09.14_面向对象(抽象类练习员工案例)

A:案例演示
- 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
- 经理，除了含有程序员的属性外，另为还有一个奖金属性。
- 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。

class Test3_Employee {
	public static void main(String[] args) {
		Coder c = new Coder("德玛西亚","007",8000);
		c.work();

		Manager m = new Manager("苍老师","9527",3000,20000);
		m.work();
	}
}

abstract class Employee {
	private String name;					//姓名
	private String id;						//工号
	private double salary;					//工资

	public Employee() {}					//空参构造

	public Employee(String name,String id,double salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}

	public void setName(String name) {		//设置姓名
		this.name = name;
	}

	public String getName() {				//获取姓名
		return name;
	}

	public void setId(String id) {			//设置id
		this.id = id;
	}

	public String getId() {					//获取id
		return id;
	}

	public void setSalary(double salary) {	//设置工资
		this.salary = salary;
	}

	public double getSalary() {				//获取工资
		return salary;
	}

	public abstract void work();
}

//程序员
class Coder extends Employee {
	public Coder() {}					//空参构造

	public Coder(String name,String id,double salary) {
		super(name,id,salary);
	}

	public void work() {
		System.out.println("我的姓名是:" + this.getName() + ",我的工号是:" + this.getId() + ",我的工资是:" 
			+ this.getSalary() + ",我的工作内容是敲代码");
	}
}

//项目经理
class Manager extends Employee {
	private int bonus;					//奖金
	public Manager() {}					//空参构造

	public Manager(String name,String id,double salary,int bonus) {
		super(name,id,salary);
		this.bonus = bonus;
	}

	public void work() {
		System.out.println("我的姓名是:" + this.getName() + ",我的工号是:" + this.getId() + ",我的工资是:" 
			+ this.getSalary() + ",我的奖金是:" + bonus + ",我的工作内容是管理");
	}
}

09.15_面向对象(抽象类中的面试题)

A:面试题1
- 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
- 可以
- 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
B:面试题2
- abstract不能和哪些关键字共存

不能与static共存，被abstract修饰的方法没有方法体，被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
不能与final共存，被abstract修饰的方法强制让子类重写，final修饰的不让子类重写，矛盾
不能与private共存，被abstract修饰的是为了让子类看到并强制重写，被private修饰不让子类访问，矛盾

09.16_面向对象(接口的概述及其特点)

A:接口概述
- 从狭义的角度讲就是指java中的interface
- 从广义的角度讲对外提供规则的都是接口
B:接口特点
- a:接口用关键字interface表示
  - interface 接口名 {}
- b:类实现接口用implements表示
  - class 类名 implements 接口名 {}
- c:接口不能实例化
  - 那么，接口如何实例化呢?
  - 按照多态的方式来实例化。
- d:接口的子类
  - a:可以是抽象类。但是意义不大。
  - b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
C:案例演示
- 接口特点

class Demo1_Interface {
	public static void main(String[] args) {
		//Inter i = new Inter();		//接口不能被实例化,因为调用抽象方法没有意义
		Inter i = new Demo();			//父类引用指向子类对象
		i.print();
	}
}
interface Inter {
	public abstract void print();					//接口中的方法都是抽象的
}

class Demo implements Inter {
	public void print() {    //重写接口中的抽象方法
		System.out.println("print");
	}
}

09.17_面向对象(接口的成员特点)

A:接口成员特点
- 成员变量；只能是常量，并且是静态（可以用接口名.常量）的并公共的。
  * 默认修饰符：public static final //三个关键字可以互相交换位置
  * 建议：自己手动给出。
- 构造方法：接口没有构造方法。
- 成员方法：只能是抽象方法（没有方法体｛｝）。
  * 默认修饰符：public abstract
  * 建议：自己手动给出。
B:案例演示
- 接口成员特点

一个类不写继承任何类，默认继承Objedt类

09.18_面向对象(类与类,类与接口,接口与接口的关系)

A:类与类,类与接口,接口与接口的关系
- a:类与类：
  - 继承关系,只能单继承,可以多层继承。
- b:类与接口：
  - 实现关系,可以单实现,也可以多实现。
  - 并且还可以在继承一个类的同时实现多个接口。
- c:接口与接口：
  - 继承关系,可以单继承,也可以多继承。
B:案例演示
- 类与类,类与接口,接口与接口的关系

interface InterA {
	public abstract void printA();
}

interface InterB {
	public abstract void printB();
}

interface InterC extends InterB,InterA {
}
//class Demo implements InterA,implements InterB {		//这么做不允许是非法的
class Demo extends Object implements InterA,InterB {
	public void printA() {
		System.out.println("printA");
	}

	public void printB() {
		System.out.println("printB");
	}
}

09.19_面向对象(抽象类和接口的区别)

A:成员区别
- 抽象类：
  - 成员变量：可以变量，也可以常量
  - 构造方法：有
  - 成员方法：可以抽象，也可以非抽象
- 接口：
  - 成员变量：只可以常量
  - 成员方法：只可以抽象
B:关系区别
- 类与类
  - 继承，单继承
- 类与接口
  - 实现，单实现，多实现
- 接口与接口
  - 继承，单继承，多继承
C:设计理念区别
- 抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
- 接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

09.20_面向对象(猫狗案例加入跳高功能分析及其代码实现)

A:案例演示
- 动物类：姓名，年龄，吃饭，睡觉。
- 猫和狗
- 动物培训接口：跳高

class Test1_Animal {
	public static void main(String[] args) {
		Cat c = new Cat("加菲",8);
		c.eat();
		c.sleep();

		JumpCat jc = new JumpCat("跳高猫",3);
		jc.eat();
		jc.sleep();
		jc.jump();
	}
}
abstract class Animal {
	private String name;				//姓名
	private int age;					//年龄

	public Animal() {}					//空参构造

	public Animal(String name,int age) {//有参构造
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//设置姓名
		this.name = name;
	}

	public String getName() {			//获取姓名
		return name;
	}

	public void setAge(int age) {		//设置年龄
		this.age = age;
	}

	public int getAge() {				//获取年龄
		return age;
	}

	public abstract void eat();			//吃饭

	public abstract void sleep();		//睡觉
}

interface Jumping {						//跳高的接口
	public void jump();
}

class Cat extends Animal {
	public Cat() {}					//空参构造

	public Cat(String name,int age) {//有参构造
		super(name,age);
	}

	public void eat() {
		System.out.println("猫吃鱼");
	}

	public void sleep() {
		System.out.println("侧着睡");
	}
}

class JumpCat extends Cat implements Jumping {
	public JumpCat() {}					//空参构造

	public JumpCat(String name,int age) {//有参构造
		super(name,age);
	}

	public void jump() {
		System.out.println("猫跳高");
	}
}

09 面向对象_多态&抽象类&接口

09.01_面向对象(多态的概述及其代码体现)

09.02_面向对象(多态中的成员访问特点之成员变量)

09.03_面向对象(多态中的成员访问特点之成员方法)

09.04_面向对象(多态中的成员访问特点之静态成员方法)

09.05_面向对象(超人的故事)

09.06_面向对象(多态中向上转型和向下转型)

09.07_面向对象(多态的好处和弊端)

09.08_面向对象(多态中的题目分析题)

09.09_面向对象(抽象类的概述及其特点)

09.10_面向对象(抽象类的成员特点)

09.11_面向对象(葵花宝典)

09.12_面向对象(抽象类练习猫狗案例)

09.13_面向对象(抽象类练习老师案例)

09.14_面向对象(抽象类练习员工案例)

09.15_面向对象(抽象类中的面试题)

09.16_面向对象(接口的概述及其特点)

09.17_面向对象(接口的成员特点)

09.18_面向对象(类与类,类与接口,接口与接口的关系)

09.19_面向对象(抽象类和接口的区别)

09.20_面向对象(猫狗案例加入跳高功能分析及其代码实现)

猜你喜欢