面向对象二(继承,多态,抽象类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修饰的局部变量。



 

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值