Java读书笔记

Java读(chao)书(shu)笔(bi)记(ji)。好多概念看了就忘。还是写下来翻阅比较方便。

多态(Polymorphism)

Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际付给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态(Polymorphism)。

先看下面程序

public class BaseClass {
    public int book = 6;
    public void base()
    {
        System.out.println("父类的普通方法");
    }
    public void test()
    {
        System.out.println("父类的被覆盖的方法");
    }
}

public class SubClass extends BaseClass
{
    // 重新定义一个book实例变量隐藏父类的book实例变量
    public String book = "轻量级Java EE企业应用实战";
    public void test()
    {
        System.out.println("子类的覆盖父类的方法");
    }
    public void sub()
    {
        System.out.println("子类的普通方法");
    }
    public static void main(String[] args)
    {
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        BaseClass bc = new BaseClass();
        // 输出6
        System.out.println(bc.book);
        // 下面两次调用将执行BaseClass的方法
        bc.base();
        bc.test();
        // 下面编译时类型和运行时类型完全一样，因此不存在多态
        SubClass sc = new SubClass();
        // 输出“轻量级Java EE企业应用实战”
        System.out.println(sc.book);
        // 下面调用将执行从父类继承到的base()方法
        sc.base();
        // 下面调用将执行当前类的test()方法
        sc.test();
        // 下面编译时类型和运行时类型不一样，多态发生
        BaseClass ploymophicBc = new SubClass();
        // 输出6 ---表明访问的是父类对象的实例变量
        System.out.println(ploymophicBc.book);
        // 下面调用将执行从父类继承到的base()方法
        ploymophicBc.base();
        // 下面调用将执行当前类的test()方法
        ploymophicBc.test();;
        // 因为ploymophicBc的编译时类型是BaseClass
        // BaseClass类没有提供sub()方法，所以下面代码编译时会出现错误
        // ploymophicBc.sub();
    }
}

上面程序的main()方法中显式创建了三个引用变量，对于前两个引用变量bc和sc,它们编译时类型和运行时类型完全相同，因此调用它们的成员变量和方法非常正常，完全没有任何问题。但第三个引用变量ploymophicBc则比较特殊，它的编译时类型是BaseClass,而运行时类型是SubClass,当调用该引用变量的test()方法(BaseClass类中定义了该方法，子类SubClass覆盖了父类的该方法)时，实际执行的是SubClass类中覆盖后的test()方法，这就可能出现多态了。

因为子类其实是一种特殊的父类，因此Java允许把一个子类对象直接赋值给一个父类引用变量，无需任何类型转换，或者被称为向上转型(upcasting),向上转型由系统自动完成。

当把一个子类对象直接赋给父类引用变量时，例如上面的BaseClass ploymophicBc = new Subclass();,这个ploymophicBc引用变量的编译时类型是BaseClass,而运行时类型是SubClass，当运行时调用该引用变量的方法时，其方法行为总是表现出子类方法的行为特征，而不是父类方法的行为特征，这个就可能出现：相同类型的变量、调用同一个方法时呈现多种不同的行为特征，这就是多态。

与方法不同的是，对象的实例变量则不具备多态性。比如上面的ploymophicBc引用变量，程序中输出它的book实例变量时，并不是输出SubClass类里定义的实例变量，而是输出BaseClass类的实例变量。

抽象类

当编写一个类时，当当会为该类定义一些方法，这些方法用以描述该类的行为方式，那么这些方法都有具体的方法体。但在某些情况下，某个父类只是知道其子类应该包含怎么样的方法，但无法准确地知道这些子类如何实现这些方法。例如定义了一个Shape类，这个类应该提供一个计算周长的方法calPerimeter(),但不同shape子类对周长的计算方法是不一样的，即Shape类无法准确地知道其子类计算周长的方法。

可能有读者会提出，既然Shape类不知道如何实现calPerimeter()方法，那就干脆不要管它了！这不是一个好思路：假设有一个Shape引用变量，该变量实际上引用到Shape子类实例，那么这个Shape变量就无法调用calPerimeter()方法，必须将其强制类型转换为其子类类型,才可调用calPerimeter()方法，这就降低了程序的灵活性。

如何既能让Shape类里包含calPerimeter()方法，又无须提供其方法实现呢？使用抽象方法即可满足该要求：抽象方法时只有方法时只有方法签名，没有方法实现的方法。

抽象方法和抽象类

抽象方法和抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义成抽象类,抽象类里可以没有抽象方法。抽象方法和抽象类的规则如下。

抽象类必须使用abstract修饰符来修饰,抽象方法也必须使用abstract修饰符来修饰,抽象方法不能有方法体。
抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
抽象类可以包含成员变量、方法(普通方法和抽象方法都可以)、构造器、初始化块、内部类(接口、枚举)5种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。
含有抽象方法的类（包括直接定义了一个抽象方法：或继承了一个抽象父类，但没有完全实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况)只能被定义成抽象类。

归纳起来，抽象类可以用“有得有失”4个字来描述。“得”指的是抽象类多了一个能力：抽象类可以包含抽象方法；“失”指的是抽象类失去了一个能力：抽象类不能用于创建实例。

定义抽象方法只需在普通方法上增加abstract修饰符，并把普通方法的方法体（也就是方法后花括号括起来的部分)全部去掉，并在方法后增加分号即可。

抽象方法和空方法体的方法不是同一个概念。例如，public abstract void test();是一个抽象方法，它根本没有方法体，即方法定义后面没有一对花括号；但public void test(){}方法是一个普通方法，它已经定义了方法体，只是方法体为空，即它的方法体什么也不做，因此这个方法不可使用abstract来修饰。

