Java面向对象2（有继承）

版权声明：本文为博主原创文章，转载请标注出处：http://blog.csdn.net/EnigmCode。 https://blog.csdn.net/EnigmCode/article/details/79291813

1、继承

(1)把多个类中相同的属性和行为提取出来，定义到一个类中，然后让这多个类和定义的这一个类产生一个关系，让这多个类具备定义的这一个类的属性和方法，这就是继承关系
(2)Java中继承的表示：class 子类名 extend 父类名{}
(3)Java中继承的特点：只能单继承，可以多层继承（继承体系）
(4)Java中继承的好处与弊端
    A:好处：
        a:提高了代码的复用性
        b:提高了代码的可维护性
        c:让类与类之间产生了一个关系，是多态的前提
    B:弊端：
        让类与类之间的耦合增强了，这样一个类的改动会直接影响另一个类
(5)Java中继承的注意事项：
    A:私有成员不能被继承
    B:构造方法不能被继承，要访问通过super关键字
    C:不能为了部分功能而去使用继承
(6)继承中成员的关系
    A:成员变量
        不同名：直接看就可以；同名：就近原则，访问自己用this，访问父类用super
    B:构造方法
        a:子类的所有构造方法都是默认访问父类的无参构造方法
        b:如果父类没有无参构造方法，通过super(…)访问父类的有参构造方法
            通过this(…)访问本类中其他的构造方法（一定要有一个访问父类的构造方法）
            注意：super或者this只能出现一个，并且只能在语句的第一条
                为什么？
                因为子类可能会访问父类的数据，所以在子类初始化之前，要先把父类加载完毕
    C:成员方法
        不同名：直接看就可以；同名：就近原则，访问自己用this，访问父类用super
(7)this和super的区别以及应用场景
    A:区别
        this：本类对象的引用
        super：父类存储空间的标识。可以理解为父类对象的引用
    B:应用场景
        a:成员变量
            this.变量 本类的成员变量
            super.变量    父类的成员变量
        b:构造方法
            this.(...)  本类的构造方法
            super.(...) 父类的构造方法
        c:成员方法
            this.(...)  本类的成员方法
            super.(...) 父类的成员方法
(8)练习题
    教师类和学生类
    猫类和狗类

2、方法重写

(1)描述：在子类中，出现了和父类一模一样的方法声明的现象
(2)作用：可以使用父类的功能，还可以增强该功能
(3)方法重写的注意事项：
    a:父类私有方法不能被重写
    b:子类重写方法的访问权限不能比父类低
    c:静态只能重写静态。（其实这不算重写）
面试题：
    1、override和overload的区别？
        override是重写：方法名，参数个数，类型，顺序以及返回值类型都必须和父类方法一致。它的关系是子父类中相同名字的方法，在子类中覆盖了父类的方法
        overload是重载：方法名不变，其余的都是可以变更的。它的关系是在同一个类中，同一个方法名，不同的方法参数列表或者返回值类型
    2、overload可以改变返回值类型吗？
        可以改变返回值类型，因为唯一区分方法重载的是参数列表不同，当参数列表不同时能达到区分重载时，就可以改变其返回值类型

3、final关键字

(1)final :最终的意思
(2)作用:可以修饰类，成员变量、成员方法
(3)特点：
    A:修饰类           类不能被继承
    B:修饰成员变量    变量变成了常量
    C:修饰成员方法    方法不能被重写
面试题：
    final修饰基本类型和引用类型的区别？
        A:final修饰局部变量
            a:基本类型 值不能发生改变
            b:引用类型 地址不能发生改变，对象内容可以改变
        B:final的初始化时机
            a:在定义时就赋值
            b:在构造方法完毕前赋值

4、多态

(1)多态：同一个对象，在不同时刻表现出来的多种形态
(2)多态的前提：
    A:有继承关系
    B:有方法重写
    C:有父类引用指向子类对象
(3)多态中的成员访问特点
    A:成员变量
        编译看左边，运行看右边
    B:成员方法
        编译看左边，运行看右边
    C:静态方法
        编译看左边，运行看左边
    为什么？
        因为方法具有重写，而变量没有。静态方法没有重写一说。
(4)好处与弊端
    A:好处
        提高代码的复用性
        提高代码的扩展性
    B:弊端
        不能访问子类特有的方法
(5)如何访问子类中特有的方法
    A:创建子类对象
    B:向下转型
(6)多态中的转型
    A:向上转型 子类对象到父类对象
    B:向下转型 父类对象到子类对象（要强制转换）

