黑马程序员——面向对象三大特性

面向对象三大特性:  封装、继承、多态

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------  

一 封装

概念:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离；便于使用；提高重用性；安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

 

封装机制在程序中的体现是：把描述对象的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义在一个类中，并保证外界不能任意更改其内部的字段值，也不允许任意调动其内部的功能方法。

程序中的一种体现：通常将类中的成员变量私有化(private)，通过对外提供方法set,get,可对该变量(xxx)进行访问

 

访问修饰符

private 类访问权限:本类内部可以访问,不能继承到子类;

default 什么都不写,包访问权限:本类内部可以访问，同包其他类也可以访问,同包可继承;

protected 子类访问权限:本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问,能继承到子类;

public 公共访问权限:任何地方都可以访问,能继承到子类;

单例设计模式：

解决的问题：保证一个类在内存中的对象唯一性。 

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

 Runtime()方法就是单例设计模式进行设计的。

 如何保证对象唯一性呢？ 

 

思想： 

1，不让其他程序创建该类对象。

 2，在本类中创建一个本类对象。 

3，对外提供方法，让其他程序获取这个对象。 

步骤： 

1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象； 

2，就在类中创建一个本类的对象； 

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控） 

代码体现： 

1，私有化构造函数； 

2，创建私有并静态的本类对象； 

3，定义公有并静态的方法，返回该对象。 

--------------------------------------------- 

//饿汉式 

class Single{ 

private Single(){}         //私有化构造函数。 

private static Single s = new Single();       //创建私有并静态的本类对象。

 public static Single getInstance(){    //定义公有并静态的方法，返回该对象。 

return s; 

} 

} 

--------------------------------------------- 

//懒汉式:延迟加载方式。

 Class Single2{ 

private Single2(){} 

private static Single2 s = null; 

public static Single2 getInstance(){ 

if(s==null) 

s = new Single2(); 

return s; 

}

 }

二  继承

首先是反映一般事物特性的类,然后在此基础上反映出特殊事物的类；

也就是说：继承是一种从一般到特殊的关系；

 

好处： 

1：提高了代码的复用性。 

2：让类与类之间产生了关系，提供了另一个特征多态的前提。  

 

注意： 

子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();  

如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。 

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

 

 格式：

       [修饰符]class SubClass extends SuperClass

总结：

继承是多态的前提。

对类而言，只支持单继承。接口可以实现多继承

子类访问父类和方法覆写

子类不能直接访问父类的私有成员,但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。

Person类中有私有字段name,Student继承Person

new Sudent().name;          ×

new Student().getName();       √

 

子类拓展父类（子类是父类的一种特殊情况）

主要是以父类为基础，然后添加属于自己的字段和方法。

 

方法覆写产生原因：

当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.

调用被覆盖的父类方法：使用super.方法名(实参);

方法覆写时应遵循的原则(一同两小一大)：

(一同):方法签名必须相同;

(两小):子类方法的返回值类型比父类方法的返回值类型更小或相等   

子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;

(一大):子类方法的访问权限应比父类方法更大或相等;

 

final特点： 

1：这个关键字是一个修饰符，可以修饰类，方法，变量。

 2：被final修饰的类是一个最终类，不可以被继承。 

3：被final修饰的方法是一个最终方法，不可以被覆盖。

 4：被final修饰的变量是一个常量，只能赋值一次。  

 

抽象类的特点： 

1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。 

2：抽象方法只定义方法声明，并不定义方法实现。 

3：抽象类不可以被创建对象(实例化)。 

4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。 

5: 抽象类只能单继承。 

 

抽象类的细节： 

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。

 2：抽象类中是否可以定义非抽象方法？ 

可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。 

3：抽象关键字abstract和哪些不可以共存？final , private , static  

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

总结：

继承是多态的前提。

对类而言，只支持单继承。接口可以实现多继承

接 口：

  抽象类和接口的区别：(问的比较多,概念性的问题)

1：抽象类只能被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。

接口中都有抽象方法，需要子类去实现。

3：抽象类使用的是  is a 关系。

接口使用的 like a 关系。

4：抽象类的成员修饰符可以自定义。

接口中的成员修饰符是固定的。全都是public的。

 

 

三、面向对象之多态

多 态：函数本身就具备多态性，某一种事物有不同的具体的体现。

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

1：必须要有关系，比如继承、或者实现。

2：通常会有覆盖操作。

 

匿名内部类：没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。

匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。

匿名内部类的使用场景：

当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。

其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。

引用关系:父类变量指向子类实例对象

 

实现多态的机制:

父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定，就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

 

多态的作用：

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

只修改方法的实现，不必修改方法的声明

 

引用变量类型转换

向上转型（子类→父类）：(自动完成)

       父类名称 父类对象 = 子类实例 ;   

                    

 向下转型（父类→子类）：(强制完成)

       子类名称 子类对象 = （子类名称）父类实例 ;

 

 

对象名   instanceof 类

 

判断指定的变量名此时引用的真正类型是不是当前给出的类或子类；

总结：对象的类型和类必须有继承关系