Java基础入门--第四章--面向对象(下)

1 继承

在Java中，类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，现有类被称作父类。子类会自动继承父类的属性和方法，使得子类具有父类的特征和行为。
在Java程序中，如果想声明一个类继承另一个类，需要使用extends关键字，其语法格式如下所示。

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

//定义Animal类
class Animal {
    public final String COLOR = "白色"; //定义COLOR属性
    private String name;    //声明name属性
    private int age;        //声明age属性

    public String getName() {        //定义name属性的getter方法
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//定义Dog类继承Animal类
class Dog extends Animal {
    //此处不写代码
}

//定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();  //创建一个Dog类的对象
        dog.setName("萨摩耶");
        dog.setAge(3);
        System.out.println("名称：" + dog.getName() + ",年龄：" + dog.getAge() + ",颜色：" + dog.COLOR);
    }
}

子类除了可以继承父类的属性和方法，也可以定义自己的属性和方法。
在子类Dog中增加属性color和相应的getter和setter方法。

// 定义Animal类
class Animal {
    private String name;         		// 声明name属性
    private int age;             		// 声明age属性
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
// 定义Dog类继承Animal类
class Dog extends Animal {
    private String color;        // 声明color属性
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();     // 创建并实例化dog对象
        dog.setName("牧羊犬");    // 此时访问的是父类Animal中的setter方法
        dog.setAge(3);           // 此时访问的是父类Animal中的setter方法
        dog.setColor("黑色");     // 此时访问的是Dog类中的setter方法
        System.out.println("名称："+dog.getName()+",年龄："+dog.getAge()+ ",颜色："+dog.getColor());
    }
}

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

1.2 方法的重写

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

// 定义Animal类
class Animal {
    //定义动物叫的方法
    void shout() {
        System.out.println("动物发出叫声");
    }
}
// 定义Dog类继承Animal类
class Dog extends Animal {
    //重写父类Animal中的shout()方法
    void shout() {
        System.out.println("汪汪汪……");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();    // 创建Dog类的实例对象
        dog.shout();            // 调用Dog类重写的shout()方法
    }
}

子类重写父类方法时的访问权限

子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限。例如，父类中的方法是public权限，子类的方法就不能是private权限。如果子类在重写父类方法时定义的权限缩小，则在编译时将出现错误。

'com.test.Dog' 中的 'shout（）' 与 'com.test.Animal' 中的 'shout（）' 冲突;试图分配较弱的访问权限（“私有”）;是“公开的”

1.3 super关键字

（1）使用super关键字访问或调用父类的非私属性或非私有方法，具体格式如下。

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

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

class Dog extends Animal{
    //重写父类Animal中的shout()方法,扩大了访问权限
    public void shout(){
        super.shout();
        System.out.println("汪汪汪");

    }
    public void printName(){
        System.out.println("名字:"+super.name);   //访问父类中的name方法
    }
}
public class Summary01 {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.shout();
        dog.printName();
    }
}

（2）使用super关键字调用父类中指定的构造方法，具体格式如下。

super(参数1,参数2…)

class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String info() {
        return "名称:" + this.getName() + ",年龄:" + this.getAge();
    }
}

//定义Dog类继承Animal类
class Dog extends Animal {
    private String color;
    public Dog(String name, int age, String color) {
        super(name, age);
        this.setColor(color);
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    //重写父类info()方法
    public String info(){
        return super.info()+",颜色:"+this.getColor();     //扩充父类中的方法
    }
}

public class Summary01 {
    public static  void main(String[] args){
        Dog dog = new Dog("牧羊犬",2,"灰色");
//        dog.info();
        System.out.println(dog.info());
    }
}

通过super()调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。

super与this的区别

区别点	super	this
访问属性	直接访问父类中的非私有属性	访问本类中的属性。如果本类中没有该属性，则从父类中继续查找
调用方法	直接调用父类中的非私有方法	调用本类中的方法。如果本类中没有该方法，泽从父类中继续查找
调用构造方法	调用父类构造方法，必须放在子类构造方法的首行	调用本类构造方法，必须放在构造方法的首行

注意：this和super不可以同时出现，因为使用this和super调用构造方法的代码都要求必须放在构造方法的首行。

2 final关键字

如果父类的成员不希望被子类重写，可以在声明父类的成员时使用final关键字修饰。在Java中，可以使用final关键字修饰类、属性、方法。在使用final关键字时需要注意以下几点：
（1）使用final关键字修饰的类不能有子类。
（2）使用final关键字修饰的方法不能被子类重写。
（3）使用final关键字修饰的变量是常量，常量不可修改。

2.1 final关键字修饰类

Java中使用final关键字修饰的类不可以被继承，也就是不能派生子类。

// 使用final关键字修饰Animal类
final class Animal {
}
// Dog类继承Animal类
class Dog extends Animal {
}
//Cannot inherit from final 'com.test.Animal'
//无法继承最终的“com.test.Animal
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog(); 		// 创建Dog类的对象
    }
}

