黑马程序员 JavaSE-06 面向对象（下）

Java培训、Android培训、iOS培训、.Net培训、期待与您交流！

JavaSE-06 面向对象（下）

继承

(1)概念：

把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。

(2)格式

    A:用关键字extends表示
    B:格式：
        class 子类名 extends 父类名 {}

(3)继承的好处

    A:提高了代码的复用性
    B:提高了代码的维护性
    C:让类与类产生了一个关系，是多态的前提

(4)继承的弊端

    A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
        原则：低耦合，高内聚。
        耦合：类与类的关系
        内聚：自己完成某件事情的能力
    B:打破了封装性

(5)Java中继承的特点

    A:Java中类只支持单继承
    B:Java中可以多层(重)继承(继承体系)

(6)继承的注意事项：

    A:子类不能继承父类的私有成员
    B:子类不能继承父类的构造方法，但是可以通过super去访问
    C:不要为了部分功能而去继承

(7)什么时候使用继承呢?

    A:继承体现的是：is a的关系。
    B:采用假设法

(8)Java继承中的成员关系

    A:成员变量
        a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
        b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
            子类的方法访问变量的查找顺序：
                在子类方法的局部范围找，有就使用。
                在子类的成员范围找，有就使用。
                在父类的成员范围找，有就使用。
                找不到，就报错。
    B:构造方法
        a:子类的构造方法默认会去访问父类的无参构造方法
            是为了子类访问父类数据的初始化
        b:父类中如果没有无参构造方法，怎么办?
            子类通过super去明确调用带参构造
            子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
            让父类提供无参构造
    C:成员方法
        a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
        b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
            通过子类对象访问一个方法的查找顺序：
                在子类中找，有就使用
                在父类中找，有就使用
                找不到，就报错

多态

(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:向上转型
        从子到父
    B:向下转型
        从父到子

抽象类

(1)基本概念

抽象方法：一个没有具体的方法体的方法是抽象的方法。
抽象类：在一个类中如果有抽象方法，该类必须定义为抽象类。

(2)抽象类的特点

    A:抽象类和抽象方法必须用关键字abstract修饰
    B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
    C:抽象类不能实例化
    D:抽象类的子类
        a:是一个抽象类。
        b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。

(3)抽象类的成员特点

    A:成员变量
        有变量，有常量
    B:构造方法
        有构造方法
    C:成员方法
        有抽象，有非抽象

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

    A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
        用于子类访问父类数据的初始化
    B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
        为了不让创建对象
    C:abstract不能和哪些关键字共存
        a:final 冲突
        b:private 冲突
        c:static 无意义

接口

(1)概念

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

(2)接口的特点

    A:接口用关键字interface修饰
        interface 接口名 {}
    B:类实现接口用implements修饰
        class 类名 implements 接口名 {}
    C:接口不能实例化
    D:接口的实现类
        a:是一个抽象类。
        b:是一个具体类，这个类必须重写接口中的所有抽象方法。

(3)接口的成员特点：

    A:成员变量
        只能是常量
        默认修饰符：public static final
    B:构造方法
        没有构造方法
    C:成员方法
        只能是抽象的
        默认修饰符：public abstract

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

    A:类与类
        继承关系，只能单继承，可以多层继承
    B:类与接口
        实现关系，可以单实现，也可以多实现。
        还可以在继承一个类的同时，实现多个接口
    C:接口与接口
        继承关系，可以单继承，也可以多继承

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

    A:成员区别
        抽象类：有变量，有常量
        接口：只能是常量,默认修饰符：public abstract
    B:关系区别:
        类与类：继承关系，只能单继承
        类与接口：实现关系，可以单实现，也可以多实现
        接口与接口：继承关系，可以单继承，也可以多继承
    C:设计理念不同
        抽象类：is a，抽象类中定义的是共性功能。
        接口：like a，接口中定义的是扩展功能。

包和导包

(1)包的概念：其实就是文件夹
(2)包的作用：

    A:区分同名的类
    B:对类进行分类管理
        a:按照功能分
        b:按照模块分

(3)包的定义

    package 包名;
    多级包用.分开。

(4)注意事项

    A:package语句必须在文件中的第一条有效语句
    B:在一个java文件中，只能有一个package
    C:如果没有package，默认就是无包名

(5)带包的编译和运行

    A:手动式
    B:自动式(掌握)
        javac -d . HelloWorld.java

（6）导包格式

    import 包名...类名;
    另一种：
        import 包名...*;(不建议)

（7）package,import,class的顺序

    package > import > class

权限修饰符

                本类  同一个包下   不同包下的子类 不同包下的无关类
    private     Y
    default     Y           Y
    protected   Y           Y           Y
    public      Y           Y           Y           Y

内部类

(1)概念：

把类定义在另一个类的内部，该类就被称为内部类。
    举例：把类B定义在类A中，类B就被称为内部类。

(2)内部类的访问规则

    A:可以直接访问外部类的成员，包括私有
    B:外部类要想访问内部类成员，必须创建对象

(3)内部类的分类

    A:成员内部类
    B:局部内部类

(4)成员内部类

    A:private 为了数据的安全性
    B:static 为了访问的方便性

    成员内部类不是静态的：
        外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
    成员内部类是静态的：
        外部类名.内部类名 对象名 = new 外部类名.内部类名();

(5)成员内部类的面试题(填空)

    class Outer {
        public int num = 10;

        class Inner {
            public int num = 20;

            public viod show() {
                int num  = 30;

                System.out.println(num);//30
                System.out.println(this.num);//20
                System.out.println(Outer.this.num);//10
            }
        }
    }

(6)局部内部类

    A:局部内部类访问局部变量必须加final修饰。
    B:为什么呢?
        因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
        所以，堆内存还是用该变量，而改变量已经没有了。
        为了让该值还存在，就加final修饰。
        通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。

(7)匿名内部类(掌握)

    A:是局部内部类的简化形式
    B:前提
        存在一个类或者接口
    C:格式:
        new 类名或者接口名() {
            重写方法;
        }
    D:本质：
        其实是继承该类或者实现接口的子类匿名对象

(8)匿名内部类在开发中的使用

    我们在开发的时候，会看到抽象类，或者接口作为参数。
    而这个时候，我们知道实际需要的是一个子类对象。
    如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

    interface Person {
        public abstract void study();
    }

    class PersonDemo {
        public void method(Person p) {
            p.study();
        }
    }

    class PersonTest {
        public static void main(String[] args) {
            PersonDemo pd = new PersonDemo();
            pd.method(new Person() {
                public void study() {
                    System.out.println("好好学习，天天向上");
                }
            });
        }
    }

(9)匿名内部类的面试题(补齐代码)

    interface Inter {
        void show();
    }

    class Outer {
        //补齐代码
        public static Inter method() {
            return new Inter() {
                public void show() {
                    System.out.println("HelloWorld");
                }   
            };
        }
    }

    class OuterDemo {
        public static void main(String[] args) {
            Outer.method().show(); //"HelloWorld"
        }
    }