面向对象二(继承,多态,抽象类abstract,接口Interface,内部类)

 

 

                                                                           

一 .继承 

1.概述  

 (1)例如 学生 和工人两个类   将这两个类中的共性内容抽取出来  定义成一个类 让学生和工人与单独
描述的这个类有关 抽取共性内容，建立父类。继承使用extends关键字.
 (2)作用

提高了代码的复用性。
让类与类之间产生了关系，有了这个关系，才有了多态的特性。

(3)代码：

 

class Person
{
    private String name;
    private  int age;
    Person(String name,int age)
    {
                 this.name = name;
                this.age = age;
   }
}
class Student extends Person
{            
         Student(String name,int age)
         { 
                   super(name,age);      
        } 
        void study()
         {
                System.out.println("study");
         }
}

 

 

2 继承说明：

(1):  java语言中，java类只支持单继承，不支持多继承。但Java接口支持多继承。

(2)  父类中的private方法 子类不能使用 其它的属性和方法一般都可以在子类中调用 。

 3.子父类中变量的特点
(1)如果子类中出现非私有的同名成员变量时：
子类要访问本类中的变量，用this.
子类要访问父类中的同名变量，用super

(2)super
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

4.子父类中函数的特点---覆盖

(1)当子类出现和父类一模一样的函数时，子类对象调用该函数会运行子类函数的内容。
如同父类的函数被覆盖一样。这一特性叫函数的覆盖，也叫重写。
(2)子类继承父类，没必要定义新功能，只要保留父类的功能定义，并重写功能内容即可。

(3)子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

(4)静态只能覆盖静态。

重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。

5子父类中构造函数的特点---子类实例化过程

(1)在对子类对象进行初始化时，父类的构造函数也会运行。因为子类的构造函数
默认第一行有一条隐式语句super
(2)super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认
第一行都是super()。
(3)当父类中没有空参数的构造函数时，子类必须手动通过super或this语句形式
来指定要访问的构造函数。
(4)子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
(5)this()和super()不能同时出现在构造函数中，因为它们都要写在第一行。
因为初始化动作要先做，所以必须写第一行。

二.多态

1.多态的概念
(1) 多态：可以理解为事物存在的多种体现形态。
(2)多态的体现：
父类的引用指向了自己的子类对象。

方法的重载。

方法的覆盖。

(3)多态的前提：
<1>必须是类与类之间有关系，要么继承，要么实现。
<2>通常还有一个前提：存在覆盖。

(4)多态的好处：
多态的出现大提高了程序的扩展性。

(5)多态的弊端：
只能使用父类的引用访问父类中的成员。

2.转型（引用类型强制转换）
(1)类型提升--->向上转型  //  Animal a = new Cat();
(2)转成子类型--->向下转型 //  Cat c = (Cat)a;
3.多态中成员的特点
(1)多态中成员函数的特点：
<1>在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过。如果没有，编译失败。
<2>在运行时期：参阅对象所属的类中是否有调用的方法。
<3>总结：成员函数在多态调用时，编译看左边，运行看右边。
(2)多态中成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类).
(3)多态中，静态成员函数的特点：
无论编译和运行，都参考左边。

三.抽象类

1.概述
(1)当多个类中出现相同功能，但是功能主体不同，这时可以进进向上抽取。
(2)这时只抽取功能定义，而不抽取功能主体。
(3)抽象就是笼统的，不具体的，看不懂的。

2.抽象类的特点：
(1)抽象方法一定在抽象类中。
(2)抽象方法和抽象类都必须被abstract关键字修饰。
(3)抽象类不可以用new创建对象，因为调用抽象方法没意义。
(4)抽象类中的抽象方法要被使用，必须由子类复写齐所有的抽象方法后，建立子类对象调用。
(5)如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
(6)抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

四.接口

