Java 隐藏和封装、深入构造器、类的继承

参考资料

[1]. 疯狂Java讲义（第三版） 李刚

隐藏和封装

使用访问控制符

访问控制级别表

范围	private	default	protected	public
同一个类中	支持	支持	支持	支持
同一个包中		支持	支持	支持
子类中			支持	支持
全局范围中				支持

下面是一个封装良好的类，代码如下：

public class Person
{
    // 使用private修饰成员变量，将这些成员变量隐藏起来
    private String name;
    private int age;
    // 提供方法来操作name成员变量
    public void setName(String name)
    {
        // 执行合理性校验，要求用户名必须在2～6位之间
        if (name.length() > 6 || name.length() < 2)
        {
            System.out.println("您设置的人名不符合要求");
            return;
        }
        else
        {
            this.name = name;
        }
    }
    public String getName()
    {
        return this.name;
    }
    // 提供方法来操作age成员变量
    public void setAge(int age)
    {
        // 执行合理性校验，要求用户年龄必须在0～100之间
        if (age > 100 || age < 0)
        {
            System.out.println("您设置的年龄不合法");
            return;
        }
        else
        {
            this.age = age;
        }
    }
    public int getAge()
    {
        return this.age;
    }
}

package、import和import static

java允许将一组功能相关的类放在同一个package下，从而组成逻辑上的类库单元。package应出现在程序第一行，语法如下：

package packageName;

下面是一个简单的Java类

package lee;
public class Hello
{
    public static void main(String[] args)
    {
        System.out.println("Hello World!");
    }
}

使用import关键字可以向某个java文件中导入指定包层次下某个类或全部类，import语句应该出现在package语句（如果有的话）之后，类定义之前。一个Java源文件只能包含一个package语句，但可以包含多个import语句。
语法如下：

import [static] 包.[类名 | *]

// 导入某一个类
import lee.sub.Apple;
// 导入全部类
import lee.sub.*;

也可以导入静态类

import static java.lang.System.*

深入构造器

使用构造器执行初始化

public class ConstructorTest
{
    public String name;
    public int count;
    // 提供自定义的构造器，该构造器包含两个参数
    public ConstructorTest(String name , int count)
    {
        // 构造器里的this代表它进行初始化的对象
        // 下面两行代码将传入的2个参数赋给this代表对象的name和count实例变量
        this.name = name;
        this.count = count;
    }
    public static void main(String[] args)
    {
        // 使用自定义的构造器来创建对象
        // 系统将会对该对象执行自定义的初始化
        ConstructorTest tc = new ConstructorTest("疯狂Java讲义" , 90000);
        // 输出ConstructorTest对象的name和count两个实例变量
        System.out.println(tc.name);
        System.out.println(tc.count);
    }
}

一旦程序员提供了自定义的构造器，系统就不再提供默认的构造器，因此上面的ConstructorTest类不能再通过new ConstructorTest(); 代码来创建实例，因为该类不再包含无参数的构造器。
如果把构造器设置为protected，主要用于被其子类调用，设置为private，阻止其他类创建该类的实例。

构造器重载

同一个类里具有多个构造器，多个构造器的形参列表不同，即被称为构造器重载。构造器重载允许Java类里包含多个初始化逻辑，从而允许使用不同的构造器来初始化Java对象。

public class ConstructorOverload
{
    public String name;
    public int count;
    // 提供无参数的构造器
    public ConstructorOverload(){}
    // 提供带两个参数的构造器，
    // 对该构造器返回的对象执行初始化
    public ConstructorOverload(String name , int count)
    {
        this.name = name;
        this.count = count;
    }
    public static void main(String[] args)
    {
        // 通过无参数构造器创建ConstructorOverload对象
        ConstructorOverload oc1 = new ConstructorOverload();
        // 通过有参数构造器创建ConstructorOverload对象
        ConstructorOverload oc2 = new ConstructorOverload(
            "轻量级Java EE企业应用实战", 300000);
        System.out.println(oc1.name + " " +  oc1.count);
        System.out.println(oc2.name + " " +  oc2.count);
    }
}

在构造器中调用构造器初始化，代码如下：

public class Apple
{
    public String name;
    public String color;
    public double weight;
    public Apple(){}
    // 两个参数的构造器
    public Apple(String name , String color)
    {
        this.name = name;
        this.color = color;
    }
    // 三个参数的构造器
    public Apple(String name , String color , double weight)
    {
        // 通过this调用另一个重载的构造器的初始化代码
        this(name , color);
        // 下面this引用该构造器正在初始化的Java对象
        this.weight = weight;
    }
}

类的继承

Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类被称为父类，有的也成其为基类、超类，继承的语法如下：

修饰符  class  SubClass extends SuperClass
{
    // 类定义部分
}

Java的子类可以获得父类的全部成员变量和方法，但不能获得父类的构造器。
如果定义一个Java类时并未显式指定这个类的直接父类，则这个类默认扩展java.lang.Object类。因此，java.lang.Object类是所有类的父类，要么是其直接父类，要么是其间接父类。因此所有的Java对象都可以调用java.lang.Object类定义的方法。
示例一个继承类，代码如下：

public class Fruit
{
    public double weight;
    public void info()
    {
        System.out.println("我是一个水果！重"
            + weight + "g！");
    }
}

继承Fruit类的子类Apple类

