java基础学习day 9

java基础学习day 9（final关键字，多态，抽象，接口）

1:final关键字可以干什么?有什么特点?
可以修饰方法，类，变量
特点

 - final可以修饰类，该类不能被继承
 - final可以修饰方法，该方法不能被重写（复写、覆盖）

2:final关键字的面试题?
A:修饰局部变量

 - 基本类型：基本类型的值不能发生变化
 - 引用类型：地址值不会发生变化，但该对象的堆内存的值是可以发生变化的

B:初始化时机

 - 被final修饰的变量只能被赋值一次
 - 在构造方法完毕之前（非静态的常量）
 - 

3:多态是什么，前提是什么?
多态就是同一个对象在不同时刻下体现出来的不同状态
前提：

• 要有继承关系
• 要有方法重写

动物 d = new dog();
d.show();

• 要有父类引用指向子类对象

父类 d = new 子类();

4:多态中成员访问的特点?
成员变量:
成员方法
静态方法
只有成员方法因为有方法重写，所以编译看右边

5:多态的好处及弊端？如何解决多态的弊端？
好处：

• 提高了代码的维护性（由继承保障）
• 提高了代码的扩展性（由多态保证）

弊端：

• 不能使用子类的特有功能

解决：

• 创建子类对象调用方法（太占用内存）
• 把父类的引用强制转化为子类的引用（向下转型）

6:什么是向上转型？什么是向下转型？
向上转型：

父 d = new 子();

向下转型：

子 z = (子）d;//要求d是必须能转化为z的

7:多态练习

猫狗案例代码如下：

class Animal {
    public void eat(){
        System.out.println("eat");
    }

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

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

    public void sleep(){
        System.out.println("狗站着睡觉");
    }
}

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

    public void sleep() {
        System.out.println("猫趴着睡觉");
    }
}
//针对动物操作的工具类
class AnimalTool {
    private AnimalTool(){}

    public static void useAnimal(Animal a) {
        a.eat();
        a.sleep();
    }
}
class DuoTaiDemo{
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.sleep();
        System.out.println("--------------");
        AnimalTool.useAnimal(d);
    }
}

8:抽象类概述及其特点?

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

    A:抽象类和抽象方法必须用abstract关键字修饰
    B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
    C:抽象类不能实例化
        因为它不是具体的。
        抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢?
        用于子类访问父类数据的初始化
    D:抽象的子类
        a:如果不想重写抽象方法，该子类是一个抽象类。
        b:重写所有的抽象方法，这个时候子类是一个具体的类。

    抽象类的实例化其实是靠具体的子类实现的。是多态的方式。

9:抽象类成员特点?

    成员变量：既可以是变量，也可以是常量。
    构造方法：有。
                用于子类访问父类数据的初始化。
    成员方法：既可以是抽象的，也可以是非抽象的。

10:抽象类练习

动物狗代码如下：

abstract class Animal{
    public int num = 10;
    public final int num2 = 20;
    public Animal(){}
    public Animal(String name,int age){}
    public abstract void show();
    public void method(){
        System.out.println("method");
    }
}
class Dog extends Animal{
    public void show(){
        System.out.println("show dog");
    }
}
public class AbstractDemo {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.num = 100;
        System.out.println(a.num);
        //a.num2 = 200;
        System.out.println(a.num2);
        System.out.println("--------------");
        a.show();
        a.method();
    }
}

11:抽象类的小问题
A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

可以，不让创建对象。

abstract不能和哪些关键字共存

private（冲突）
final（冲突）
static（无意义）

12:接口的概述及其特点?

特点：
A:接口用关键字interface表示

interface 接口名 {}

B.类实现接口用implements表示

class 类名 implements 接口名 {}

C.接口不能实例化
那么接口如何实例化呢？按照多态的方式来实例化

D.接口的子类
a.可以是抽象类，但是意义不大
b.可以是具体类。要重写接口中的所有抽象方法

13:接口的成员特点?

成员变量：只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出

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

成员方法：只能是抽象方法
默认修饰符：public abstract
建议：自己手动给出

所有的类都继承自一个类：Object
类Object是类层次结构的根类。每个类都使用Object作为超类

14:接口的练习

//定义动物培训接口
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 at = new Cat();
        at.jump();
    }

}

15:抽象类和接口的区别

抽象类（共性功能）：

成员变量：可以是变量，也可以是常量
成员方法：可以是抽象方法，也可以不是
构造方法：有

接口（扩展功能）：

成员变量：只能是常量
成员方法：只能是抽象方法
构造方法：无

16:案例 : 教练和运动员案例

interface test{
    //功能
    public abstract void testing();
}
abstract class people{
    public abstract void doing();
    public void swimming(){
        System.out.println("游泳");
    }
}
class teacher extends people
{
    public void doing() {
        System.out.println("老师要教学游泳");
    }
}
class student extends people{
    public void doing(){
        System.out.println("学生要游泳");
    }
}
class somestudent implements test{
    public void testing(){
        System.out.println("有些学生需要去参加比赛");
    }
}
class FinalDemo {
    public static void main(String[] args) {
        //测试学生类
        people a = new student();
        a.doing();
        a.swimming();
        System.out.println("-----------------");
        somestudent s = new somestudent();
        s.testing();
    }
}