javaSE第九天

 

第九天    50

1. final关键字(掌握)    50

(1)定义：    50

(2)特点：    51

(3)面试相关：    51

A:final修饰的局部变量    51

B:final修饰变量的初始化时机    51

2. 多态(掌握)    51

(1)多态的定义：    51

(2)多态的前提：    51

(3)多态中的成员访问特点    52

(4)多态的好处：    52

(5)多态的弊端：    52

(6)多态中的转型    52

A:向上转型    52

B:向下转型    52

(7)孔子装爹的案例帮助大家理解多态    52

(8)多态继承中的内存图解    53

(9) .多态中的对象变化内存图解    53

(10)多态的练习    53

3. 抽象类(掌握)    54

(1)定义：    54

(2)抽象类的特点    54

(3)抽象类的成员特点：    55

(4)抽象类的练习    55

(5)抽象类的几个小问题    55

4. 接口(掌握)    55

(1)回顾猫狗案例，它们仅仅提供一些基本功能。    55

(2)接口的特点：    56

(3)接口的成员特点：    56

(4)类与类,类与接口,接口与接口    56

(5)抽象类和接口的区别?    56

(6)练习：    57

 

第九天

1. final关键字(掌握)

    (1)定义：

是最终的意思，可以修饰类，方法，变量。

    (2)特点：

        A:它修饰的类，不能被继承。

        B:它修饰的方法，不能被重写。

        C:它修饰的变量，是一个常量。

    (3)面试相关：

        A:final修饰的局部变量

            a:基本类型 值不能发生改变

            b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的

        B:final修饰变量的初始化时机

            a:被final修饰的变量只能被赋值一次。

            b:在构造方法执行完毕之前（前提为：非静态变量）                        

c:赋值时机：1.在定义的时候就进行赋值。(推荐)

                 2.在构造方法中进行赋值。

    

2. 多态(掌握)

    (1)多态的定义：

同一个对象在不同时刻体现出来的不同状态。

    (2)多态的前提：

        A:有继承或者实现关系。

        B:有方法重写。

        C:有父类或者父接口引用指向子类对象。

        

        多态的分类：

            a:具体类多态

                class Fu {}

                class Zi extends Fu {}

                

                Fu f = new Zi();

            b:抽象类多态

                abstract class Fu {}

                class Zi extends Fu {}

                

                Fu f = new Zi();

            c:接口多态

                interface Fu {}

                class Zi implements Fu {}

                

                Fu f = new Zi();

    (3)多态中的成员访问特点

        A:成员变量

            编译看左边，运行看左边

        B:构造方法

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

        C:成员方法

            编译看左边，运行看右边

        D:静态方法

            编译看左边，运行看左边

            

        为什么?

            由于成员方法存在方法重写，所以它运行看右边

    (4)多态的好处：

        A:提高代码的维护性(继承体现)

        B:提高代码的扩展性(多态体现)

    (5)多态的弊端：

        父不能使用子的特有功能。

        

        现象：

            子可以当作父使用，父不能当作子使用。

    (6)多态中的转型

        A:向上转型

            从子到父（Fu f = new Zi()）

        B:向下转型

            把父类的引用强制转换为子类的引用（从父到子）(Zi z = (Zi)f )

    (7)孔子装爹的案例帮助大家理解多态

// 多态的问题理解：

class
孔子爹 {

    public int age = 40;

 

    public void teach() {

        System.out.println("讲解JavaSE");

    }

}

 

class
孔子
extends
孔子爹 {

    public int age = 20;

 

    public void teach() {

        System.out.println("讲解论语");

    }

 

    public void playGame() {

        System.out.println("英雄联盟");

    }

}

 

class MainDemo {

