第四章面向对象（上）

面向对象三大特征：封装，继承，多态

4.4 隐藏与封装

封装：将对象的状态信息隐藏在对象内部，外部程序通过该类提供的方法对内部信息进行操作访问。
protected:方法想被子类重写，但不想被外界调用

package lee; 如果程序第一行
javac -d . Hello.java
在当前目录下会有一个lee文件夹，以及Hello.java源文件，
lee文件夹中是所有Hello.class xxx.class 字节码文件
运行时是java lee.Test

import lee.; import是导入类的。lee包中的子包不会导入
java默认导入java.lang.

静态导入制定类的指定/全部静态成员变量，方法。

import static java.lang.Math.*; //可以不写类名了
import static java.lang.System;
out.println(sqrt(256));

构造器
构造器重载，如果B完全包含了A, 用this调用
this(name);子类中重载的构造器，出现在构造器执行体的第一行，调用的其他构造器会调用父类构造器。
super("猪猪侠",23);调用父类构造器必须出现在子类构造器执行体的第一行。
无super this，会隐式调用父类无参数的构造器。

子类不能获得父类的构造器
方法的重写：两同两小一大
两小：返回值，异常值
一大：访问权限

子类中定义的和父类同名的成员变量不会覆盖，只是隐藏，用super调用
Creature->Animal->Walf
System.out.print(((Creature)w).tag);强制向上转型

//集成时的构造器
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();
    }
}

输出：
Creature无参数的构造器
Animal带一个参数的构造器，该动物的name为灰太狼
Animal带两个参数的构造器，其age为3
Wolf无参数的构造器

多态

Java 引用变量有两个类型：

编译时的类型由声明该变量时使用的类型决定
运行时的类型由实际赋给该变量的对象决定。
如果编译时类型和支行时的类型不一致，这就有可能出现所谓的多态。
两个相同类型的引用变量，由于它们实际引用的对象的类型不同，当它们调用同名方式时，可能呈现出多种行为特征，这就是多态。
相同类型的变量，调用同一个方法时呈现出多种不同的行为特征。
！！对象的实例变量不具备多态性。

因为子类是一种特殊的父类。
向上转型upcasting：子类对象赋值给父类引用

类型转换

基本类型：数值类型之间，整数型，字符型，浮点型。数值类型和布尔类型之间不能进行相互转化。
引用类型：具有继承关系，父类 F = new 子类（），该F可以转化为子类。

instanceof

前一个操作通常是一个引用类型的变量，后一个操作通常是一个类（也可以是接
口）。如果是返回true 否返回false。

if (o instanceof String) {
  String str = (String) o; //父类对象赋值给子类引用
}

5.8继承和组合：实现类复用

继承表达的是一种“是（is-a）”的关系，破环封装
组合表达的是”有（has-a）“的关系。需要显式创建被组合的对象。

// 使用时此时需要显式创建被组合的对象
Animal a1 = new Animal();
Bird b = new Bird(a1);
b.breath();

5.9初始化块

[static] {
///初始化块
}

基本用法：对所有对象完全相同且无须接收任何参数的初始化处理代码
假象：编译后会还原在每个构造器中
静态初始化块：类初始化块

先从父到子静态初始化块，
再从父初始化块，构造器-->子初始化块构造器。

class Root {
    static {
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root() {
        System.out.println("Root的无参数的构造器");
    }
}
class Mid extends Root {
    static {
        System.out.println("Mid的静态初始化块");
    }
    {
        System.out.println("Mid的普通初始化块");
    }
    public Mid() {
        System.out.println("Mid的无参数的构造器");
    }
    public Mid(String s) {
        this();
        System.out.println("mid的带参构造器,参数为" + s);
    }
}
class Leaf extends Mid {
    static {
        System.out.println("leaf的静态初始化块");
    }
    {
        System.out.println("leaf的普通初始化块");
    }
    public Leaf() {
        super("猪猪侠");
        System.out.println("leaf的无参数的构造器");
    }

}
public class Test {
    public static void main(String[] args) {
        new Leaf();
        new Leaf();
    }
}

输出：
Root的静态初始化块
Mid的静态初始化块
leaf的静态初始化块

Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
mid的带参构造器,参数为猪猪侠
leaf的普通初始化块
leaf的无参数的构造器

Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
mid的带参构造器,参数为猪猪侠
leaf的普通初始化块
leaf的无参数的构造器

静态初始化块和声明静态成员变量时所指定的初始值执行顺序与写的顺序相同

public class StaticInitTest {
    // 先执行静态初始化块将a静态成员变量赋值为6
    static
    {
        a = 6;
    }
    // 再将a静态成员变量赋值为9
    static int a = 9;
    public static void main(String[] args)
    {
        // 下面代码将输出9
        System.out.println(StaticInitTest.a);
    }
}

第四章面向对象（上）