5、抽象类

(1)有时候对事物不能用具体的东西来描述，这时候就应该把事物定义为抽象类
(2)抽象类的特点
    A:抽象类或者抽象方法必须用abstract修饰
    B:抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
    C:抽象类不能直接实例化，可以按照多态的方式实例化
    D:抽象类的子类
        a:要么是抽象类
        b:要么重写抽象类中所有的抽象方法
(3)抽象类成员的特点
    A:成员变量 可以是变量也可以是常量
    B:构造方法 有，但是不能实例化，用于子类访问父类数据的初始化
    C:成员方法 可以是抽象的，也可是非抽象的
(4)两个小问题
    A:如果一个抽象类中没有抽象方法，表示不让别人创建这个类
    B:abstract不能和那些关键字共存？
        a:private   冲突
        b:final     冲突
        c:static    无意义
(5)案例：
    猫狗案例，员工案例，学生案例，教师案例

6、接口类

(1)有些时候，不是事物本身具备的功能，我们可以考虑使用接口来扩展这一个功能
(2)接口的特点：
    A:用关键字interface来定义,格式： interface 接口名{}
    B:类实现接口用关键字implements，格式： class 类名 implement 接口名{}
    C:接口不能实例化
    D:接口的子类
        a:要么是抽象类
        b:要么重写接口中的所有方法
(3)接口成员特点
    A:成员变量：只能是常量并且是静态的，默认修饰符：public static final 
    B:成员方法：只能是抽象方法，默认修饰符：public abstract
    C:建议：写接口时把默认修饰符加上
(4)类与接口的关系
    A:类与类：继承关系，只能单继承，可以多层继承
    B:类与接口：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
    C:接口与接口：继承关系，可以单继承，也可以多继承
(5)抽象类和接口的区别
    A:成员区别
    B:关系区别
    C:设计理念区别
        抽象类：父抽象类里面定义的是共性内容
        接口：父接口里面定义的是扩展内容

7、形式参数和返回值问题

(1)形式参数：
    基本类型：需要的是对应的值
    引用类型：类：该类的对象，抽象类该类的子类，接口，该接口的实现类对象
(2)返回值问题：
    基本类型：返回的是对应的值
    引用类型：类：该类的对象，抽象类该类的子类，接口，该接口的实现类对象
(3)链式编程：
    new A().b().c().d()

8、包结构

(1)其实就是文件夹
(2)对类进行分类管理
(3)格式：package 包名;
(4)注意事项：
    A:package是 程序中的第一条语句
    B:在类中package是唯一的
    C:没有package，默认是无包名的
(5)带包类的编译和运行

9、导包

(1)为了方便使用不同的包下的类，需要导包
(2)格式：import 包名1.包名1....类名
    注意：可以导入到*,但是不建议
面试题：package、import、class在类中有没有顺序关系？
  有；package-->import-->class

10、修饰符总结：

(1)4种权限修饰符
                本类  同一个包    不同包下的子类     不同包下的其他子类
    private     yes
       默认       yes      yes
    protected   yes      yes        yes
    public      yes      yes        yes             yes
(2)常见修饰符号
    A:类     public
    B:成员变量  private
    C:构造方法  public
    D:成员方法  public

11、内部类

(1)把类A定义在类B中，类A就被称为内部类
(2)访问特点：
    A:内部类可以直接访问外部类的成员，包括私有的
    B:外部类要想访问内部类的成员，必须建立对象 
        格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
(3)分类:成员内部类，局部内部类
(4)成员内部类
    A:private：为了数据的安全
    B:static：为了让数据访问方便
(5)局部内部类
    A:可直接访问外部类的成员
    B:可以常见内部类对象，通过对象调用内部类方法，来使用局部内部类功能
    面试题：局部内部类访问变量为什么需要被final修饰？
        为了让数据还能被继续使用，就用final修饰，这样就可以在内存中存储一个常量值
(6)匿名内部类
    A:没有名字的内部类
    B:前提：存在一个类或者接口
    C:格式：
        new 类名或者直接接口名(){
            重写方法();
        }
    本质：是一个匿名对象
(7)开发中如何使用
    不用再定义一个新的类。直接通过匿名内部类的格式

interface Person{ public abstract void show(); } class
PersonDemo(){ public void method(Person p){
p.show(); } } PersonDemo pd = new PersonDemo(); pd.method(new Person(){ public void show(){…} });

**面试题：补齐代码，在控制泰输出HelloWorld**

interface Inter{ public abstract 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(); } }