Java学习之面向对象三

Posted 2020-09-28 Vanguard

1、多态是什么，多态的前提条件是什么?

     多态就是父类引用变量指向子类对象；

     前提条件：必须有子父类关系或类实现接口关系；

2、多态中成员访问的特点分别是什么?
     成员变量：

      当子父类中出现同名的成员变量，多态调用该变量时，

       编译时期：参考的是引用变量所属的类中是否有被调用的成员变量。没有编译失败；

      运行时期：也是调用引用型变量所属的类中的成员变量；

      简单记：运行编译看左边。
　  成员方法(非静态方法)

       编译时期：参考引用变量所属的类，如果没有类中调用的方法，便以失败；

      运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的方法；

      简单记：编译看左边，运行看右边。
     静态方法

     编译时期：参考引用变量所属的类中是否有调用的静态方法；

     运行时期：参考引用变量所属的类中是否有调用的静态方法；

     简单记：编译运行都看左边；

     其实对于静态方法，是不需要对象的。直接用类名调用即可。

3、什么是接口，它的特点是什么？

     接口是功能的集合，同样可以看做是一种数据类型，是比抽象类更为抽象的“类”;

     接口只描述应该具备的方法，并没有具体实现，具体的实现由接口的实现类来完成。这样就实现了功能 的定义与实现分离，优化了程序设计。

    一切事物均有功能，即一切事物皆有接口。

4、接口的成员特点有哪些？

     1. 接口中可以定义变量，但是变量必须有固定的修饰符修饰 public static final，

　　 固定格式：public static final 数据类型 变量名 = 值；

        所以接口中的变量也称为常量，其值不能被改变。

        注意：修饰符 public static final 在接口变量定义中可以省略不写；

        但是，不写不等于没有；

        三个修饰符也可以选择性书写。

     2. 接口中可以定义方法，方法也有固定的修饰符，public abstract

         固定格式：public abstract 返回值类型 方法名（）；

         修饰符 public abstract，可以不写，也可以选择性书写

         但是，写与不写，都有

     3. 实现类实现接口，重写接口中全部的抽象方法，创建实现类对象

         实现类重写了一部分抽象方法，实现类还是一个抽象类

　  4. 接口不可以创建对象 

5、抽象类和接口的区别是什么?

     相同点：

     都位于继承的顶端，用于被其他类实现或继承；

     都不能实例化对象；

     都包含抽象放大，其子类都必须重写这些抽象方法。

     区别：

     抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码的重用性；接口只包含抽象方法；

 　 一个类只能继承一个直接父类（可能是父类），可以实现多个接口；接口弥补了Java的单继承；

     抽象类是这个事物中应该具备的内容，继承体系是is...a关系；

     接口是这个事物额外的功能，继承体系是一种 like...a关系。

     二者选用：

     优先选用接口，尽量少用抽象类；

　  需要定义子类的行为，又要为子类提供共性功能时才选用抽象类。

6、定义一个父类Animal eat方法 , 定义两个子类 Dog 特有方法keepHome , Cat 特有方法 catchMouse ;并且 重写eat方法
测试类中写一个方法,参数列表有一个参数Animla类型,
要求: 调用该方法分别传递Dog对象 和Cat 对象, 使用instanceof进行将转后调用eat,和他们的特有方法

/**
 * Animal类
 * @author vanguard
 *
 */
public abstract class Animal {
    public abstract void eat();
}

1 public class Dog extends Animal {
2     public void eat() {
3         System.out.println("狗吃狗粮");
4     }
5     public void keepHome() {
6         System.out.println("狗看家");
7     }
8 }

public class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃猫粮");
    }
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

 1 /**
 2  * 测试类中写一个方法,参数列表有一个参数Animla类型
 3  * @author vanguard
 4  *
 5  */
 6 public class Test {
 7     public static void pet(Animal a) {
 8         if(a instanceof Dog) {
 9             Dog d = (Dog)a;
10             d.eat();
11             d.keepHome();
12         }
13         if(a instanceof Cat) {
14             Cat c = (Cat)a;
15             c.eat();
16             c.catchMouse();
17         }
18     }
19     public static void main(String[] args) {
20         pet(new Dog());
21         pet(new Cat());
22     }
23 }

 

