java笔记分享（4）

this关键字

在类的内部，可以在任何方法中使用this引用当前对象。

使用this关键字解决在实例变量和局部变量之间可能发生的任何名称冲突。

局部变量，包括方法的形参，可以和类的实例变量重名。当局部变量和实例变量具有相同的名称时，局部变量隐藏了实例变量。

static关键字

在正常情况下，只有通过组合类的对象才能访问该类的成员。有时可能希望定义能够独立于类的所有对象进行使用的成员。为了创建这种成员，需要在成员声明的前面使用关键字static。例如Math类中的方法，就是静态方法。

方法和变量都可以声明为静态的。main()方法是最常见的静态成员的例子。main()方法被声明为静态的，因为需要在创建所有对象之前调用该方法。

静态变量

案例：（演示静态变量的访问方式、不同实例共享相同的值）

Math中的成员变量PI就是静态变量。

public class StaticM{

//实例变量

private int i;

//静态变量

static int  si;

public static showStatic(){};

}

特别注意：

（1）被声明为静态的变量本质上是全局变量，类的所有实例共享相同的静态变量。因此，通过一个对象修改静态变量的值后，通过该类的其他对象访问到的静态变量是修改后的值。

（2）访问静态变量的方式：

类名.变量名（推荐）

对象.变量名（不推荐）

（3）初始化时机

静态变量：当类被虚拟机加载，静态变量就初始化，既不需要创建类的对象就可以使用静态变量。

实例变量：创建类的对象时初始化

静态代码块

静态代码块,只执行一次,而且是类加载时就执行

作用：一般完成静态变量初始化赋值或完成整个系统只执行一次的任务

静态方法

最典型的静态方法是main()方法；

静态的方法有几个限制：

l 它们只能直接调用其他静态方法。

l 它们只能直接访问静态数据

l 它们不能以任何方式引用this或super关键字。（super是与继承相关的关键字，将在下一章介绍。）

案例：

改写前面的Calculator类，使用静态方法实现两个数量相加的功能。

main方法、math类中提供的许多方法都是静态方法

关于static的几点说明

1、static的本质作用是区分成员属于类还是属于实例。

2、通常把使用static修饰的变量和方法称为类变量和类方法，有时也称为静态变量和静态方法，把不使用static修饰的变量和方法称为实例变量和实例方法。

3、对于使用static修饰的成员，既可以通过类来调用也可以通过类的实例调用，但是建议使用类调用静态成员。对于实例变量和实例方法，则只能通过类的实例调用。

继承是面向对象的基本特征之一。

继承的概念

使用继承可以为一系列相关对象定义共同特征的一般类，然后其他类(更特殊的类)可以继承这个一般类，每个进行继承的类都可以添加其特有的内容。

被继承的类称为超类（super class）/父类，继承的类称为派生类/子类（subclass）。

一旦创建了一个定义一系列对象共同特征的超类，就可以使用该超类创建任意数量的更特殊的子类。

继承的语法

继承使用关键字extends（扩展）实现。

public class A extends SuperA{

}

子类可以从父类继承属性和部分方法，自己再增加新的属性和方法。通过继承可以重用父类的方法和属性，减少代码重复编写，便于维护、代码扩展。

继承案例：

案例1

父类：Person：name  age  sex  sleep()

子类：Student：grade  score  study()

子类：Teacher：college  course  teach()

案例2：

父类：Animal：name  color  age  eat();  “动物吃东西！”

子类：Dog：layal  watch();  “忠诚地看家护院”

子类：Cat：wakan  CatchMouse();  “聪明地捉老鼠”

案例3：

父类：Box：length  width  height  volume()

子类：WeightBox：weight  

子类：ColorBox：color

对继承的说明

（1）子类不能从父类继承的资源：私有方法、构造方法、如果子类与父类在不同包中，子类不能继承父类中那些具有默认访问权限的方法。即不能继承那些不能访问的方法。在子类中不能访问到的那些方法，无法继承的。

理论上子类会继承父类的全部成员变量，但是子类不能访问父类的私有成员变量，如果子类与父类在不同包中，子类也不能访问父类中具有默认访问权限的成员变量。

（2）java类继承只允许单继承（只能有一个超类）；java中接口允许多继承。

（3）子类中可以定义与父类中同名的成员变量，这时子类的成员变量会隐藏/覆盖父类中的同名成员变量。

