Java基础第四章

一、类的继承

1.定义：类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，现有类被称作父类。子类会自动继承父类的属性和方法，使得子类具有父类的特征和行为。（extends）

class 父类{
  ……
 }
class 子类 extends 父类{
  …… 
}

（1）在Java中，类只支持单继承，不允许多继承。也就是说一个类只能有一个直接父类。
（2）多个类可以继承一个父类。
（3）在Java中，多层继承也是可以的，即一个类的父类可以再继承另外的父类。例如，C类继承自B类，而B类又可以继承自类A，这时，C类也可称作A类的子类。
（4）在Java中，子类和父类是一种相对概念，一个类可以是某个类的父类，也可以是另一个类的子类。

2.方法的重写：在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

class Animal {
    //定义动物叫的方法
    void shout() {
        System.out.println("动物发出叫声");
    }
}

class Dog extends Animal {
    //重写父类Animal中的shout()方法
    void shout() {
        System.out.println("汪汪汪……");
    }
}

public class main{
    public static void main(String[] args) {
        Dog dog = new Dog();    // 
        dog.shout();            // 调用Dog类重写的shout()方法
    }
}

3.super关键字：

（1）使用super关键字访问或调用父类的非私属性或非私有方法

super.属性
super.方法(参数1,参数2…)

（2）使用super关键字调用父类中指定的构造方法

super(参数1,参数2…)

二、final关键字

（1）使用final关键字修饰的类不能有子类。
（2）使用final关键字修饰的方法不能被子类重写。
（3）使用final关键字修饰的变量是常量，常量不可修改。

1.final关键字修饰类：

// 使用final关键字修饰Animal类，该类不可以被继承，也就是没有子类
final class Animal {
}

2。final关键字修饰方法：

一个类的方法被final关键字修饰后，该类的子类将不能重写该方法

3.final关键字修饰变量：

被final修饰的变量为常量

三、抽象类和接口

1.抽象类：定义一个类时，常常需要定义一些成员方法用于描述类的行为特征，但有时这些方法的实现方式是无法确定的

abstract 返回值类型 方法名称(参数列表); 

当一个类包含了抽象方法，该类就是抽象类。抽象类和抽象方法一样，必须使用abstract关键字进行修饰 

abstract class 抽象类名称{
    属性;
    访问权限 返回值类型 方法名称(参数){                    //普通方法
        return [返回值];
    }
    访问权限 abstract 返回值类型 抽象方法名称(参数);//抽象方法，无方法体
}

  (1）包含抽象方法的类必须是抽象类。
（2）声明抽象类和抽象方法时都要使用abstract关键字修饰。
（3）抽象方法只需声明而不需要实现。
（4）如果非抽象类继承了抽象类，那么该类必须实现抽象类中的全部抽象方法。

2.接口

[public] interface 接口名 [extends 接口1,接口2...] {
	[public] [static] [final] 数据类型 常量名 = 常量;
	[public] [abstract] 返回值的数据类型 方法名(参数列表);
	[public] static 返回值的数据类型 方法名(参数列表){}
	[public] default 返回值的数据类型 方法名(参数列表){}
}
//接口使用interface关键字声明

不管写不写访问权限，接口中方法的访问权限永远是public

四、多态

1.概述：（1）方法的重载
（2）对象的多态（方法的重写）

// 定义抽象类Animal
abstract class Animal {
    abstract void shout();     	// 定义抽象shout()方法
}

class Cat extends Animal {
    // 实现shout()方法
    public void shout() {
        System.out.println("喵喵……");
    }

class Dog extends Animal {
    // 实现shout()方法
    public void shout() {
        System.out.println("汪汪……");
    }
}
// 定义测试类
public class Summary01{
    public static void main(String[] args) {
        Animal an1 = new Cat(); // 创建Cat对象,使用Animal类型的变量an1引用
        Animal an2 = new Dog(); // 创建Dog对象,使用Animal类型的变量an2引用
        an1.shout();
        an2.shout();
    }
}

2.对象类型的转换

（1）向上转型;父类对象可以调用子类重写父类的方法

对象向上转型：父类类型 父类对象 = 子类实例;

（2）向下转型：

对象向下转型：
父类类型 父类对象 = 子类实例;
子类类型 子类对象 = （子类）父类对象;

3.instanceof关键字：使用instanceof关键字判断一个对象是否是某个类（或接口）的实例

五、Object类：它是所有类的父类，每个类都直接或间接继承了Object类

六、内部类

1.成员内部类：在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类

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

2.局部内部类：局部内部类，也称为方法内部类，是指定义在某个局部范围中的类，它和局部变量都是在方法中定义的，有效范围只限于方法内部

3.静态内部类:就是使用static关键字修饰的成员内部类

外部类名.静态内部类名 变量名 = new 外部类名.静态内部类名();

4.匿名内部类：

new 继承的父类或实现的接口名(){
   //匿名内部类的类体
}

七、异常:指的是程序在执行过程中，出现的非正常情况

1.try...catch和finally:

2.throw关键字