Java基础面向对象（4面向对象）

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ## Java基础@[杨光浩]

第四章

类的继承：在Java中类的继承是之一个现有类的基础上去构建一个新的类，构建出来的新的类被称作子类，现有的类被称作父类或者基类，子类会自动拥有父类所有可继承的属性和方法。
继承关键字extends。
实现类的继承中：
（1）在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类。【不合法：class C extends A,B】
（2）多个类可以继承同一个父类【合法：class B extends A class C extends A】
（3）在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类 例如：

class A{}
class B extends A{}//类B继承类A 类B 是类A的子类
class C extends B{}//类C继承类B 类C是类B的子类，同时也是类A的子类 

（4）在Java中 子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。

重写父类的方法
在继承关系中，子类会自动继承父类中公共的方法,但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。需要注意的是,子类中重写的方法需要和父类被重写的方法具有相同的方法名，参数列表以及返回值类型。

注意：子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限。如父类中的方法访问权限时public，子类重写父类该方法的访问权限就不能是private。
当子类重写父类的方法后，子类对象将无法直接访问父类被重写的方法。Java中专门提供了一个super关键字来访问父类的成员。
（1）使用super关键字调用父类的成员变量和成员方法，具体格式如下：

super.成员变量
super.成员方法([参数1,参数2,...])

(2)使用super关键字调用父类的构造方法，具体格式如下：

super([参数1,参数2,...])

通过super调用的父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次，否则程序在编译期间就会报错。

Object类
在Java中提供了一个Object类，他是所有类的父类，即每个类都直接或间接继承自该类，object类通常被称为超类、基类或根类。当定义一个类时，如果没有使用extens关键字为这个类显式地指定父类，那么该类会默认继承Object类。
Object类的toString()方法中输出信息具体格式如下：

getClass().getName()+"@"+Integer.toHexString(hashCode());

1.getClass().getName()代表返回对象所属类的类名，即包名+类名的全限定名称。
2.hashCode()代表返回该对象的哈希值。
3.Integer.toHexString(hashCode())代表将对象的哈希值用十六进制表示。
final关键字
final关键字可用于修饰类、变量和方法，它有“不可更改”或者“最终”的含义，因此被final修饰的类、变量和方法将具有以下特性：
1.final修饰的类不能被继承。
2.final修饰的方法不能被子类重写。
3.final修饰的变量（成员变量和局部变量）是常量，只能赋值一次。
注意：final修饰的成员变量，必须在声明的同时进行赋值，否则编译报错
final修饰的局部变量，可以先声明，再进行一次赋值
抽象类
Java中提供了抽象方法。抽象方法必须使用abstract关键字来修饰，并且在定义方法时不需要实现方法体。当一个类中包含了抽方法，那么该类必须使用abstract关键字来修饰，这种使用abstract关键字修饰的类就是抽象类。
抽象类及抽象方法定义的基本方法格式如下：

//定义抽象类
[修饰符] abstract class 类名 {
   //定义抽象方法
   [修饰符] abstract 方法返回值类型 方法名([参数表列]);
   //其他方法或属性
}

注意：包含抽象方法的类必须定义为抽象类，但抽象类中可以不包含任何抽象方法。另外，抽象方法是不可以被实例化的，因为抽象类中有可能包含抽象方法，抽象方法时没有方法体的，不可以被调用。如果想调用抽象类中定义的抽象方法，需要创建一个子类，在子类中实现抽象类中的抽象方法。

小提示：定义抽象方法只需要在普通方法上增加abstract关键字，并把普通方法的方法体（大括号以及大括号中的部分）全部去掉，然后在方法名称后增加英文分号即可，例如：pbulic abstract void shout();

接口定义接口时，不适用class关键字，而是使用interface关键字来声明
抽象类的中所有的方法都是抽象方法，可以将这个类定义为Java中的另一个形式——接口（一种特殊的抽象类），接口不包含普通方法，接口的内部所有的方法都是抽象方法，接口将抽象进行的更为彻底。

JDK8中，对接口进行了重新定义，接口中除了抽象方法外，还可以有默认方法和静态方法（也叫类方法），默认方法使用default修饰，静态方法使用static修饰，并且这两种方法都允许有方法体。

接口定义的基本语法格式如下：

[修饰符] interface 接口名 [extends 父接口1,父接口2,...]{
    [public] [static] [final] 常量类型 常量名 = 常量值;//定义常量时必须进行初始化赋值
    [public] [abstract] 方法返回值类型 方法名 ([参数表列]);
    [public] default 方法返回值类型 方法名 ([参数表列]){
        //默认方法的方法体
    }
    [public] static 方法返回值类型 方法名 ([参数表列]){
        //静态方法的方法体
    }
 }

Java的多态是由类的继承、方法重写以及父类引用指向子类对象体现的。

• 对象类型转换
  多态中，将子类的对象当作父类类型使用的情况，在Java语言环境中称为"向上转型"，例如：

Animal an1 = new Cat();  //将Cat类对象当作Animal类型来使用
Animal an2 = new Dog();  //将Dog类对象当作Animal类型来使用

将子类对象当作父类使用时不需要任何显式声明，需要注意的是，此时不能通过父类变量去调用子类特有的方法
Java中向下类型转换的时，必须转换为本质类型，否则转换时会出现错误。
Java中提供了一个关键字instanceof,它可以判断一个对象是否为某个类（或接口）的实例或者子类实例，语法格式如下：

对象(或者对象的引用变量) instandeof 类(或接口)

内部类
在Java中允许在一个类的内部定义类,这样的类称作内部类,这个内部类所在的类称作外部类。在实际情况中，根据内部类的位置、修饰符和定义方式的不同，内部类可以分为4种形式:成员内部类，局部内部类，静态内部类和匿名内部类。

• 成员内部类
  在成员内部类中，可以访问外部类的所有成员，包括成员变量和成员方法；在外部类中，同样可以访问成员内部类的变量和方法。
  创建内部类对象的具体语法格式如下：

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

• 局部内部类
  局部内部类，也叫做方法内部类，就是定义在某个局部范围中的类，它和局部变量一样，都是在方法中定义，其有效范围只限于方法内部。
  在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中的变量和方法却只能在创建该局部内部类的方法中进行访问。
• 静态内部类
  静态内部类，就是用static关键字修饰的成员内部类。与成员内部类相比，在形式上，静态内部类只是在内部类前增加了static关键字，但在功能上，静态内部类中只能访问外部类的静态成员，同时通过外部类访问静态内部成员时，可以跳出外部类从而直接通过内部类访问静态内部类成员。
  创建静态内部类对象的基本语法格式如下：

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

• 匿名内部类

JDK8的Lambda表达式
一个Lanbda表达式由三个部分组成，分别为参数表列，"->"和表达式主题，语法格式如下:

([数据类型 参数名,数据类型 参数名,...])->{表达式主体}

Lamdba表达式是基于函数式接口实现的。
局限：接口中有且仅有一个抽象方法时才能使用Landba表达式代替匿名内部类

函数式接口
Lamdba表达式就是基于函数式接口实现的。函数式接口是指有且仅有一个抽象方法的接口，Lamdba表达式就是Java中函数式编程的体现。
异常
在Java中提供了大量的异常类，这些类都继承自java.lang.Throwable类。
异常体系结构图

• 使用try…catch语句对异常进行捕获处理
• 使用throws关键字声明抛出异常，让调用者对其处理。