    public static void main(String[] args) {

        // Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了

        // 但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?

        // 然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹

        // 向上转型

        孔子爹
k爹 = new
孔子();

        // 到人家那里去了

        System.out.println(k爹.age); // 40

        k爹.teach(); // 讲解论语

        // k爹.playGame(); //这是儿子才能做的

 

        // 讲完了，下班回家了

        // 脱下爹的装备，换上自己的装备

        // 向下转型

        孔子
k = (孔子) k爹;

        System.out.println(k.age); // 20

        k.teach(); // 讲解论语

        k.playGame(); // 英雄联盟

 

    }

}    

 

(8)多态继承中的内存图解

 

1. .多态中的对象变化内存图解

   

       (10)多态的练习

           A:猫狗案例

           B:老师和学生案例

    

   3. 抽象类(掌握)

       (1)定义：

   把多个共性的东西提取到一个类中，这是继承的做法。

        但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。

        也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。

        所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。

        而一个没有具体的方法体的方法是抽象的方法。

        在一个类中如果有抽象方法，该类必须定义为抽象类。

       (2)抽象类的特点

           A:抽象类和抽象方法必须用关键字abstract修饰

           B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

           C:抽象类不能实例化

   因为它不是具体的

   抽象类有构造方法，但是不能实例化，构造方法的作用是什么呢？

   用于子类访问父类数据的初始化

           D:抽象类的子类

               a:如果不想重写抽象方法，该子类则是一个抽象类。

               b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。

       (3)抽象类的成员特点：

           A:成员变量

               既可以是变量，也可以是常量

   B:构造方法

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

           C:成员方法

               既可以是抽象的，也可以是非抽象的

   抽象类的成员方法特性：

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

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

       (4)抽象类的练习

           A:猫狗案例练习

           B:老师案例练习

           C:学生案例练习

           D:员工案例练习

       (5)抽象类的几个小问题

           A:抽象类有构造方法，不能实例化，那么构造方法有什么用?

               用于子类访问父类数据的初始化

           B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?

               为了不让创建对象

           C:abstract不能和哪些关键字共存

               a:final    冲突

               b:private 冲突

               c:static 无意义

    

   4. 接口(掌握)

       (1)回顾猫狗案例，它们仅仅提供一些基本功能。

        比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，

        是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。

       (2)接口的特点：

           A:接口用关键字interface修饰

               interface 接口名 {}

           B:类实现接口用implements修饰

               class 类名 implements 接口名 {}

           C:接口不能实例化

   那么，接口如何实例化呢？

   按照多态的方式来实例化

   多态类实例化方式？

   a: 具体类多态（几乎没有）

   b: 抽象类多态（常用）

   c: 接口多态（最常用）

           D:接口的实现类

               a可以是抽象类。但是意义不大

               b:也可以是具体类，这个类必须重写接口中的所有抽象方法。（推荐方案）

       (3)接口的成员特点：

           A:成员变量

               只能是常量，并且是静态的

               默认修饰符：public static final

   建议：自己手动给出

           B:构造方法

               没有构造方法

           C:成员方法

               只能是抽象的

               默认修饰符：public abstract

       (4)类与类,类与接口,接口与接口

           A:类与类

               继承关系，只能单继承，可以多层继承

           B:类与接口

               实现关系，可以单实现，也可以多实现。

               还可以在继承一个类的同时，实现多个接口

           C:接口与接口

               继承关系，可以单继承，也可以多继承

       (5)抽象类和接口的区别?

           A:成员区别

               抽象类：

   成员变量：既可以是变量，也可以是常量

   构造方法：有

   成员方法：既可以是抽象方法，也可以是非抽象方法

               接口：

   成员变量：只可以是常量

   成员方法：只可以是抽象方法

           B:关系区别:

               类与类：

   继承，单继承

               类与接口：

   实现，单实现，多实现

               接口与接口：

   继承，单继承，多继承

           C:设计理念不同

               抽象类：is a，抽象类中定义的是共性功能。

               接口：like a，接口中定义的是扩展功能。

       (6)练习：

           A:猫狗案例，加入跳高功能

           B:老师和学生案例，加入抽烟功能