黑马程序员 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"        }    }