黑马程序员——Java语言基础——03.面向对象（2）三大特征

------- android培训、java培训、期待与您交流！ ----------

面向对象三大特征是：封装(encapsulation)、继承(inheritance)、多态(polymorphism)

本节考点：

一、对象的实例化过程

一个对象实例化过程，以Person p = new Person();为例：
1、JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）。
2、在内存中开辟空间，并分配地址。
3、并在对象空间中，对对象的属性进行默认初始化。
4、调用对应的构造函数进行初始化。
5、在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6、父类初始化完毕后，再对子类的属性进行显示初始化。
7、再进行子类构造函数的特定初始化。
8、初始化完毕后，将地址值赋值给引用变量。

二、接口和抽象类的异同

抽象类和接口的异同点？
相同点：
都是不断向上抽取而来的。
不同点：
①抽象类需要被继承，而且只能单继承。
   接口需要被实现，而且可以多实现。
②抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
   接口中只能定义抽象方法，必须由子类去实现。
③抽象类的继承，是is a关系，定义该体系的基本共性内容。
   接口的实现是like a关系。

2-1 封装（Encapsulation）

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

好处：
①将变化隔离。
②便于使用。
③提高重用性。
④提高安全性。

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

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">/*人：属性：年龄行为：说话*/class Person{       //private：私有，是一个权限修饰符，用于修饰       //不希望别人直接访问赋值，需要通过私有化把属性进行隐藏       private int age ;       //通过提供set、get公共方法对其访问       public void setAge( int a){             //在set方法内可以对属性的赋值进行限制             if (a > 0 && a < 130){                   age = a;            } else                  System. out .println("错误的数据" );      }       public int getAge(){             return age ;      }       void speak(){            System. out .println("age = " + age);      }}class PersonDemo{       public static void main(String[] args){            Person p = new Person();            //通过其他方式访问            p.setAge(20);            p.speak();            //赋值不合法，set方法就不允许成功赋值            p.setAge(-20);      }} </span>

注意：

1、私有仅仅是封装的一种体现而已。

2、private关键字：是一个权限修饰符，用于修饰成员(成员变量和成员函数)，被私有化的成员只在本类中有效。

3、常用场景之一：将成员变量私有化，对外提供对应的set、get方法对其进行访问，提高对数据访问的安全性。

2-2 继承

2-2-1 继承的概述

 

通过 extends 关键字让类与类之间产生继承关系。

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。

注意：

①子类可以直接访问父类中的非私有的属性和行为。

②子类无法继承父类中私有的内容。
③父类怎么来的？共性不断向上抽取而来的。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">ExtendDemo.javaclass Person{      String name;      int age ;}class Student extends Person{       void study(){            System. out.println("student study..." + age);      }}class Worker extends Person{       void work(){            System. out.println("worker work..." + age);      }}class ExtendDemo{       public static void main(String[] args){            Student s = new Student();            s. name = "zhangsan" ;            s. age = 20;            s.study();            Worker w = new Worker();            w. name = "lisi" ;            w. age = 30;            w.work();      }}</span>

好处：

继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。

2-2-2 继承的特点

Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。

原因：

因为多继承容易出现问题。

两个父类中有相同的方法。子类到底要执行哪一个是不确定的。

Java支持多层继承(继承体系)

C继承B，B继承A，就会出现继承体系。

多层继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象，即可使用该体系功能。

定义继承需要注意：
不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属( "is a")关系。

2-2-3 super关键字 & 函数覆盖

在子父类中，成员的特点体现：
①成员变量

this和super的用法很相似。

this代表本类对象的引用。

super代表父类的内存空间的标识。

当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">ExtendDemo.javaclass Fu{       private int num = 4;       public int getNum(){             return num ;      }}class Zi extends Fu{       private int num = 5;           void show(){            System. out.println(this.num + "..." + super.getNum());      }}class ExtendDemo{       public static void main(String[] args){            Zi z = new Zi();            z.show();      }}</span>