（4）子类中也可以定义与父类中同名的成员方法，这时子类中的方法重写了父类中的同名方法。

子类的构造方法

（1）构造方法的调用顺序

在类继承层次中按照继承的顺序从父类到子类调用构造函数。

（2）在子类的构造方法中，一定会首先调用父类的构造方法。super();

（3）子类的每个构造方法都会隐式的调用父类的无参数构造方法，如果想调用父类的其他构造方法，必须使用super(参数列表)来显式调用。

说明：编写类时，通常需要提供无参数构造方法。

（4）如果父类没有无参的构造方法，或者想调用父类的有参构造方法，则在子类的构造方法中必须显式使用super(xxx)调用父类有参构造方法。这时super(xxx)必须是子类中的第一条语句。

（5）通常的做法：

在父类中定义有参数的构造方法，负责初始化父类的成员变量。

在子类的构造方法中，先调用父类的构造方法完成从父类继承来的那些成员变量，然后初始化子类中特有的成员变量。

注意：

如果父类中定义了一个有参数的构造方法，系统就不会再为父类提供默认的构造方法。这时，在子类的构造方法中，必须使用super(xxx)显示调用父类的有参构造方法。

创建多级继承层次

public  GrandFather( ){

}

public  Father( ) extends GrandFather{

}

public  Son( )  extends Father{

}

案例：BawieStudent继承自Student类

方法重写介绍

当子类从父类中继承来的方法不能满足需要时，子类可以重写该方法，重写方法要求方法名与参数列表都相同。

案例：

重写Student、Teacher类中的sleep()、show()

重写Dog、Cat类中的eat()、show()

重写WeightBox、ColorBox类中的Show()

超类引用变量可以引用子类对象

SuperA  sa;     //声明超类的变量

A  a = new A();  //创建子类对象

sa = a;          //将子类对象赋给引用对象

sa = new A();    //创建一个新的子类对象，赋给超类引用变量

可以将子类的对象赋给父类的引用变量，但是这时使用父类的引用变量只能访问父类中定义的那些成员变量。换句话说，可以访问哪些成员是由引用变量的类型决定的，而不是由所引用的对象类型决定的。

动态方法调度介绍：

案例演示：

对象的转型

Animal a = new Dog();  //小转大  可以自动进行

a.layal;  //语法错误，这时通过a只能使用父类中定义的成员变量。编译时就确定

a.eat();  //

Animal a = new Dog()；

d = (Dog)a;  //正确   大转小， 需要强制转换

Dog d = new Animal();  //错误

Dog d = (Dog)new Animal();  //语法没错，可以编译，但运行时会抛出异常

Cat c = new Cat();

d = (Dog)c; //不正确

子类对象 赋给 父类引用  可以，自动转换

父类引用  赋给  子类引用  需要强转 ，前提：父类引用确实指向了正确的子类对象

super关键字

关键字super用于调用/访问从父类中继承来的实例变量和方法。

super有两种一般用法。第一种用于调用超类的构造方法。第二种用于访问超类中被子类的某个成员隐藏的成员。

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

l 在子类中使用super()调用父类的构造方法，必须是第一条语句

l 在本类中可以使用this()调用重载的构造方法，也必须是第一条语句

l 在子类的构造方法中this()和super()不能同时使用

8.2.2  使用super访问父类中被子类隐藏的成员变量

父类的属性被子类继承，如果子类又添加了名称相同的属性，则子类有两个相同名称的属性，如果父类型对象调用属性，就是父类的，如果是子类型对象调用就是子类的属性。

一个子类需要引用它的直接超类，都可以使用关键字super。

案例：

Object

Object类介绍

所有其他类都是Object的子类。也就是说，Object是所有其他类的超类。这意味着Object类型的引用变量可以引用任何其他类的对象。此外，因为数组也是作为类实现的，所以Object类型的变量也可以引用任何数组。

Object类定义了下面列出的方法，这意味着所有对象都可以使用这些方法。

方  法	用  途
Object clone()	创建一个和将要复制的对象完全相同的新对象。
boolean equals(Object object)	确定一个对象是否和另外一个对象相等
void finalize()	在回收不再使用的对象前调用
Class getClass()	在运行时获取对象的类
int hashCode()	返回与调用对象相关联的散列值
void notify()	恢复执行在调用对象上等待的某个线程
void notifyAll()	恢复执行在调用对象上等待的所有线程
String toString()	返回一个描述对象的字符串
void wait() void wait(long milliseconds) void wait (ling milliseconds, int nanoseconds)	等待另一个线程的执行