2.2 final关键字修饰方法

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

2.3 final关键字修饰变量

Java中被final修饰的变量为常量，常量只能在声明时被赋值一次，在后面的程序中，常量的值不能被改变。如果再次对final修饰的常量赋值，则程序会在编译时报错。

3 抽象类和结构

3.1 抽象类

定义一个类时，常常需要定义一些成员方法用于描述类的行为特征，但有时这些方法的实现方式是无法确定的。例如，前面定义的Animal类中的shout()方法用于描述动物的叫声，但是不同的动物，叫声也不相同，因此在shout()方法中无法准确描述动物的叫声。
针对上面描述的情况，Java提供了抽象方法来满足这种需求。抽象方法是使用abstract关键字修饰的成员方法，抽象方法在定义时不需要实现方法体。抽象方法的语法格式如下。

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

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

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

从上面抽象类的语法格式中可以发现，抽象类的定义比普通类多了一个或多个抽象方法，其他地方与普通类的组成基本相同。抽象类的定义规则如下。
（1）包含抽象方法的类必须是抽象类。
（2）声明抽象类和抽象方法时都要使用abstract关键字修饰。
（3）抽象方法只需声明而不需要实现。
（4）如果非抽象类继承了抽象类，那么该类必须实现抽象类中的全部抽象方法。

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

//定义Dog类继承抽象类Animal
class Dog extends Animal {
    //实现抽象方法shout()
    void shout() {
        System.out.println("汪汪");
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
    }
}

注意
使用abstract关键字修饰的抽象方法不能使用private关键字修饰，因为抽象方法必须要被子类实现，如果使用了private关键字修饰抽象方法，则子类无法实现该方法。

3.2 接口

接口是一种用来定义程序的协议，它用于描述类或结构的一组相关行为。接口是由抽象类衍生出来的一个概念，并由此产生了一种编程方式，可以称这种编程方式为面向接口编程。面向接口编程就是将程序的业务逻辑进行分离，以接口的形式去对接不同的业务模块。接口中不实现任何业务逻辑，业务逻辑由接口的实现类来完成。当业务需求变更时，只需要修改实现类中的业务逻辑，而不需要修改接口中的内容，以减少需求变更对系统产生的影响。

在Java中，使用接口的目的是为了克服单继承的限制，因为一个类只能有一个父类，而一个类可以同时实现多个父接口。在JDK 8之前，接口是由全局常量和抽象方法组成的。JDK 8对接口进行了重新定义，接口中除了抽象方法外，还可以定义默认方法和静态方法，默认方法使用default关键字修饰，静态方法使用static关键字修饰，且这两种方法都允许有方法体。

接口使用interface关键字声明，语法格式如下。

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

在很多的Java程序中，经常看到编写接口中的方法时省略了public ，有很多读者认为它的访问权限是default，这实际上是错误的。不管写不写访问权限，接口中方法的访问权限永远是public。

接口本身不能直接实例化，接口中的抽象方法和默认方法只能通过接口实现类的实例对象进行调用。实现类通过implements关键字实现接口，并且实现类必须重写接口中所有的抽象方法。需要注意的是，一个类可以同时实现多个接口，实现多个接口时，多个接口名需要使用英文逗号（,）分隔。

修饰符 class 类名 implements 接口1,接口2,...{
    ...
}