②成员函数

当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作，这是函数在子父类中的特性。

在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

函数两个特性：
1、重载，同一个类中。
2、覆盖，子类中，覆盖也称为重写，覆写，override。

什么时候使用覆盖操作？

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

①父类中的私有方法不可以被覆盖。

②父类为static的方法无法覆盖。

③覆盖时，子类方法权限一定要大于等于父类方法权限。

③构造函数

子父类中构造函数的特点：
在子类构造函数执行时，发现父类构造函数也运行了。
原因：在子类的构造函数中，第一行有一个默认的隐式语句：super();。

注意：如果使用super(4);语句调用父类的其他构造函数，那么默认的父类构造函数将不会再被调用。

2-2-4 子类的实例化过程

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

子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。

注意：

①当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

②子类构造函数中如果使用this调用了本类构造函数，那么默认的super();就没有了，因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

③super语句必须要定义在子类构造函数的第一行！因为父类的初始化动作要先完成。

2-2-5 final关键字

final可以修饰类，方法，变量。
final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

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

为什么要用final修饰变量，其实在程序中如果一个数据是固定的。
那么直接使用这个数据就可以了，但是这种阅读性差，所以应该给数据起个名称。
而且这个变量名称的值不能变化，所以加上final固定。
写法规范：常量所有字母都大写，多个单词，中间用_连接。

2-3 抽象类

2-3-1 抽象类概述

抽象定义：
抽象就是从多个事物中将共性的，本质的内容抽取出来。
例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

抽象类：
Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：
多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

2-3-2 抽象类的特点

抽象类和抽象方法必须用abstract关键字来修饰。

抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符 abstract 返回值类型 函数名(参数列表) ;

抽象类不可以被实例化，也就是不可以用new创建对象。

原因如下：
①抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
②而且抽象类即使创建了对象，调用抽象方法也没有意义。
③抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

2-3-3 抽象类相关问题

抽象类中是否有构造函数？

答：有，用于给子类对象进行初始化。

抽象关键字abstract不可以和哪些关键字共存？

答：private、static、final。

抽象类中可不可以没有抽象方法？

答：可以，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。

示例：

abstract class Demo{
     void show1(){}
     void show2(){}
}

抽象类和一般类的区别？

答：

相同点：
抽象类和一般类都是用来描述事物的，都在内部定义了成员。

不同点：
①一般类有足够的信息描述事物。
   抽象类描述事物的信息有可能不足。
②一般类中不能定义抽象方法，只能定义非抽象方法。
   抽象类中可定义抽象方法，同时也可以定义非抽象方法。
③一般类可以被实例化。
   抽象类不可以被实例化。

抽象类一定是个父类吗？

答：是的，因为需要子类覆盖其方法后才可以对子类实例化。

2-3-4 接口

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。

格式：interface {}

接口中的成员修饰符是固定的：
成员常量：public static final
成员函数：public abstract

由此得出结论，接口中的成员都是公共的权限。

接口是对外暴露的规则。
接口是程序的功能扩展。

注意：

①虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。

②类与类之间是继承关系，类与接口直接是实现关系。

③接口不可以实例化,只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

在java中不直接支持多继承，因为会出现调用的不确定性。

所以，java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。

接口的出现避免了单继承的局限性。

2-4 多态

2-4-1 定义

某一类事物的多种存在形态。
例：动物中猫，狗。
猫这个对象对应的类型是猫类型：猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物：动物  y = new 猫();
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。

多态性简单说就是一个对象对应着不同类型。

体现：
父类或者接口的引用指向或者接收自己的子类对象。
作用：
多态的存在提高了程序的扩展性和后期可维护性。

前提：
①需要存在继承或者实现关系。
②需要有覆盖操作。

好处：

