###08.01_面向对象(多态的概述及其代码体现)
* A:多态(polymorphic [,pɒlɪ'mɔːfɪk])概述
* 事物存在的多种形态
* 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("猫吃鱼");
}
}
###08.02_面向对象(多态中的成员访问特点之成员变量)
* 成员变量
* 编译看左边(父类)，运行看左边(父类)。
/*
成员变量
编译看左边(父类),运行看左边(父类)
成员方法
编译看左边(父类)，运行看右边(子类)。动态绑定
静态方法
编译看左边(父类)，运行看左边(父类)。
(静态和类相关，算不上重写，所以，访问还是左边的)
只有非静态的成员方法,编译看左边,运行看右边
*/
案例：
class Demo2_Polymorphic {
public static void main(String[] args) {
Father f = new Son(); //父类引用指向子类对象
System.out.println(f.num); //相当于是Father.method()
Son s = new Son();
System.out.println(s.num);
}
}
class Father {
int num = 10;
}
class Son extends Father {
int num = 20;
}
###08.03_面向对象(多态中的成员访问特点之成员方法)
* 成员方法
* 编译看左边(父类)，运行看右边(子类)。
案例：
class Demo2_Polymorphic {
public static void main(String[] args) {
Father f = new Son();
f.print(); //相当于是Father.method()
}
}
class Father {
int num = 10;
public void print() {
System.out.println("father");
}
}
class Son extends Father {
int num = 20;
public void print() {
System.out.println("son");
}
}
###08.04_面向对象(多态中的成员访问特点之静态成员方法)
* 静态方法
* 编译看左边(父类)，运行看左边(父类)。
* (静态和类相关，算不上重写，所以，访问还是左边的)
* 只有非静态的成员方法,编译看左边,运行看右边
案例：
class Demo2_Polymorphic {
public static void main(String[] args) {
Father f = new Son();
f.method(); //相当于是Father.method()
}
}
class Father {
int num = 10;
public static void method() {
System.out.println("father static method");
}
}
class Son extends Father {
int num = 20;
public static void method() {
System.out.println("son static method");
}
}
###08.05_面向对象(超人的故事)
* A:案例分析
* 通过该案例帮助学生理解多态的现象（talkTrade:谈生意）
案例：
class Demo3_SuperMan {
public static void main(String[] args) {
Person p = new SuperMan(); //父类引用指向子类对象,超人提升为了人
//父类引用指向子类对象就是向上转型
System.out.println(p.name);
p.talkTrade();
}
}
class Person {
String name = "John";
public void talkTrade() {
System.out.println("谈生意");
}
}
class SuperMan extends Person {
String name = "superMan";
public void talkTrade() {
System.out.println("谈几个亿的大单子");
}
public void fly() {
System.out.println("飞出去救人");
}
}
###08.06_面向对象(多态中向上转型和向下转型)
* 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.talkTrade();
SuperMan sm = (SuperMan)p; //向下转型
sm.fly();
/*
基本数据类型自动类型提升和强制类型转换
*/
int i = 10;
byte b = 20;
//i = b; //自动类型提升
//b = (byte)i; //强制类型转换
}
}
class Person {
String name = "John";
public void talkTrade() {
System.out.println("谈生意");
}
}
class SuperMan extends Person {
String name = "superMan";
public void talkTrade() {
System.out.println("谈几个亿的大单子");
}
public void fly() {
System.out.println("飞出去救人");
}
}
###08.07_面向对象(多态的好处和弊端)
* A:多态的好处
* a:提高了代码的维护性(继承保证)
* b:提高了代码的扩展性(由多态保证)
* B:案例演示
* 多态的好处
* 可以当作形式参数,可以接收任意子类对象
* C:多态的弊端
* 不能使用子类的特有属性和行为。
* D:案例演示
案例：
class Demo4_Animal {
public static void main(String[] args) {
//Cat c1 = new Cat();
//c1.eat();
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("看家");
}
}
###08.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();
}
}错误 多态中父类无法子类的特有方法
* 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();
a.show();//爱
B b = new C();
b.show();//你
}
}
###08.09_面向对象(抽象类的概述及其特点)
* A:抽象类概述
* 抽象就是看不懂的
* B:抽象类特点
* a:抽象类和抽象方法必须用abstract关键字修饰
* abstract class 类名 {}
* public abstract void eat();//当不知道该方法具体是怎么实现的
//比如动物吃，你知道它吃什么吗？怎么吃？都不知道
* b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
* c:抽象类不能实例化那么，抽象类如何实例化呢?
* 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
* d:抽象类的子类
* 要么是抽象类
* 要么重写抽象类中的所有抽象方法
* C:案例演示
* 抽象类特点
案例：
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("猫吃鱼");
}
}
###08.10_面向对象(抽象类的成员特点)
* A:抽象类的成员特点
* a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
* b:构造方法：有。
* 用于子类访问父类数据的初始化。
* c:成员方法：既可以是抽象的，也可以是非抽象的。
* B:案例演示
* 抽象类的成员特点
* C:抽象类的成员方法特性：
* a:抽象方法 强制要求子类做的事情。
* b:非抽象方法 子类继承的事情，提高代码复用性。
案例：
class Demo2_Abstract {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
abstract class Demo {
int num1 = 10;//变量
final int num2 = 20;//常量
public Demo(){}//构造方法
public void print() {//非抽象方法，子类可以直接使用
System.out.println("111");
}
public abstract void method();//抽象方法，子类必须实现
}
class Test extends Demo {
public void method() {
System.out.println("111");
}
}
###08.11_面向对象(葵花宝典)
* 案例演示
* 抽象类的作用
class Demo3_葵花宝典 {
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("用锤子,不忍直视");
}
}
###08.12_面向对象(抽象类练习猫狗案例)
* A:案例演示
* 具体事物：猫，狗
* 共性：姓名，年龄，吃饭
* 猫的特性:抓老鼠
* 狗的特性:看家
案例：
class Test1_Animal {
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 name;
}
public void setAge(int age) { //设置年龄
this.age = age;
}
public int getAge() { //获取年龄
return 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("看家");
}
}
###08.13_面向对象(抽象类练习老师案例)
* A:案例演示
* 具体事物：基础班老师，就业班老师
* 共性：姓名，年龄，讲课。
* 具体事物:基础班学生,就业班学生
* 共性:姓名,年龄,学习
案例：
class Test2_Teacher {
public static void main(String[] args) {
BaseTeacher bt = new BaseTeacher("冯佳",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 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 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基础");
}
}
###08.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 + ",我的工作内容是管理");
}
}
###08.15_面向对象(抽象类中的面试题)
* A:面试题1
* 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
* 可以
* 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
* B:面试题2
* abstract不能和哪些关键字共存
案例：
class Demo4_Abstract {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
/*
* A:面试题1
* 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
* 可以
* 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
* B:面试题2
* abstract不能和哪些关键字共存
abstract和static
被abstract修饰的方法没有方法体
被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
abstract和final
被abstract修饰的方法强制子类重写
被final修饰的不让子类重写,所以他俩是矛盾
abstract和private
被abstract修饰的是为了让子类看到并强制重写
被private修饰不让子类访问,所以他俩是矛盾的
*/
abstract class Demo {
//public static abstract void print(); //错误: 非法的修饰符组合: abstract和static
//public final abstract void print(); //错误: 非法的修饰符组合: abstract和final
private abstract void print(); //错误: 非法的修饰符组合: abstract和private
}
###08.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");
}
}
###08.17_面向对象(接口的成员特点)
* A:接口成员特点
* 成员变量只能是常量，并且是静态的并公共的。
* 默认修饰符：public static final
* 建议：自己手动给出。
* 构造方法：接口没有构造方法。
* 成员方法：只能是抽象方法。
* 默认修饰符：public abstract
* 建议：自己手动给出。
* B:案例演示
* 接口成员特点
案例：
class Demo2_Interface {
public static void main(String[] args) {
Demo d = new Demo();
d.print();
System.out.println(Inter.num);
}
}
interface Inter {
public static final int num = 10;
//public Inter(){} 接口中没有构造方法
/*public void print() { 接口中不能定义非抽象方法
}*/
public abstract void print();
}
class Demo /*extends Object*/ implements Inter { //一个类不写继承任何类,默认继承Object类
public void print() {
//num = 20;
System.out.println(num);
}
public Demo() {
super();
}
}
###08.18_面向对象(类与类,类与接口,接口与接口的关系)
* A:类与类,类与接口,接口与接口的关系
* a:类与类：
* 继承关系,只能单继承,可以多层继承。
* b:类与接口：
* 实现关系,可以单实现,也可以多实现。
* 并且还可以在继承一个类的同时实现多个接口。
* c:接口与接口：
* 继承关系,可以单继承,也可以多继承。
* B:案例演示
* 类与类,类与接口,接口与接口的关系
案例：
class Demo3_Interface {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
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");
}
}
###08.19_面向对象(抽象类和接口的区别)
* A:成员区别
* 抽象类：
* 成员变量：可以变量，也可以常量
* 构造方法：有
* 成员方法：可以抽象，也可以非抽象
* 接口：
* 成员变量：只可以常量
* 成员方法：只可以抽象
* B:关系区别
* 类与类
* 继承，单继承
* 类与接口
* 实现，单实现，多实现
* 接口与接口
* 继承，单继承，多继承
* C:设计理念区别
* 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
* 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
* 对事物本质的抽象用抽象类，对事物功能的扩展用接口
###08.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("猫跳高");
}
}
什么是 多态
重写
extends
父类对象引用指向子类对象
sruper s = (Super).Person 强制转换
有向下的才有向下的，
默认的是this，
出现了狗是一只猫所以定义一个方法 public static void method(Animal a) method(new (Cat));
调用完之后还会现有些动物无法执行，需用到 if(.. instanceof ..)
两道面试题
只有方法看子类，其它都看父类，注意默认有super
abstract 抽象就是不知道怎么实现
1，可以抽象类也可以抽象方法
2，不能实例化 但可以用多态、父引向指
3，重写抽象类中所有方法 或把类改成abstract
4,abstract 不能修饰成员变量（比如颜色怎么抽象），成员方法既可以是抽象的也可以是非抽象
的
5，abstract 有构造方法
6，abstract 强制重写父类方法
面试题
没有抽象方法的抽象类就是不让其它对象创建本类对象
interface 接口
0，接口的成员只能是常量 默认修饰符 public static final;
1，接口中的方法都是抽象的 (默认都会加上abstract)
2, 用implements实现 （class ....implements...）
3, 接口不能实例化，因为调用抽象方法没有意思 （用多态实现）
4，接口可以不重写方法，但是要抽象类 （abstract 类）
5，接口的是实现 （干爹）
6，接口的的变量都是常量 (默认修饰符pulic static final )
7，接口没有构造方法 （默认继承object）
8, 接口都是公共的,父类中都会默认public abstract ，但是子类要加上
class JumpCat extends Cat implements Jumping{}
类与类
继承关系，单继承，多层继承
类接口
实现关系， 可单 ，可多，可以同时实现、用逗号隔开
接口
可单，可多
抽象 is s 共性
接口 like a 扩展
扫一扫
852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