public class Apple extends Fruit
{
    public static void main(String[] args)
    {
        // 创建Apple对象
        Apple a = new Apple();
        // Apple对象本身没有weight成员变量
        // 因为Apple的父类有weight成员变量，也可以访问Apple对象的weight成员变量
        a.weight = 56;
        // 调用Apple对象的info()方法
        a.info();
    }
}

重写父类的方法

子类继承了父类，子类是一个特殊的父类。大部分的时候，子类总是以父类为基础，额外增加新的成员变量和方法。但是有一种情况例外：子类需要重写父类的方法。

示例代码如下：
定义一个父类

public class Bird
{
    // Bird类的fly()方法
    public void fly()
    {
        System.out.println("我在天空里自由自在地飞翔...");
    }
}

定义一个继承了bird类的鸵鸟类Ostrich

public class Ostrich extends Bird
{
    // 重写Bird类的fly()方法
    public void fly()
    {
        System.out.println("我只能在地上奔跑...");
    }
    public void callOverridedMethod()
    {
        // 在子类方法中通过super来显式调用父类被覆盖的方法。
        super.fly();
    }

    public static void main(String[] args)
    {
        // 创建Ostrich对象
        Ostrich os = new Ostrich();
        // 执行Ostrich对象的fly()方法，将输出"我只能在地上奔跑..."
        os.fly();
    }
}

重写父类方法，必须类型完全一样，下面的代码会报错，代码如下：

// 父类
class BaseClass
{
    public static void test(){...}
}
// 子类
class SubClass extends BaseClass
{
    public void test(){...}
}

不能重写父类的私有方法，但是可以重新定义一个，代码如下：

// 父类
class BaseClass
{
    // test()方法是private访问权限，子类不可以访问该方法
    private void test(){...}
}
// 子类
class SubClass extends BaseClass
{
    // 此处不是方法重写，所以可以增加static关键字
    public static void test(){...}
}

super限定

super是Java提供的一个关键字，super用于限定该对象调用它从父类继承得到的实例变量或方法，super不能出现在static修饰的方法中。

class BaseClass
{
    public int a = 5;
}
public class SubClass extends BaseClass
{
    public int a = 7;
    public void accessOwner()
    {
        System.out.println(a);
    }
    public void accessBase()
    {
        // 通过super来限定访问从父类继承得到的a实例变量
        System.out.println(super.a);
    }
    public static void main(String[] args)
    {
        SubClass sc = new SubClass();
        sc.accessOwner(); // 输出7
        sc.accessBase(); // 输出5
    }
}

因为子类中定义与父类中同名的实例变量并不会完全覆盖父类中的实例变量，它只是简单的隐藏了父类中的实例变量，所以会出现下面的情形：

class Parent
{
    public String tag = "疯狂Java讲义";         //①
}
class Derived extends Parent
{
    // 定义一个私有的tag实例变量来隐藏父类的tag实例变量
    private String tag = "轻量级Java EE企业应用实战";         //②
}
public class HideTest
{
    public static void main(String[] args)
    {
        Derived d = new Derived();
        // 程序不可访问d的私有变量tag，所以下面语句将引起编译错误
        // System.out.println(d.tag);         //③
        // 将d变量显式地向上转型为Parent后，即可访问tag实例变量
        // 程序将输出：“疯狂Java讲义”
        System.out.println(((Parent)d).tag);         //④
    }
}

调用父类构造器

在子类构造器中调用父类构造器使用super调用来完成。
下面程序定义了Base类和Sub类，其中Sub类是Base类的子类，程序在Sub类的构造器中使用super来调用Base构造器的初始化代码。

class Base
{
    public double size;
    public String name;
    public Base(double size , String name)
    {
        this.size = size;
        this.name = name;
    }
}
public class Sub extends Base
{
    public String color;
    public Sub(double size , String name , String color)
    {
        // 通过super调用来调用父类构造器的初始化过程
        // 使用super调用父类构造器必须出现在子类构造器执行体的第一行
        super(size , name);
        this.color = color;
    }
    public static void main(String[] args)
    {
        Sub s = new Sub(5.6 , "测试对象" , "红色");
        // 输出Sub对象的三个实例变量
        System.out.println(s.size + "--" + s.name
            + "--" + s.color);
    }
}

不管是否使用super调用来执行父类构造器的初始化代码，子类构造器总会调用父类构造器一次。
子类构造器调用父类构造器的三种情况：
1. 子类构造器执行体的第一行使用super显示调用父类构造器。
2. 子类构造器执行体的第一行代码使用this显式调用本类中重载的构造器。
3. 子类构造器无super和this调用。
上面三种情况都会根据传入参数自动调用。
执行父类构造器时，系统会再次上溯执行其父类构造器，依次类推，创建任何Java对象，最先执行的总是Java.lang.Object类的构造器。
下面是一个调用父类构造器的示例：

class Creature
{
    public Creature()
    {
        System.out.println("Creature无参数的构造器");
    }
}
class Animal extends Creature
{
    public Animal(String name)
    {
        System.out.println("Animal带一个参数的构造器，"
            + "该动物的name为" + name);
    }
    public Animal(String name , int age)
    {
        // 使用this调用同一个重载的构造器
        this(name);
        System.out.println("Animal带两个参数的构造器，"
            + "其age为" + age);
    }
}
public class Wolf extends Animal
{
    public Wolf()
    {
        // 显式调用父类有两个参数的构造器
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }
    public static void main(String[] args)
    {
        new Wolf();
    }
}