//定义接口Animal
interface Animal {
    int ID = 1;         // 定全局常量,编号
    String NAME = "牧羊犬";

    static int getID() {    // 定义静态方法getID(),用于返回ID值
        return Animal.ID;
    }

    void shout();   // 定义抽象方法shout()

    public void info();     // 定义抽象方法info()
}

interface Action {
    public void eat();      //定义抽象方法eat()
}

class Dog implements Animal, Action {
    //实现Action接口中的抽象方法eat()
    public void eat() {
        System.out.println("喜欢吃骨头");
    }

    //实现Animal接口中的抽象方法shout()
    public void shout() {
        System.out.println("汪汪");
    }

    //实现Animal接口中的抽象方法info()
    public void info() {
        System.out.println("名称:" + NAME);
    }
}

public class Summary01 {
    public static void main(String[] args){
        System.out.println("编号:"+Animal.getID());
        Dog dog=new Dog();
        dog.info();
        dog.shout();
        dog.eat();
    }
}

上述演示的是类与接口之间的实现关系，如果在开发中一个子类既要实现接口又要继承抽象类，则可以按照以下语法格式定义子类。

修饰符class 类名 extends 父类名 implements 接口1,接口2,... {
    ...
}

//定义接口Animal
interface Animal {
    public String NAME = "牧羊犬";

    public void shout();   // 定义抽象方法shout()

    public void info();     // 定义抽象方法info()
}

abstract class Action {
    public abstract void eat();
}

class Dog extends Action implements Animal {
    //实现Action接口中的抽象方法eat()
    public void eat() {
        System.out.println("喜欢吃骨头");
    }

    //实现Animal接口中的抽象方法shout()
    public void shout() {
        System.out.println("汪汪");
    }

    //实现Animal接口中的抽象方法info()
    public void info() {
        System.out.println("名称:" + NAME);
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.info();
        dog.shout();
        dog.eat();
    }
}

在Java中，接口是不允许继承抽象类的，但是允许接口继承接口，并且一个接口可以同时继承多个接口。

//定义接口Animal
interface Animal {
    public String NAME = "牧羊犬";

    public void info();     // 定义抽象方法info()
}

interface Color {
    public void black();    //定义抽象接口black()
}

//定义接口Action,Action同时继承接口Animal和接口Color
interface Action extends Animal,Color{
    public void shout();    //定义抽象方法shout()
}

class Dog implements Action {
    //实现Color接口中的抽象方法black()
    public void black(){
        System.out.println("黑色");
    }

    //实现Action接口中的抽象方法shout()
    public void shout() {
        System.out.println("汪汪");
    }

    //实现Animal接口中的抽象方法info()
    public void info() {
        System.out.println("名称:" + NAME);
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.info();
        dog.shout();
        dog.black();
    }
}

4 多态

4.1 多态概述

多态是面向对象思想中的一个非常重要的概念，在Java中，多态是指不同类的对象在调用同一个方法时表现出的多种不同行为。例如，要实现一个动物叫声的方法，由于每种动物的叫声是不同的，因此可以在方法中接收一个动物类型的参数，当传入猫类对象时就发出猫类的叫声，传入犬类对象时就发出犬类的叫声。在同一个方法中，这种由于参数类型不同而导致执行效果不同的现象就是多态。

Java中多态主要有以下两种形式。
（1）方法的重载。
（2）对象的多态（方法的重写）。

// 定义抽象类Animal
abstract class Animal {
    abstract void shout();     	// 定义抽象shout()方法
}
 定义Cat类继承Animal抽象类
class Cat extends Animal {
    // 实现shout()方法
    public void shout() {
        System.out.println("喵喵……");
    }
}
 定义Dog类继承Animal抽象类
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();
    }
}

4.2 对象类型的转换

1 对象向上转型，父类对象可以调用子类重写父类的方法，这样当需要新添功能时，只需要新增一个子类，在子类中对父类的功能进行扩展，而不用更改父类的代码，保证了程序的安全性。对于向上转型，程序会自动完成，对象向上转型格式如下所示。

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

class Animal {
    public void shout(){
        System.out.println("喵喵……");
    }
}
 定义Dog类