提高了代码的扩展性，前期定义的代码可以使用后期的内容。
弊端：
前期定义的内容不能使用（调用）后期子类的特有内容。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">/*毕老师和毕姥爷的故事*/class 毕姥爷{       void 讲课(){            System. out.println("管理" );      }       void 钓鱼(){            System. out.println("钓鱼" );      }}class 毕老师 extends 毕姥爷{       void 讲课(){            System. out.println("Java" );      }       void 看电影(){            System. out.println("看电影" );      }}class DuoTaiDemo{       public static void main(String[] args){            毕老师 x = new 毕老师();            x.讲课(); //Java            x.看电影(); //看电影            毕姥爷 y = new 毕老师();            y.讲课(); //Java            y.钓鱼(); //钓鱼            毕老师 z = (毕老师)y;            z.看电影(); //看电影      }}</span>

2-4-1 多态时成员的特点

①成员变量
     编译时：参考引用型变量所属的类中的是否有调用的成员变量。有，编译通过，没有，编译失败。
     运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
     简单说：编译和运行都参考等号的左边。

②成员函数（非静态）
     编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过。没有，编译失败。
     运行时：参考的是对象所属的类中是否有调用的函数。
     简单说：编译看左边，运行看右边。

③静态函数
     编译时：参考的是对象所属的类中是否有调用的函数。
     运行时：参考的是对象所属的类中是否有调用的函数。
     简单说：编译和运行看左边。

2-4-3 内部类

定义：

将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。
访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。

内部类的位置

内部类定义在成员位置上,可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

①如果内部类中定义了静态成员，该内部类也必须是静态的！

②为什么内部类能直接访问外部类中的成员呢？
那是因为内部类持有了外部类的引用，外部类名.this。

③内部类定义在局部位置上，也可以直接访问外部类中的成员。

同时可以访问所在局部中的局部变量，但必须是被final修饰的。

示例：

class InnerDemo{public static void main(String[] args){Outer out = new Outer();//建立外部对象out.method();//通过外部对象的方法访问内部类/*直接访问内部类的方式：Outer.Inner in = new Outer().new Inner();in.in();*///Outer.Inner.in();//如果类名和内部方法没有静态，则，使用 new Outer.Inner().in();}}class Outer{private static int x = 4;private static class Inner//类名和内部方法以及调用的变量必须都是static{//内部类一般被私有修饰，通过外部类的方法调用即可//int x = 5;static void in(){//int x = 6;System.out.println("shabi:"+x);//内部类可以直接访问外部类变量，即使是私有变量}<span style="white-space:pre"></span>//内部类访问外部类原理，即类名.this.变量 Outer.this.x}void method(){Inner in = new Inner();//通过函数method才能访问内部类in.in();}}

2-4-4 匿名内部类

定义：

就是内部类的简化写法。
前提：
内部类可以继承或实现一个外部类或者接口。
格式：
new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。

什么时候使用匿名内部类呢？
通常在使用方法是接口类型参数，并且该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。
好处：

增强阅读性。

示例：

<span style="font-family:Microsoft YaHei;font-size:14px;">class Outer{       int num = 4;       void method(){             new Demo(){//匿名内部类                   void show(){                        System. out.println("show......" + num);                  }            }.show();      }}class InnerClassDemo{       public static void main(String[] args){             new Outer().method();      }}</span>

/*内部类放在局部时，即处于函数中不可以被成员修饰符修饰可以访问外部成员变量，但不能访问局部，除非局部变量被final修饰。*/class Outer{private int x = 3;void method(){final int y = 2;//final类型才能被内部类访问class Inner{void function(){System.out.println("shabi:"+x+y);}}new Inner().function();}}class PartInner {public static void main(String[] args) {new Outer().method();/*Outer out = new Outer();out.method(3);out.method(4);[上面的method（final int a）]每次打印出的结果依旧会变化，因为栈内存中数据运行结束后释放*/}}

------- android培训、java培训、期待与您交流！ ----------