Java—类的封装、继承与多态

一.类和对象

1.类

类是数据以及对数据的一组操作的封装体。

类声明的格式：

类声明

{

　　成员变量的声明；

　　成员方法的声明及实现；

}

1.1 声明类

[修饰符] class 类<泛型> [extends 父类] [implements 接口列表]

<泛型>——类的参数，带有参数的类成为泛型类。

1.2 声明成员变量和成员方法

成员变量声明格式：[修饰符] 数据类型 变量[=表达式]{，变量[=表达式]}；

成员方法——用来描述对成员变量进行的操作，格式：[修饰符] 返回值类型 方法（[参数列表]）[throws 异常类]
{
 　　语句序列；
 　　[return [返回值]]；
}

例如：

public class MyDate   //类声明

{

　　int year,month,day;  //声明成员变量

　　void set(int y,int m,int d)   //成员方法，设置日期值

　　{                                    //无返回值，有三个参数

　　　　　　year=y;

　　　　　　month=m;

　　　　　　day=d;

　　}

}

2.对象

类本身不参与程序运行，实际参与运行的是类的对象。

对象是类的实例（instance），即类的取值。类的一个对象能够获得并保存类的一个实例。

类比：类——对象——类的实例

　　　　数据类型———变量——取值

　　　　例如：int类型——变量i——取值10

2.1 MyDate d=new MyDate();//声明对象，创建实例并赋值

2.2 引用对象的成员变量和调用成员方法

　　　　对象.成员变量

　　　　对象.成员方法（[参数列表]）

注：Java的内存自动管理机制，能够跟踪存储单元的使用情况，自动回收不再被使用的资源，所以，程序中不需要释放对象占用的空间资源。

Java的类是引用数据类型，两个对象之间的赋值是引用赋值，对象赋值过程中没有创建新的实例。

（注：1、“==”作用在引用数据类型间，判断内存地址是否相等，想判断内容实体用equals；
　　  2、基本传值传参传的是副本，修改后原值不变；引用传值传参穿的是地址，修改后原值改变。

　　引用类型 就是只变量中存储的不是值而是一个内存中的地址的数据类型
　　也就是说 变量中存储了这个变量的值所在内存中的地址 每次调用这个变量都是引用这个地址而得到真正的值 所以叫引用类型 。

　　通俗说，将变量名与变量值分开，比如Student s=new Student(),s就是个引用类型的变量，s这个名分配在栈空间里，但是s它指向的值在堆空间里）

二、类的封装性

1.构造方法

用于创建类的一个实例并对实例的成员变量进行初始化。构造方法与类同名；构造方法通过new运算符调用。

构造方法和成员方法的不同之处：

A.作用不同：成员方法实现对类中成员变量的操作；构造方法用于创建类的实例并对实例的成员变量进行初始化。

B.调用方式不同：成员方法通过对象调用；构造方法通过new运算符调用。

例如：

public class MyDate

{

　　public MyDate (int y,int m,int d)

　　{

　　　　year=y;month=m;day=d;

　　}

}

使用new运算符调用自定义的构造方法，参数必须符合构造方法的声明。

MyDate d=new MyDate(2009,7,18);//创建实例并初始化成员变量

拷贝构造方法

一个类的构造方法，如果其参数是该类对象，称为拷贝构造方法，它将创建的新对象初始化为形式参数的实例值，实现对象复制功能。

Java不提供默认拷贝构造方法。