class Dog extends Animal {
    // 重写shout()方法
    public void shout() {
        System.out.println("汪汪……");
    }
    public void eat() {
        System.out.println("吃骨头……");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();  // 创建Dog对象
        Animal an = dog;		// 向上转型
        an.shout();
    }
}

注意:
父类Animal的对象an是无法调用Dog类中的eat()方法的，因为eat()方法只在子类中定义，而没有在父类中定义。

2 对象向下转型
除了向上转型，对象还可以向下转型。向下转型一般是为了重新获得因为向上转型而丢失的子类特性。对象在进行的向下转型前，必须先进行向上转型，否则将出现对象转换异常。
向下转型时，必须指明要转型的子类类型。对象向下转型格式如下所示。

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

// 定义Animal类
class Animal {
    public void shout(){
        System.out.println("喵喵……");
    }
}
// 定义Dog类
class Dog extends Animal {
    // 重写shout()方法
    public void shout() {
        System.out.println("汪汪……");
    }
    public void eat() {
        System.out.println("吃骨头……");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Animal an = new Dog();  // 此时发生了向上转型，子类→父类
        Dog dog = (Dog)an;       // 此时发生了向下转型
        dog.shout();
        dog.eat();
    }
}

注意：在向下转型时，不能直接将父类实例强制转换为子类实例，否则程序会报错。

4.3 instanceof关键字

Java中可以使用instanceof关键字判断一个对象是否是某个类（或接口）的实例，语法格式如下所示。

对象  instanceof  类（或接口）

// 定义Animal类
class Animal {
    public void shout() {
        System.out.println("动物叫……");
    }
}

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

    public void eat() {
        System.out.println("吃骨头……");
    }
}

// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Animal a1 = new Dog();         // 通过向上转型实例化Animal对象
        System.out.println("Animal a1 = new Dog()：" + (a1 instanceof Animal));
        System.out.println("Animal a1 = new Dog()：" + (a1 instanceof Dog));
        Animal a2 = new Animal();     // 实例化Animal对象
        System.out.println("Animal a2 = new Animal()：" + (a2 instanceof Animal));
        System.out.println("Animal a2 = new Animal()：" + (a2 instanceof Dog));
    }
}

5 Object类

Java提供了一个Object类，它是所有类的父类，每个类都直接或间接继承了Object类，因此Object类通常被称为超类。当定义一个类时，如果没有使用extends关键字为这个类显式地指定父类，那么该类会默认继承Object类。

方法名称	方法说明
boolean equals()	判断两个对象是否“相等”
int hashCode()	返回对象的哈希值
String toString()	返回对象的字符串表示形式

// 定义Animal类
class Animal {
    // 定义动物叫的方法
    void shout() {
        System.out.println("动物叫！");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args)  {
        Animal animal = new Animal();  	         // 创建Animal类对象
        System.out.println(animal.toString());	 // 调用toString()方法并打印
    }
}

在实际开发中，通常情况下不会直接调用Object类中的方法，因为Object类中的方法并不能适用于所有的子类，这时就需要对Object类中的方法进行重写，以符合实际开发需求。下面通过重写Object类的toString()方法进行演示。

// 定义Animal类
class Animal {
    //重写Object类的toString()方法
    public String toString(){
        return "这是一个动物。";
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Animal animal = new Animal(); 			// 创建animal对象
        System.out.println(animal.toString()); // 调用toString()方法并打印
    }
}

6 内部类

6.1 成员内部类

在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。成员内部类可以访问外部类的所有成员，无论外部类的成员是何种访问权限。如果想通过外部类访问内部类，则需要通过外部类创建内部类对象，创建内部类对象的具体语法格式如下：

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

class Outer {
    int m = 0;                        // 定义类的成员变量

    //外部类方法test1()
    void test1() {
        System.out.println("外部类成员方法test1()");
    }

    //外部类方法test2()
    void test2() {
        Inner inner = new Inner();                         //实例化内部类对象inner
        System.out.println("内部成员变量n = " + inner.n); //访问内部类变量和方法
        inner.show2();
    }

    // 下面的代码定义了一个成员内部类Inner
    class Inner {
        int n = 1;