对象相等性比较

Object类中的equals()方法实现等价于“==”运算符，比较相等，如果实现对象的内容相等比较，自己的类必须重写equals方法。

例如：String类对equals()方法进行了重写，重写后的equals方法比较两个两个字符串的内容是否相同。

Object类的常用方法

l equals(Object  obj)方法

比较对象相等   Object类的实现是 等价于 ==

相等的含义：两个引用是否指向同一个对象。

自己的类要比较对象相等，重写equals()方法

案例：重写Box类的equals()方法

l toString()方法

直接打印对象时，默认调用对象的toString()方法

Object类的toString方法输出格式：

getClass().getName() + '@' + Integer.toHexString(hashCode())

自己的类要重写toString()

案例：重写Box类的toString()方法。l protected  

Object  clone()

克隆对象的方法   被克隆的对象的类必须实现Cloneable接口

l finalize()方法    //终结方法

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

l HashCode()方法

返回该对象的哈希码值

当我们重写equals()方法，判断两个对象相等时，最好也同时重写hascode()方法，让相同对象的哈希码值也相同

final

final修饰变量、方法、类

l 如果final修饰变量，变量就是常量，常量不可修改，定义时必须初始化

l 如果final修饰方法，方法就不能被子类重写

l 如果final修饰类，类就不能再被扩展，不能再有子类。Java类库中的String、Math就是final类。

引用类型的常量

如果常量是基本数据类型，不可以再修改。

如果常量是引用类型，不能再将其他对象赋给该引用，但可以使用该引用改变对象内部的属性。

例如

final Student s = new Student(“zhangsan”,20);

s = new Student(“李四”,20); //错误

s.setName(“李四”);        //可以  正确

多态的概念

同一个方法名称，执行不同的操作。方法重载就是一种多态的一种形式。

方法重写

当子类从父类中继承来的方法不能满足需要时，子类可以重写该方法，重写方法要求方法名与参数列表都相同。

因此如果子类中的方法与父类中的方法同名、并且参数类型也相同，那么子类中的方法就重写了父类中的同名方法。

为什么不直接定义另外一个方法？因为重写方法可以实现运行时多态的效果。

注意：重写只针对方法，属性没有重写概念

方法重写的规则

两同：方法名相同、参数列表相同

两小：返回值类型更小（子类）或相等、抛出的异常类更小或相等

一大：访问权限更大或相等

案例复习：

Student、Teacher重写Person中的sleep()、show()方法

Dog、Cat重写Animal中的eat()、show()方法

WeightBox、ColorBox重写Box中的show()方法

重写Shape类中的area()方法

重写fruit类中的show()方法

方法重写与方法重载的区别

只有当两个方法的名称和类型签名都相同时才会发生重写。如果不是都相同，那么这两个方法就只是简单的重载关系。

动态方法调度与运行时多态

动态方法调度

当通过父类引用调用重写方法时，在运行时会调用子类中的重写版本。

动态方法调用要以方法重写为前提。

Animal  a;

a = new Dog();

a.eat();  //动态方法调度：在运行时根据超类引用指向的对象确定调用哪个方法

运行时多态

运行时多态的实现机理：动态方法调度

总结：方法重写是前提、动态调度是手段、多态是最终的目的

运行时多态的优点：灵活

Animal  a;

a = new Dog();

a.eat();

a = new Cat();

a.eat();   //运行时多态：方法名相同，得到的结果不同

运行时多态的两个要素：

（1）在子类中重写超类中的方法

（2）使用超类引用调用重写方法。

在自己的类中定义的toString()方法就是重写方法。

注意不要混淆：

使用超类引用调用成员变量时，调用的是超类的成员变量。

多态的两种形式

运行时多态：动态方法调度实现

编译时多态：重载方法，编译时通过方法匹配实现的

多态实例

实例1：Animal、Dog、Cat类的eat()方法、show()方法

实例2：Person、Student、Teacher、Worker类的show()方法、eat、sleep

实例3：Fruit、Apple、Banana的Show()方法

实例4：Shape、Rectangle、Circle、Triangle类的area()、draw()方法

多态应用

案例1：Feeder类，喂养Dog、Cat

案例2：Manager类，管理Student、Teacher、Worker

案例3：Salesman类，卖水果

案例4：Engineer类，使用Shape类