Shape抽象类

public abstract class Shape
{
	{
		System.out.println("执行Shape的初始化块...");
	}
	private String color;
	// 定义一个计算周长的抽象方法
	public abstract double calPerimeter();
	// 定义一个返回形状的抽象方法
	public abstract String getType();
	// 定义Shape的构造器，该构造器并不是用于创建Shape对象，
	// 而是用于被子类调用
	public Shape(){}
	public Shape(String color)
	{
		System.out.println("执行Shape的构造器...");
		this.color = color;
	}
	// 省略color的setter和getter方法
	public void setColor(String color)
	{
		this.color = color;
	}
	public String getColor()
	{
		return this.color;
	}
}

上面Shape类里包含了两个抽象方法:calPerimeter()和getType()，所以这个Shape类只能被定义成抽象类。Shape类里既包含了初始化块，也包含了构造器，这些都不是在创建Shape对象时被调用的，而是在创建其子类的实例时被调用。

抽象类不能用于创建实例，只能当作父类被其他子类继承。下面定义一个三角形类，三角形类被定义成普通类，因此必须实现Shape类里的所有抽象方法。

public class Triangle extends Shape
{
	// 定义三角形的三边
	private double a;
	private double b;
	private double c;
	public Triangle(String color , double a
		, double b , double c)
	{
		super(color);
		this.setSides(a , b , c);
	}
	public void setSides(double a , double b , double c)
	{
		if (a >= b + c || b >= a + c || c >= a + b)
		{
			System.out.println("三角形两边之和必须大于第三边");
			return;
		}
		this.a = a;
		this.b = b;
		this.c = c;
	}
	// 重写Shape类的的计算周长的抽象方法
	public double calPerimeter()
	{
		return a + b + c;
	}
	// 重写Shape类的的返回形状的抽象方法
	public String getType()
	{
		return "三角形";
	}
}

上面的triangle类继承了Shape抽象类，并实现了Shape类中两个抽象方法，是一个普通类，因此可以创建Triangle类的实例，可以让一个Shape类型的引用变量指向Triangle对象。下面再定义一个Circle普通类，Circle类也是Shape类的一个子类。

public class Circle extends Shape
{
	private double radius;
	public Circle(String color , double radius)
	{
		super(color);
		this.radius = radius;
	}
	public void setRadius(double radius)
	{
		this.radius = radius;
	}
	// 重写Shape类的的计算周长的抽象方法
	public double calPerimeter()
	{
		return 2 * Math.PI * radius;
	}
	// 重写Shape类的的返回形状的抽象方法
	public String getType()
	{
		return getColor() + "圆形";
	}
	public static void main(String[] args)
	{
		Shape s1 = new Triangle("黑色" , 3 , 4, 5);
		Shape s2 = new Circle("黄色" , 3);
		System.out.println(s1.getType());
		System.out.println(s1.calPerimeter());
		System.out.println(s2.getType());
		System.out.println(s2.calPerimeter());
	}
}

上面main()方法中定义了两个Shape类型的引用变量，它们分别指向Triangle对象和Circle对象。由于在Shape类中定义了calPerimeter()方法和getType()方法，搜易程序可以直接调用s1变量和s2变量的 calPerimeter()方法和getType()方法，无须强制类型转换为其子类类型。

利用抽象类和抽象方法的优势，可以更好的发挥多态的优势，使得程序更加灵活。

抽象类的作用

从前面的示例程序可以看书，抽象类不能创建实例，只能当成父类来被继承。从语义的角度看，抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象。从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类设计的随意性。

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。

如果编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模板模式，末班模式也是十分常见且简单的设计模式之一。例如前面介绍的Shape、Circle和Triangle三个雷，已经使用了模板模式。下面再介绍一个模板模式的范例，在这个范例的抽象父类中，父类的普通方法依赖于一个抽象方法，而抽象方法则推迟到子类中提供实现。

接口和抽象类

接口和抽象类很像，它们都具有如下特征。

接口和抽象类都不能被实例化，它们位于继承树的顶端，用于被其他类实现和继承。
接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

但接口和抽象类之间差别非常大，这种差别主要体现在二者设计目的上。下面具体分析二者的差别。

接口作为系统与外界交互的窗口，接口体现的是一种规范。对于接口的实现者而言，接口规定了实现者必须向外提供哪些服务(以方法的形式来提供);对于接口的调用者而言，接口规定了调用者可以调用哪些服务，以及如何调用这些服务(就是如何来调用方法)。当在一个程序中使用接口时，接口时多个模块间的耦合标准；当在多个应用程序时间使用接口时，接口时多个程序之间的通信标准。

某种程度上来看，接口类似于整个系统的“总纲”，它制定了系统各模块应该遵循的标准，因此一个系统中的接口不应该经常改变。一旦接口被改变，对整个系统甚至其他系统的影响将是辐射式的，导致系统中大部分类都需要改写。

抽象类则不一样，抽象类作为系统中多个子类的共同父类，它所体现的是一种模板式设计。抽象类作为多个子类的抽象父类，可以被当成系统实现过程中的中间产品，这个中间产品已经实现了系统的部分功能)那些已经提供实现的方法),但这个产品依然不能当最终产品，必须有更进一步的完善，这个中完善可能有几种不同方式。

除此之外，接口和抽象类在用法上也存在如下差别。

接口里只能包含抽象方法、静态方法和默认方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法。
接口里只能定义静态常量，不能定义普通成员变量；抽象类里既可以定义普通成员你变量，也可以定义静态常量。
接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
接口里不能包含初始化块；但抽象类则完全可以包含初始化块。
一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。