面向对象小节2

一、 多态

1.1 定义

同一个对象（事物），在不同时刻体现出来的状态。

1.2 前提

A.要有继承关系或者实现关系

B.要有方法重写

C.要有父类引用指向子类对象  父 f = new子（）

1.3 成员访问特点

A.成员变量

编译看左边 运行看左边

B.构造方法

创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化

C.成员方法（成员方法有重写）

编译看左边 运行看右边

D. 静态方法

编译看左边 运行看左边

1.4 弊端及改进

弊端：不能使用子类的特有功能

改进：

A. 创建子类对象调用方法 Zi z = new Zi( )

B. 把父类的引用强制转换为子类的引用（向下转型）

Zi z = (Zi) f

 

多态例子：

   */

class A {

public void show() {

show2();

}

public void show2() {

System.out.println("我");

}

}

class B extends A {

/*

public void show() {

show2();

}

*/

 

public void show2() {

System.out.println("爱");

}

}

class C extends B {

public void show() {

super.show();

}

public void show2() {

System.out.println("你");

}

}

public class DuoTaiTest4 {

public static void main(String[] args) {

A a = new B();

a.show();

B b = new C();

b.show();

}

}

继承的时候：

子类中有和父类中一样的方法，叫重写。

子类中没有父亲中出现过的方法，方法就被继承过来了。

因此运行结果：爱你

二、抽象类

2.1 定义

把一个不是具体的功能称为抽象的功能。一个类中，如果有抽象的功能，该类必须是抽象类。

2.2 特点

A. 抽象类和抽象方法必须用abstract修饰

B. 抽象类中不一定有抽象方法，但有抽象方法的类必须定义为抽象类

C. 抽象类不能实例化

D. 抽象类的子类

a. 如果不重写抽象方法，抽象类的子类是抽象的

b. 如果重写所有的方法，这个时候子类是一个具体的类

2.3 成员特点

A. 成员变量：可以变量，可以常量

B. 构造方法：有 用于子类访问父类数据的初始化

C. 成员方法：可以抽象，可以非抽象

抽象类成员方法的特性：

抽象方法：强制要求子类做的事

非抽象方法：子类继承的事，提高代码的复用性

抽象类例子

abstract class Animal {

//姓名

private String name;

//年龄

private int age;

public Animal() {}

public Animal(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 Dog extends Animal {

public Dog() {}

public Dog(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("狗吃肉");

}

}

 

//定义具体的猫类

class Cat extends Animal {

public Cat() {}

public Cat(String name,int age) {

super(name,age);

}

public void eat() {

System.out.println("猫吃鱼");

}

}

 

//测试类

class AbstractTest {

public static void main(String[] args) {

//测试狗类

//具体类用法

//方式1：

Dog d = new Dog();

d.setName("旺财");

d.setAge(3);

System.out.println(d.getName()+"---"+d.getAge());

d.eat();

//方式2：

Dog d2 = new Dog("旺财",3);

System.out.println(d2.getName()+"---"+d2.getAge());

d2.eat();

System.out.println("---------------------------");

//方式3：

Animal a = new Dog();

a.setName("旺财");

a.setAge(3);

System.out.println(a.getName()+"---"+a.getAge());

a.eat();

Animal a2 = new Dog("旺财",3);

System.out.println(a2.getName()+"---"+a2.getAge());

a2.eat();

三、接口

3.1 特点

A. 接口用关键字interface表示

Interface 接口名 ｛｝

B. 类实现接口用implements表示

 Class 类名implements接口名｛｝

C. 接口不能实例化

按照多态的方式实现实例化

D. 接口的子类

a. 可以抽象类，意义不大（不能实例化）

b. 可以具体类，要重写接口中的所有抽象方法

3.2 成员特点

A. 成员变量：只能是常量，并且是静态的

默认修饰符：public static final

建议：手动给出

B. 构造方法：接口没有构造方法

C. 成员方法：只能是抽象方法

默认修饰符：public abstract

建议：手动给出

 

接口例子：

 

*/

//定义动物培训接口

interface AnimalTrain {

public abstract void jump();

}

 

//抽象类实现接口

abstract class Dog implements AnimalTrain {

}

 

//具体类实现接口

class Cat implements AnimalTrain {

public void jump() {

System.out.println("猫可以跳高");

}

}

 

class InterfaceDemo {

public static void main(String[] args) {

//AnimalTrain是抽象的;无法实例化

//AnimalTrain at = new AnimalTrain();

//at.jump();

AnimalTrain at = new Cat();

at.jump();

}

}