1.接口:
初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以
通过接口的形式来表示。
2.区别：
class用于定义类。
interface用于定义接口。
3.接口的格式：interface{}
4.接口定义的格式特点：
(1)接口中常见定义：常量，抽象方法。
(2)接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
5.注意：
(1)接口中的成员都是public的。
(2)接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法
全部覆盖后，子类才可以实例化，否则子类是一个抽象类。
6.接口的特点：

(1)接口可以被多实现，也可以多继承。
(2)接口是对外暴露的规则。
(3)接口是程序的功能扩展。
(4)接口降低了偶合性
(5)类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
(6)接口与接口之间可以有继承关系。
(7)基本功能定义在类中，扩展功能定义在接口中。
 

五.内部类

1.内部类
(1)将一个类定义在另一个类的里面，对里面那个类就称为内部类,或叫内置类，嵌套类。
(2)访问特点：
<1>内部类可以直接访问外部类中的成员，包括私有成员。
<2>外部类要访问内部类中的成员，必须要建立内部类的对象。

3)注意：
<1>内部类之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用。
格式为：外部类名.this

<2>内部类可以被私有封装。
<3>内部类可以被static修饰。

(4)代码示例：

class Outer
{
private int x = 3;
class Inner
{
int x=4;
void function()
{
int x=6;
System.out.println("inner:" + this.x);
}
}
void method()
{
Inner in = new Inner();
in.function();
}
}

 

 

2.静态内部类
(1)访问格式：
<1>当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象。
格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象
如： Outer.Inner in = new Outer().new Inner();
<2>当内部类在成员位置上，就可以被成员修饰符所修饰。
比如：private:将内部类在外部类中进行封装。
static :内部类就具备static特性

a.当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
b.在外部其他类中，如何直接访问static内部类的静态成员呢？
new Outer.Inner().function();
c.在外部其他静态类中，如何直接访问static 内部类的静态成员呢？
Outer.Inner.function();

(2)注意：
<1>当内部类中定义了静态成员，该内部类必须是static的。
<2>当外部类中的静态方法访问内部类时，内部类也必须是静态的。

3.内部类的定义原则：

当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容。

4.匿名内部类：

要点：
(1)内部类只有定义在成员位置上时，才能被private和static所修饰，一般内部类是不会被public所修饰的。
(2)内部类可以被写在任意位置上，成员也可以。局部也可以。
(3)非静态，没对象不运行
(4)从内部类中访问局部变量，需要被声明为最终类型(加final).
(5)内部类定义在局部时：
<1>不可以被成员修饰符修饰。
<2>可以直接访问外部类中的成员，因为还持有外部类中的引用，但是不可以访问它所在的局部中的变量，
只能访问被final修饰的局部变量。

注意：
(1)匿名内部类其实就是内部类的简写格式。
(2)定义匿名内部类的前提：内部类必须是继承一个类或者接口。
(3)匿名内部类的格式：new 父类或接口(){定义子类的内容}
(4)其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的对象。
(5)匿名内部类中定义的方法不要超过3个，最好是2个或者1个。
(6)定义匿名内部类，就是为了简化书写，覆盖方法。

六.Object类

1.Object类
(1)Object:是所有对象的直接或者间接父类，是一个超类，该类中定义的肯定是所有对象都具备的功能。
(2)Object类中已经提供了对对象是否相同的比较方法，如果自定义类中也有比较相同的功能，没必要
重新定义，只要沿袭父类中的功能，建立自己特有的比较内容即可，这就是覆盖。
(3)java认为所有对象都具备比较性，该方法equals定义在Object中。
2.Object中方法：
(1)toString():返回该对象的字符串表示，所有对象都可以变成字符串打印。
(2)hashCode():返回该对象的哈希码值。
(3)getClass():返回此Object的运行时类。

(4)wait();

(5)notify();

(6)notifyAll();

七.final关键字

final:意为“最终”，是一个修饰符。
(1)可以修饰类，函数，变量。
(2)被final修饰的类，不可以被继承。
(3)被final修饰的方法不可以被复写。如：final void show(){}//最终方法
(4)被final修饰的变量是一个常量。如：final int x=3;
(5)内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。