        void show1() {
            // 在成员内部类的方法中访问外部类的成员变量m
            System.out.println("外部成员变量m = " + m);
            // 在成员内部类的方法中访问外部类的成员方法test1()
            test1();
        }

        void show2() {
            System.out.println("内部成员方法show2()");
        }
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Outer outer = new Outer();                //实例化外部类对象outer
        Outer.Inner inner = outer.new Inner();    //实例化内部类对象inner
        inner.show1();         //在内部类中访问外部类的成员变量m和成员方法test1()
        outer.test2();         //在内部类中访问内部类的成员变量n和成员方法show2()
    }
}

6.2 局部内部类

局部内部类，也称为方法内部类，是指定义在某个局部范围中的类，它和局部变量都是在方法中定义的，有效范围只限于方法内部。
在局部内部类中，局部内部类可以访问外部类的所有成员变量和成员方法，而在外部类中无法直接访问局部内部类中的变量和方法。如果要在外部类中访问局部内部类的成员，只能在局部内部类的所属方法中创建局部内部类的对象，通过对象访问局部内部类的变量和方法。

class Outer {
    int m = 0;                    // 定义类的成员变量

    //定义一个成员方法test1()
    void test1() {
        System.out.println("外部类成员方法test1()");
    }

    void test2() {
        //定义一个局部内部类，在局部内部类中访问外部类变量和方法
        class Inner {
            int n = 1;

            void show() {
                System.out.println("外部类成员变量m = " + m);
                test1();
            }
        }
        //访问局部内部类中的变量和方法
        Inner inner = new Inner();
        System.out.println("局部内部类变量n = " + inner.n);
        inner.show();
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test2();     //通过外部类对象outer调用创建了局部内部类的方法test2()
    }
}

6.3 静态内部类

静态内部类，就是使用static关键字修饰的成员内部类。与成员内部类相比，在形式上，静态内部类只是在内部类前增加了static关键字，但在功能上，静态内部类只能访问外部类的静态成员，通过外部类访问静态内部类成员时，因为程序已经提前在静态常量区分配好了内存，所以即使静态内部类没有加载，依然可以通过外部类直接创建一个静态内部类对象。创建静态内部类对象的基本语法格式如下。

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

class Outer {
    static int m = 0; // 定义类的静态变量
    // 下面的代码定义了一个静态内部类
    static class Inner {
        int n = 1;
        void show() {
            // 在静态内部类的方法中访问外部类的静态变量m
            System.out.println("外部类静态变量m = " + m);
        }
    }
}
public class Summary01 {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

6.4 匿名内部类

在Java中调用某个方法时，如果该方法的参数是接口类型，那么在传参时，除了可以传入一个接口实现类，还可以传入实现接口的匿名内部类作为参数，在匿名内部类中实现接口方法。匿名内部类就是没有名称的内部类，定义匿名内部类时，其类体作为new语句的一部分。定义匿名内部类的基本语法格式如下所示。

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

interface Animal {                    //定义接口Animal
    void shout();                    //定义抽象方法shout()
}

public class Summary01 {
    public static void main(String[] args) {
        String name = "小花";
        animalShout(new Animal() {    //调用animalShout()方法，参数为匿名内部类
            @Override
            public void shout() {
                System.out.println(name + "喵喵……");
            }
        });
    }

    public static void animalShout(Animal an) {    //该方法参数为Animal接口类型
        an.shout();
    }
}

首先介绍了面向对象的继承特性，包括继承的概念、方法的重写以及super关键字；
接着介绍了final关键字，包括final关键字修饰类、方法和变量；然后介绍了抽象类和接口、多态、Object类的相关知识；
最后介绍了内部类，包括成员内部类、局部内部类、静态内部类、匿名内部类。

	代码规范

（1）包名中所有字母小写

（2）类名和接口名的每个首字母都大写，ArrayList

（3）常量名中所有字母都大写，单词之间用下画线连接，DAY_OF_MONTH

（4）变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写，lineNumber，getLineNumber

（5）在程序中，尽量使用有意义的英文单词定义标识符，使程序便于阅读，userName定义用户，password定义密码