public class MyJava {

public static void main(String[] args) {
  // TODO 自动生成的方法存根
  MyJava d1=new MyJava(2016,4,27);
  MyJava d2=new MyJava(d1);
  System.out.print(d2.year);
 }

private int year;
 private int month;
 private int day;
 
public MyJava(int y,int m,int d){
 year = y;
    month=m;
 day=d;
}
public MyJava(MyJava d){
 year = d.year;
    month=d.month;
 day=d.day;
}

输出：2016

2.this引用和instanceof 对象运算符

2.1 this引用

（1）指代对象本身 this

this用于指代调用成员方法的当前对象自身。

（2）访问本类的成员变量和成员方法

this.成员变量

this.成员方法([参数列表])

public MyDate(int year,int month,int day)

{  //指定参数的构造方法，参数与成员变量同名

　　this.year=year;//this.year指定当前对象的成员变量，year指参数

　　this.month=month;//this引用不能省略

　　this.day=day;　　

}

public MyDate()   //默认构造方法，重载

{

　　this(1970,1,1);//调用本类已定义好的构造方法

}

public MyDate(MyDate d)

{

　　this(d.year,d.month,d.day);　　

}

2.2 instanceof 对象运算符

判断一个对象是否属于指定类及其子类，返回boolean类型。

例：MyDate d=new MyDate();

d instanceof MyDate

//返回true，d是MyDate类的实例

3 访问控制

3.1 类的访问控制权限

声明一个类可使用的权限修饰符只有两种： public 和 缺省

　　共有权限public，可被所有类访问

　　缺省权限无修饰符，可被当前包（当前文件夹）中的类访问。

一个源程序文件中可声明多个类，但用public修饰的类只能有一个，且该雷鸣必须与文件名相同。

　　源程序文件MyDate.java中可声明多个类如下：

　　　　public class MyDate  //公有权限的类

　　　　class MyDate_ex //缺省权限的类

类的成员有4种访问控制权限

private—声明私有成员，该成员仅能被当前类的成员访问。（当前类）

缺省—没有修饰符表示缺省权限，说明该成员能被当前类以及当前包中的其他类访问，也称在当前包中可见。（当前包）

protected—声明保护成员，该成员能被当前类及其子类、或当前包中的其他类访问，也称在子类中可见。（子类）

public——声明公有成员，该成员可被所有类访问。（所有）

声明set()和get()方法存取对象的属性 —值对象的某个特性或特征

　　Java约定，存取对象属性的方法分别是set()和get()。

　　　　public void set(int y,int m,int day)//设日期

　　　　public void set(MyDate d)//设置日期，重载

　　　　public int getYear()//获取年份

4 静态成员

实例成员—属于对象，包括实例成员变量和成员方法。只有创建了实例，才能通过对象访问实例成员变量和实例成员方法。

静态成员—属于类，需要用关键字static标识。包括类成员变量和类成员方法。即使没有创建实例，也可以通过类名直接访问类静态成员变量和调用静态成员方法。

5 析构方法

——用于释放实例并执行特定操作。

public void finalize() //约定析构方法名为finalize

{                           //finalize()没有参数，也没有返回值

　　语句序列；

}                          //一个类只能有一个finalize()方法，qiefinalize()不允重载

　　Java的内存自动管理机制能够释放不再将被使用的对象，所以，通常类不需要设计析构方法。

如果需要在释放对象时执行特定操作，则类可以声明析构方法。

注：A.当对象超出它的作用域时，Java将执行对象的析构方法。

　　B.一个对象也可以调用析构方法来释放对象自己。

　　C.不能使用已被析构方法释放的对象，否则将产生运行错误。

例如：d.finalize(); //调用对象的析构方法

6 浅拷贝与深拷贝

浅拷贝—一个类的拷贝构造方法，使用一个已知实例对新创建实例的成员变量逐个赋值，这种方法称为浅拷贝。

　　当对象的成员变量是基本数据类型时，两个对象的成员变量已有存储空间，赋值运算传递值，所以浅拷贝能够赋值实例。

　　当对象的成员变量是引用数据类型时，浅拷贝不能实现对象复制功能，需要深拷贝。

　　public class Person

{

　　String name;                     //姓名

MyDate birthday;                //生日

public Person(String name,MyDate birthday)   //构造方法

　　{

　　　　this.name=name;

　　　　this.birthday=birthday;    //引用赋值

　　}

public Person(Person p)          //拷贝构造方法，复制对象

　　{

　　　　this(p.name,p.birthday);

　　}　　

　}

深拷贝—当一个类包含引用类型的成员变量时，该类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并初始化为形式参数实例值，这种复制方法称为深拷贝。

三 类的继承

1 由继承派生类

继承：根据一个已知的类由继承方式创建一个类，使新创建的类自动拥有被继承类的全部成员。

父类/超类——被继承类；子类/派生类——通过继承产生的新类

父类和子类的关系：

A.子类自动拥有父类的全部成员，包括成员变量和方法等，使父类成员得以传承和延续；

B.子类可以更改从父类继承来的成员，使父类成员适应新的需求；

C.子类也可以增加自己的成员，使类的功能得以扩充。

D.子类不能删除父类的成员。

声明继承类：[修饰符] class <泛型>[extends 父类] [implements 接口列表]

注：Java的类是单继承的，一个类只能有一个父类，不能有多个父类。

1.1 继承原则

（1）子类继承父类的成员变量

（2）子类继承父类除构造方法以外的成员方法

（3）子类不能继承父类的构造方法

子类没有继承父类的构造方法，因为父类的构造方法只能创建父类实例并初始化，无法创建实例。

例如：父类声明构造方法Person(String,MyDate),当子类没有生命Student(String,MyDate)构造方法时，下列语句是错误的：

　　　　　　Student s1=new Student("李小明"，new MyDate(1979,3,15));//语法错，构造方法参数不匹配

（4）子类可以增加成员，可以重定义从父类继承来的成员，但不能删除。

1.2 子类的构造方法

子类对象包含从其父类继承来的成员变量，以及子类声明的成员变量，子类构造方法必须对这些成员变量进行初始化。而父类构造方法已对父类声明的成员变量进行了初始化，因此，子类构造方法必须调用父类的某一个构造方法。

1.2.1 使用super()调用父类构造方法

　　　　　在子类的构造方法体中，可以使用"super引用"调用父类的构造方法。其语法如下：

　　　　　　　　　　　　　　super([参数列表])

　　　　　public Student(String name,MyDate birthday,String spec)

　　　　　{

　　　　　　　super(name,birthday);   //super()调用必须是第一条语句  调用父类同参数的构造方法

　　　　　　　this.speciality=spec;

　　　　　}

1.2.2 默认执行super()

以下两种情况，Java默认值型super()，调用父类的构造方法。

（1）当一个类没有声明构造方法时，Java为该类提供默认构造方法，调用super()执行父类无参数的构造方法。

　　public Student()    //Java提供的默认构造方法

　　{

　　　　　　super();     //调用父类构造方法Person()

　　}

如果父类Person没有声明构造方法Person()，则上述语句产生编译错误。因此，每个类都要声明无参数的构造方法，即使自己不用，也要为子类准备着。

　　　　　　public Person()   //Java提供的默认构造方法

　　　　　　{

　　　　　　　　super();        //调用父类构造方法Object()

　　　　　　}

（2） 如果子类的构造方法没有调用super()或this()，Java将默认执行super()。

　　　　　　public Student()

　　　　　　{

　　　　　　　　super();

　　　　　　　　speciality="";

　　　　　　}

1.3 类的多态性

类的多态性表现为方法的多态和类型的多态。

方法的多态：包括方法的覆盖和重载，为一种功能提供多种实现。

类型的多态：子类是一种父类类型。

子类重定义父类成员包括：

（1）重定义父类的成员变量，则隐藏父类的成员变量；

（2）重定义父类的成员方法，如果参数列表相同，则覆盖父类的成员方法，否则重载。

子类重定义父类成员表现出多态，父类对象引用父类成员，子类对象引用子类成员。

在子类的成员方法中，如果需要引用被子类隐藏或覆盖的父类同名成员，可以用super引用。格式如下：

super.成员变量

super.成员方法([参数列表])

子类对象即是父类对象——子类对象包含父类的所有成员变量，isA关系表现为继承具有“即是”性质。 new Person()/Student() instanceof Person

父类对象引用子类实例——父类对象能够引用子类实例

Person p=new Student();

1.3.1 编译时多态和运行时多态

　（1）编译时多态

　　　　对于多个同名方法，如果在编译时能够确定执行同名方法中的哪一个，则称编译时多态。

方法的重载—都是编译时多态性

　　  方法的覆盖—当对象引用本类实例时，为编译时多态；

　　　                 否则，运行时多态。

　　　Person p1=new Person("李小明"，new MyDate(1979,3,15));

　　　System.out.println("p1:"+p1.toString()); //编译时多态性，执行Person类的toString()

　　（2）运行时多态

　　　　父类对象只能执行哪些在父类中声明、被子类覆盖了的子类方法，如toString()，不能执行子类中新增加的成员方法。

程序运行时，Java从实例所属的类开始寻找匹配的方法执行，如果当前类中没有匹配方法，则沿着继承关系逐层向上，依次在父类和各祖先类中寻找匹配方法，直到Object类。

四 类的抽象性

抽象类特点：1）抽象类中可以不包含抽象方法，但是包含抽象方法的类必须被声明为抽象类；

2）构造方法、静态成员方法不能被声明为抽象方法；

　　　　　　　　3）一个非抽象类必须实现从父类继承来的所有抽象方法，如果不能实现父类的所有抽象方法，则该类必须声明为抽象类；

　　　　　　　　4）抽象类不能被实例化，不能创建抽象类实例。