7.测试: 如果一个方法的返回值类型是父类,那么能否返回一个子类对象.(该父类不管是类,抽象类还是接口)

　

public class Fu {
    public void show() {
        System.out.println("父类show方法");
    }
}

public class Zi extends Fu {
    public void show() {
        System.out.println("子类show方法");
    }
}

public class Test {
    public static Fu test(Zi z) {
        return z;
    }
    public static void main(String[] args) {
        Zi z = (Zi) test(new Zi());
    }
}

经过测试，如果一个方法的返回值类型是父类,那么能返回一个子类对象。

　
8.现有两种 OldPhone NewPhone; 两个类都有call() sendMessage() 方法(考虑向上抽取一个父类);
已知接口IPlay中有一个方法 playGame()，NewPhone添加玩游戏的功能;
要求: 分别测试OldPhone和NewPhone的两个方法,再测试新手机palyGame()的方法.

/**
 * Phone的抽象类
 * 功能：
 * call
 * sendMessage
 * @author vanguard
 *
 */
public abstract class Phone {
    public abstract void call();
    public abstract void sendMessage();
}

/**
 * 接口IPlay
 * 方法：playGame()
 * @author vanguard
 *
 */
public interface IPlay {
    public abstract void playGame();
}

/**
 * OldPhone类继承Phone重写call()、sendMessage()
 * @author vanguard
 *
 */
public class OldPhone extends Phone {
    public void call() {
        System.out.println("旧手机打电话");
    }
    public void sendMessage() {
        System.out.println("旧手机发信息");
    }
}

/**
 * NewPhone类继承Phone重写call()、sendMessage()，
 * 实现IPlay接口，重写PlayGame()
 * @author vanguard
 *
 */
public class NewPhone extends Phone implements IPlay {
    public void call() {
        System.out.println("新手机打电话");
    }
    public void sendMessage() {
        System.out.println("新手机发信息");
    }
    public void playGame() {
        System.out.println("新手机玩游戏");
    }
}

/**
 * 测试类
 * 分别测试OldPhone和NewPhone的两个方法,再测试新手机palyGame()的方法.
 * @author vanguard
 *
 */
public class Test {
    public static void main(String[] args) {
        OldPhone op = new OldPhone();
        op.call();
        op.sendMessage();
        
        NewPhone np = new NewPhone();
        np.call();
        np.sendMessage();
        np.playGame();
    }
}

 

9 .(完成下面的汽车案例)
描述：汽车都具有跑的功能，普通的奥迪车也不例外，但是高端的奥迪车除了具有跑的功能外，还具有自动泊车和无人驾驶的功能！
需求：定义普通奥迪车，高端奥迪车，实现描述中的功能并测试

 

/**
 * 定义汽车的抽象类
 * @author vanguard
 *
 */
public abstract class Car {
    public abstract void run();
}

 

/**
 * 其他功能的接口
 * 自动泊车
 * 自动驾驶
 * @author vanguard
 *
 */
public interface OtherFunction {
    public abstract void parkAssist();
    public abstract void autopilot();
}

/**
 * 普通奥迪类
 * @author vanguard
 *
 */
public class AudiCar extends Car {
    public void run() {
        System.out.println("普通奥迪车跑");
    }
}

/**
 * 高端奥迪类
 * @author vanguard
 *
 */
public class HAudiCar extends Car implements OtherFunction {
    public void run() {
        System.out.println("高端奥迪车跑");
    }
    public void parkAssist() {
        System.out.println("自动泊车");
    }
    public void autopilot() {
        System.out.println("自动驾驶");
    }
}

/**
 * 测试类
 * @author vanguard
 *
 */
public class Test {
    public static void main(String[] args) {
        AudiCar ac = new AudiCar();
        ac.run();
        
        HAudiCar hc = new HAudiCar();
        hc.run();
        hc.parkAssist();
        hc.autopilot();
    }
}