09.01 面向对象(多态的概述及其代码实现)
A.多态概述(ploymorphic)
事物存在的多种形态
B.多态前提
a.要有继承
b.要有方法重写
c.要有父类引用子类对象
C.案例演示
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_01 { 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("Animal eat"); } } class Cat extends Animal{ public void eat(){ System.out.println("Cat eat"); } }
09.02 面向对象(多态的成员访问特点)
A.多态中的成员方法特点
a.成员变量
编译看左,运行看左
b.成员方法(指的是非静态的成员方法)
编译看左,运行看右
c.静态方法
编译看左,运行看左
(静态和类相关,算不上重写,所以,访问还是看右边)
B.案例演示
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_02 { public static void main(String[] args) { Father f = new Son(); System.out.println(f.num); } } //成员变量,(父类引用指向子类对象)左左 class Father { int num = 10; } class Son extends Father{ int num = 20; } public class day09_02 { public static void main(String[] args) { Father f = new Son(); f.print(); } } //成员方法,(父类引用指向子类对象)左右 class Father { public void print(){ System.out.println("father"); } } class Son extends Father{ public void print(){ System.out.println("Son"); } } --------------------------------- public class day09_02 { public static void main(String[] args) { Father f = new Son(); f.method(); } } //静态得到,(父类引用指向子类对象)左左 class Father { public static void method(){ System.out.println("father static method"); } } class Son extends Father{ public static void method(){ System.out.println("Son static method"); } }
09.03 面向对象(多态的概述及其代码实现)
成员方法
编译看左,运行看右
09.04 面向对象(多态的概述及其代码实现)
静态方法
编译看左,运行看左
09.05 面向对象(超人的故事)
A.案例演示
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_05 { /*基本数据类型自动类型提升和强制类型转换 * int i = 10; * byte b = 20; * i=b; //自动类型提升byte--> int * b=byte()i; //强制类型提升int -->byte */ public static void main(String[] args) { SuperMan p =new SuperMan(); System.out.println(p.name); p.Tlak(); //无法用 p.fly()调用子类的fly()方法,因为编译看左,父类没有fly(),编译失败 SuperMan sm = (SuperMan)p; sm.fly(); } } class Person{ String name = "John"; public void Tlak(){ System.out.println("tlak bussiness"); } } class SuperMan extends Person{ String name = "SuperMan"; public void Tlak(){ System.out.println("tlak Son class"); } public void fly(){ System.out.println("fly out"); } }
![](https://i-blog.csdnimg.cn/blog_migrate/a2145c194f4521b06fe1ce48a8a03af1.png)
09.06 面向对象(多态的向上转型和向下转型)
Person p = new Person()
SuperMan sm = (SuperMan)p;
09.07 面向对象(多态的好处和弊端)
A.多态的好处
a.提高了代码的复用性
b.提高了代码的拓展性
B.案例演示
多态的好处
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_07 { public static void main(String[] args) { method(new Cat7()); method(new Dog7()); } /*public static void method(Cat7 c){ c.eat(); }*/ public static void method(Animal7 a){ // a.eat(); //调用子类共有的属性 //如果先调用子类特有的属性呢? //关键字 :instanceof,判断前面的引用是否是后边的数据类型 if(a instanceof Cat7){ Cat7 c = (Cat7)a; c.eat(); c.catchMouse(); } } } class Animal7{ public void eat(){ System.out.println("Animal eat fish"); } } class Cat7 extends Animal7{ public void eat(){ System.out.println("Cat eat fish"); } public void catchMouse(){ System.out.println("catch Mouse"); } } class Dog7 extends Animal7{ public void eat(){ System.out.println("Dog eat rou"); } public void LookHome(){ System.out.println("LookHome"); } }
C.多态的弊端
不能使用子类的特有属性和行为
D.案例演示
method(Animal a)
method(Cat c)
09.08 面向对象(多态的题目分析)
09.09 面向对象(抽象类的概述机器特点)
A.抽象类概述
当你无法描述一个类时,就将她定义为抽象的。抽象就是看不懂的。抽象就是看不懂的(********)
B.抽象类特点
a.抽象类和抽象方法必须使用abstract关键字来修饰
abstract class 类名{}
public abstract void eat();
b.抽象类不一定由抽象方法,有抽象方法的类一定是抽象类或者接口
c.抽象类不能被实例化,那么抽象类如何实例化呢?
按照多态的方式,由句体的子类实例化。其实这也是多态的一种,抽象类多态
d.抽象类的子类
要么抽象类
要么是重写抽象类中所有抽象方法(一般选择这种方式)(**********)
C.案例演示
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_09 { /*a.抽象类和抽象方法必须使用abstract关键字来修饰 abstract class 类名{} public abstract void eat(); b.抽象类不一定由抽象方法,有抽象方法的类一定是抽象类或者接口 c.抽象类不能被实例化,那么抽象类如何实例化呢? 按照多态的方式,由句体的子类实例化。其实这也是多态的一种,抽象类多态 d.抽象类的子类 要么抽象类 要么是重写抽象类中所有抽象方法(一般我们这么使用) */ public static void main(String[] args) { // Animal9 a = new Animal9(); //抽象方法不能实例化 //用父类引用指向子类对象来调用子类方法 Animal9 a = new Cat9(); a.eat(); } } abstract class Animal9{ //抽象类 public abstract void eat(); //抽象方法 } class Cat9 extends Animal9{ public void eat(){ System.out.println("Cat eat fish"); } }
09.10 面向对象(抽象类的成员特点)
A.抽象类的成员特点
a.成员变量:既可以是变量,也可以是常量。abstract不能修饰成员变量
b.构造方法:有。用于子类访问父类数据的初始化
c.成员方法:抽象,非抽象都可以
B.案例特点
09.10 面向对象(抽象类的成员特点)
A.抽象类的成员特点
a.成员变量:既可以是变量,也可以是常量。abstract不能修饰成员变量
b.构造方法:有。用于子类访问父类数据的初始化
c.成员方法:抽象,非抽象都可以
B.案例特点
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
09.10 面向对象(抽象类的成员特点) A.抽象类的成员特点 a.成员变量:既可以是变量,也可以是常量。abstract不能修饰成员变量 b.构造方法:有。用于子类访问父类数据的初始化 c.成员方法:抽象,非抽象都可以 B.案例特点 09.11 面向对象(岳不群,东方不败) 09.12 面向对象(猫狗类) 09.13 面向对象(老师类) 09.14 面向对象(员工类) 假如我们再开发一个系统程序是需要堆程序员进行设计,程序员包括3个属性:姓名/工号/工资 经理,除了含有程序员的属性外,还有一个奖金属性 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/ 09.15 面向对象(抽象类中的面试题) 面试题: 1.一个抽象类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义? 可以。这么做的目的只有一个,就是不让其他类创建本类对象,交给子类完成 2.abstract不能和哪些关键字共存、、 abstract和static/final,private static。被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的 final。 被abstract修饰的方法强制子类重写,被final修饰的不让子类重写 private.被abstract修饰的是为了让子类看到并强制重写 09.16 面向对象(接口的概述及其特点) A. B.接口特点 a:接口关键字:interface。 使用方式: interface 接口名 {} b:类实现接口:implements 使用方法: class 类名 implements 接口名 {} c:接口不能实例化。所以可以按照多态的方式进行实例化 d:接口的子类:可以是抽象类(意义不大),可以是具体类,要重写接口中的所有抽象方法(********) C.案例演示 09.17 面向对象(接口的成员特点) A.接口成员特点 成员变量:只能是常量,并且是静态的公共的 默认修饰符是:public static final 建议:自己手动给出 构造方法:无 成员方法:只能是抽象方法 建议:自己手动给出 09.18 接口与接口,类 的关系 A.类与类,类与接口,接口与接口 a.类与类: 继承关系。只能单继承 b.类与接口: 实现关系,单实现和多实现 c.接口与接口:继承关系,单继承和多继承 09.19 面向对象(抽象类和接口的区别) A.成员区别 抽象类: 成员变量:可以变量也可以常量 构造方法:有 成员方法:可以抽象,可以非抽象 接口: 成员变量:只能常量 成员方法:只能抽象 C.设计理念: 抽象类:体现的是:“is a” 接口 : 体现的是:“like a” 09.20 面向对象(猫狗类) A.案例演示<猫狗类> 动物类: 姓名 年龄 吃饭 睡觉 猫和狗 动物培训接口:跳高
09.11 面向对象(岳不群,东方不败)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_11 { public static void main(String[] args) { 岳不群 小岳子 = new 岳不群(); 小岳子.自宫(); } } abstract class 葵花宝典{ //抽象类 public abstract void 自宫(); //定义抽象方法 } class 岳不群 extends 葵花宝典{ public void 自宫(){ //必须重写父类的抽象方法 System.out.println("用牙签"); } } class 林平之 extends 葵花宝典{ public void 自宫(){ //必须重写父类的抽象方法 System.out.println("用指甲刀"); } } class 东风不败 extends 葵花宝典{ public void 自宫(){ //必须重写父类的抽象方法 System.out.println("用锤子"); } }
09.12 面向对象(猫狗类)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_12 { public static void main(String[] args) { Cat12 c = new Cat12("加菲猫",80); System.out.println(c.getName() + "..." + c.getAge()); c.eat(); c.catchMouse(); Dog12 d = new Dog12("八公",20); d.eat(); d.LookHome(); } } abstract class Animal12{ private String name; private int age; // public Animal12(){} public Animal12(String name,int age){ this.name = name; this.age = age; } // public String getName(){ return name; } public void setName(String name){ this.name =name; } public int getAge(){ return age; } public void setAge(int age){ this.age = age; } // public abstract void eat(); //抽象方法必须放在抽象类种 } class Cat12 extends Animal12{ public Cat12(){} public Cat12(String name,int age){ super(name,age); } public void eat(){ //必须重写父类的抽象方法 System.out.println("Cat eat"); } public void catchMouse(){ System.out.println("catch mouse"); } } class Dog12 extends Animal12{ public Dog12(){} public Dog12(String name,int age){ super(name,age); } public void eat(){ //必须重写父类的抽象方法 System.out.println("dog eat rou"); } public void LookHome(){ System.out.println("look home"); } }
09.13 面向对象(老师类)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_13 { public static void main(String[] args) { BaseTeacher bt = new BaseTeacher("fengjia",18); bt.teach(); } } abstract class Teacher{ private String name; private int age; // public Teacher(){} public Teacher(String name,int age){ this.name = name; this.age = age; } // public String getName(){ return name; } public void setName(String name){ this.name =name; } public int getAge(){ return age; } public void setAge(int age){ this.age = age; } public abstract void teach(); } class BaseTeacher extends Teacher{ public BaseTeacher(){} public BaseTeacher(String name,int age){ super(name,age); } public void teach(){ System.out.println("我的姓名是:"+ this.getName() + ",我的年龄是:"+ this.getAge()+",讲的内容是Java基础"); } }
09.14 面向对象(员工类)
假如我们再开发一个系统程序是需要堆程序员进行设计,程序员包括3个属性:姓名/工号/工资
经理,除了含有程序员的属性外,还有一个奖金属性
请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_14 { public static void main(String[] args) { Coder c = new Coder("demaxiya",8,8000,5000); c.work(); } } /*假如我们再开发一个系统程序是需要堆程序员进行设计,程序员包括3个属性:姓名/工号/工资 * 经理,除了含有程序员的属性外,还有一个奖金属性 * 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/ class Employee{ private String name; private int id; private double salary; public Employee(){} public Employee(String name,int id,double salary){ this.name = name; this.id = id; this.salary=salary; } // public String getName(){ return name; } public void setName(String name){ this.name =name; } public int getId(){ return id; } public void setId(int id){ this.id = id; } public double getSalary(){ return salary; } public void setSalary(double salary){ this.salary = salary; } } class Coder extends Employee{ private int bonus; //定义本类的成员变量 public Coder(){} public Coder(String name,int id,double salary,int bonus){ super(name,id,salary); this.bonus = bonus; //this进行赋值 } public void work(){ System.out.println("我的姓名是:"+ this.getName() + ",我的工号是:"+this.getId()+",我的工资是:"+this.getSalary()+",我的奖金是:"+this.bonus); } }
09.15 面向对象(抽象类中的面试题)
面试题:
1.一个抽象类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
可以。这么做的目的只有一个,就是不让其他类创建本类对象,交给子类完成
2.abstract不能和哪些关键字共存、、
abstract和static/final,private
static。被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
final。 被abstract修饰的方法强制子类重写,被final修饰的不让子类重写
private.被abstract修饰的是为了让子类看到并强制重写
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_15 { /** 面试题: 1.一个抽象类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义? 可以。这么做的目的只有一个,就是不让其他类创建本类对象,交给子类完成 2.abstract不能和哪些关键字共存、、 abstract和static/final,private static。被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的 final。 被abstract修饰的方法强制子类重写,被final修饰的不让子类重写 private.被abstract修饰的是为了让子类看到并强制重写 */ public static void main(String[] args) { } } /*abstract class Demo{ //public static abstract void print();//错误,这是不能共存的 //public final abstract void print();//错误,这是不能共存的 //private abstract void print(); /错误,这是不能共存的 }*/
09.16 面向对象(接口的概述及其特点)
A.
B.接口特点
a:接口关键字:interface。 使用方式: interface 接口名 {}
b:类实现接口:implements 使用方法: class 类名 implements 接口名 {}
c:接口不能实例化。所以可以按照多态的方式进行实例化
d:接口的子类:可以是抽象类(意义不大),可以是具体类,要重写接口中的所有抽象方法(********)
C.案例演示
09.17 面向对象(接口的成员特点)
A.接口成员特点
成员变量:只能是常量,并且是静态的公共的
默认修饰符是:public static final
建议:自己手动给出
构造方法:无
成员方法:只能是抽象方法
建议:自己手动给出
09.18 接口与接口,类 的关系
A.类与类,类与接口,接口与接口
a.类与类: 继承关系。只能单继承
b.类与接口: 实现关系,单实现和多实现
c.接口与接口:继承关系,单继承和多继承
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_18 { public static void main(String[] args) { } } interface InterA{ public abstract void printA(); } interface InterB{ public abstract void printB(); } class Demo18 implements InterA{ public void printA(){ System.out.println("printA"); } public void printB(){ System.out.println("printB"); } }
09.19 面向对象(抽象类和接口的区别)
A.成员区别
抽象类:
成员变量:可以变量也可以常量
构造方法:有
成员方法:可以抽象,可以非抽象
接口:
成员变量:只能常量
成员方法:只能抽象
C.设计理念:
抽象类:体现的是:“is a”
接口 : 体现的是:“like a”
09.20 面向对象(猫狗类)
A.案例演示<猫狗类>
动物类: 姓名 年龄 吃饭 睡觉
猫和狗
动物培训接口:跳高
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
package day09; public class day09_20 { public static void main(String[] args) { Cat20 c = new Cat20("加菲猫",20); c.eat(); c.sleep(); System.out.println("-------------------"); JumpCat jc = new JumpCat("调高猫",30); jc.eat(); jc.sleep(); jc.jump(); } } /*A.案例演示<猫狗类> 动物类: 姓名 年龄 吃饭 睡觉 猫和狗 动物培训接口:调高*/ abstract class Animal20{ private String name; private int age; public Animal20(){} public Animal20(String name,int age){ this.name = name; this.age = age; } public String getName(){ return name; } public void setName(String name){ this.name =name; } public int getAge(){ return age; } public void setAge(int age){ this.age = age; } public abstract void eat(); //1.抽象方法必须放在抽象类种 public abstract void sleep(); } interface Jumping{ //实现一个接口 public void jump(); } //用猫继承动物 class Cat20 extends Animal20{ public Cat20(){} public Cat20(String name,int age){ super(name,age); } public void eat(){ //2.必须重写父类的抽象方法 System.out.println("Cat eat"); } public void sleep(){ System.out.println("sleep"); } } //跳猫JumpCat先继承Cat20后继续Jumping class JumpCat extends Cat20 implements Jumping{ public JumpCat(){} public JumpCat(String name,int age){ super(name,age); } public void jump(){ //3.必须重写 接口中的方法 System.out.println("猫跳高"); } }