Java基础：继承与多态

1.继承的定义 

继承就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类的非私有的属性和行为

2.继承的作用

        基本作用：子类继承父类，代码可以得到复用

        主要作用：因为有了继承关系，才有了后期的方法覆盖机制

3.继承的格式

 通过extends关键字

class 父类{

....

}

class 子类 extends 父类{

....

}

4.继承的相关特性

4.1、B类继承A类，则称A类为超类，父类，基类

         B类则称为子类，派生类，扩展类

4.2、Java中的继承只支持单继承，不支持多继承

4.3、虽然Java不支持多继承，但会产生间接继承的效果如：class A extends B , class B extends A,

4.4、Java中规定，子类继承父类，除构造方法不能继承之外，剩下的都可以继承。但是私有的属性无法在子类中直接访问

4.5、Java中的类没有显示的继承任何类，则默认继承Object类，Object类是jJava语言提供的根类

5.继承后的特点

1、子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有变量时，需要使用super关键字

        使用格式：super.父类成员变量名

super调用父类构造时，一定要放在构造方法的首行上

class A {
    public A(String msg) { // 父类构造
        System.out.println("*************************");
    }
}

class B extends A {
    public B() { // 子类构造
        super("Hello"); // 调用父类构造
        System.out.println("#########################");
    }
}

public class TestDemo {
    public static void main(String args[]) {
        B b = new B(); // 实例化子类对象
    }
}

2、子类出现与父类一模一样的方法时，会覆盖这个效果，也称重写或复写

        注意事项：

        子类方法覆盖父类方法，必须要保证权限大于等于父类权限

        子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样

3、子类继承父类后，是将父类继承过来的方法归为自己所有。实际上调用的也不是父类的方法是他子类自己的方法

---

抽象类

1、概述

类与类之间的共同特征，将这些共同特征提取出来，形成的就是抽象类，类本身是不存在的，所以抽象类无法创建对象（无法实例化）

2、抽象类属于引用数据类型

3、抽象类怎么定义

语法：

        [修饰符列表] abstract class 类名{

        类体；

}

4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的

5、final 和 abstract不能联合使用，这两个关键字是对立的

6、抽象类的子类可以是抽象类

7、抽象类虽然无法实例化，但是抽象类有构造方法这个构造方法是供子类使用的

8、抽象方法的特点：

        8.1、没有方法体，以分号结尾  public abstract void doSome();

        8.2、前面修饰符列表中有abstract关键字

9、抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中，一个非抽象的类继承抽象类，必须将抽象类中的抽象方法实现了。

abstract class Animal{
    public abstract void move();
}

class Cat extends Animal{
    public void move(){

    }
} 

这里的重写（覆盖），也可以叫做实现（对抽象的实现）

---

多态

1、多态是继封装、继承之后，面向对象的第三大特征

2、多态是指同一行为具有多个不同的表现形式

3、多态体现为父类引用变量可以指向子类对象

在使用多态后的父类引用变量调用方法时，会调用子类的重写后的方法

4、多态体现的格式

父类类型 变量名=new 子类对象；

变量名.方法名（）；

父类类型：指子类对象继承的父类类型，或者实现的父类的接口类型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后的方法

5、引用类型转换

          5.1、向上转型：多态本身是子类类型向父类类型想上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。

父类类型 变量名=new 子类类型();
如：Animal a=new Cat();

          5.2、向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的，一个已经向上转型的子类对象，将父类引用转换为子类引用，可以使用强制类型转换的格式，便是向下转型

当你需要访问的子类对象中"特有"的方法,此时必须是向下转型。

子类类型 变量名=new (子类类型)父类变量
如：Cat c=new (Cat)a;

6、转型的异常

Animal a=new Cat();
a.eat();//调用的是Cat的eat

Dog d=new (Dog)a;

d.run();//调用的是Dog的run，运行报错

这是因为Cat和Dog没有任何的继承关系，不符合类型转换的定义

7、instranceof

如果该变量属于该数据类型返回true

如果该变量不属于该数据类型返回false

Animal a=new Cat();
a.eat;

if(a instanceof Cat){
    Cat c=new (Cat)a;
    c.run();
}else if(a instanceof Dog){
    Dog d=new (Dog)a;
    d.run();
}

---

接口

1、接口也是一种引用数据类型

2、接口是完全抽象的。（抽象类是半抽象）或者也可以说接口是特殊的抽象类

3、接口怎么定义，语法是什么？

[修饰符列表] interface 接口名{

}

4、一个接口可以继承多个接口（支持多继承）

interface A{
}

interface B{
}

interface C extends A,B{
}

 5、接口中只包含两部分内容，一部分是：常量。一部分是：抽象方法。接口中没有其他内容了

6、接口中所有的元素都是public修饰的（都是公开的）

7、接口中的抽象方法定义时：public abstract修饰符可以省略

interface MyMath{
        public abstract int sum(int a,int b);
}

8、接口中的方法都是抽象方法，所以不能有方法体

9、接口中的常量的public static final可以省略

interface MyMath{
        public static final doublie PI=3.14;
        public abstract int sum(int a,int b);
}

10、接口实现使用implements关键字完成

11、当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）

12、接口的多实现

class 类名 implements 接口1，接口2{
    重写接口中的抽象方法【必须】
    重写接口中的默认方法【不重名时可选】
}

13、extends 和 implements可以共存，extends在前implement在后：

interface A{
    int num();
}

class B{
}

class C extends B implement A{
    public int num(){

    }
}

14、使用接口，写代码的时候，可以使用多态（父类型对象引用子类型对象）

---

final关键字

1、final：不可改变。可以用于修饰类。方法和变量

2、类：被修饰的类，不能被继承

final class 类名{}

3、方法：被修饰的方法，不能被重写

修饰符 final 返回值类型 方法名（参数列表）{

}

  4、变量：被修饰的变量，不能被重新赋值

      局部变量——基本类型

        基本类型的局部变量，被final修饰后，只能赋值一次，不能被改变

     局部变量——引用类型

        引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能在更改，但是不影响对象内部的成员变量值的修改

5、被final修饰的常量名称，一般都有书写规范，所有字母都大写

---

权限修饰符

	public(公共的)	protected(受保护的)	default(默认的)	private(私有的)
同一类中	√	√	√	√
同一包中	√	√	√
不同包的子类	√	√
不同包的无关类	√

---

内部类

1、概述

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B称为外部类

2、成员内部类

定义在类中方法外的类

class 外部类{

        class 内部类{

        }

}

3、访问特点

内部类可以直接访问外部类的成员，包括私有成员。外部类要访问内部类的成员，必须要简历内部类的对象

创建内部类对象格式：

外部类名.内部类名 对象名= new 外部类型().new 内部类型(); 

4、匿名内部类

匿名内部类必须继承一个父类或者实现一个父接口