面向对象分析和设计笔记——第3章

[1]封装性

 对象是Java封装性最大的体现

public ClassName{
　　成员变量/数据成员：访问权限 数据类型 变量名 ；
　　成员方法：访问权限 返回值类型 方法名（）{函数体；}
　　构造方法：访问权限 类名（）{}
}

　　对象的创建与使用：1）对象变量（或引用reference）的声明：声明时操作系统仅会在栈（Stack）内为其分配一个存储首地址数据的32位内存空间；

　　　　　　　　　　　2）对象的创建：通过new关键字和实参来调用构造函数来构建对象并初始化成员变量/数据成员，此时操作系统才会在堆（Heap）内为对象分配存储对象信息的内存空间，同时将引用地址值返回给Stack中的引用变量；

　　　　　　　　　　　3）对象的使用：通过点运算符“.”可以实现对对象属性的访问和方法的调用，reference可以是已初始化的对象变量，也可以是生成对象的表达式，如：

reference.variable;
reference.methodName([paramlist]);
float tx = pointOne.x;
float tx = new Point2D(100.0, 200.0).x;
pointOne.setX(300.0);
new Point2D(100.0, 200.0).setX(300.0);

注：1）{}“类体”或可以认为是“类的作用域”；

　　2）Java中的方法只能作为类的一部分创建，所有的方法都不能游离于类之外；调用方法是通过方法名和实参类型来匹配的；

　　3）当为某个类撰写多个构造方法时，若想在其中某个构造方法内部调用另一个构造方法，使用this ([参数列表])；

　　4）Java中的reference不同于C++，不可以对引用变量进行“加加减减”的操作；

 注：Java基本上是“纯”的面向对象语言，唯一“不纯”的地方在于存在8个基本数据类型（byteshortintlong; floatdouble; char; boolean）为了弥补这个问题，Java提供了基本类库，提供了这8个基本数据类型的包装类（Wrapped type）；此外如果精度还是不够，还可以考虑使用BigDecimal和BigInteger这两个类；

 注：1）IEEE754

　　 2）BigDecimal类

　　 3）BigInteger类

[2]继承性

　　1）类型为Employee的一个对象首次创建时，或者Employee类的静态方法或数据首次调用时，JVM必须查找环境变量classpath所指定的位置，找出并装载Employee.class；

　　2）Employee.class装载后，如果它有超类，那么便会继续装载它的超类，如果超类还有超类，便会继续装载第二个超类，以此类推。从超类到Employee类的所有静态初始化模块顺序进行，静态初始化动作仅发生一次

　　3）当1)中创建一个Employee对象时，从超类到Employee类，每一类会分别顺序执行如下步骤：Object*4→Person*3→Employee*3

　　　　在堆内分配一个足够的存储空间，reference地址一样；

　　　　系统会先用默认值初始化对象的成员变量；

　　　　执行所有出现于数据定义处的初始化动作；

　　　　执行构造函数；

　　4）如果应用程序没有结束，在同一个应用程序中再创建类Employee的对象时，则从3）开始循环执行；

public class Person{
    private String name;
    private String address;
    public Person (String initialName, String initialAddress){
        name = initialName;
        address = initialAddress;
    }
    public String getName(){
        return name;
    }
    public String getAddress(){
        return address;
    }
    public String toString(){
        return "name:" + name + "|address:" + address;
    }
}

public class Employee extends Person{
    private double salary;
    public Employee(String initialName, String initialAddress, double initialSalay){
        super(initialName, initialAddress);
        salary = initialSalary;
    }
    public double getSalary(){
        return salary;
    }
    public void setSalary(double newSalary){
        salary = newSalary;
    }
    public String toString(){//override
        return super.toString() + "|salary:" + salary;//return "name:" + getName() + "|address:" + getAddress() + "|salary:" + salary;
    }
}

对象转型：

向上转型（upcasting）时，父类的引用变量虽然指向子类对象，但不能通过该引用调用子类所特有的方法；如果想通过父类对象的引用调用子类特有的方法，则必须对其进行强制类型转换；upcasting是自然的、合法的，基本都是legal的

Employee employee = new Employee("lee", "99Ave", 30);
Person person = employee;double salary = ((Employee)person).getSalary();

向下转型（downcasting）有着特殊性：如果父类对象引用指向的是一个子类的对象，则可以使用downcasting，把超类引用显式地转型为一个子类的对象；如果超类对象引用指向的是一个自身类对象则不可以使用downcasting，illegal的

Person person = new Person("lee", "99MainAve");
double salsry = ((Employee))person).getSalary();//ClassCastException

downcasting常与instanceof操作符合用以避免非法的向下转型

Person person = new Employee("lee", "100 MainAve", 100);
if(person instanceof Employee){
    salary = ((Employee)person).getSalary();
}

重写和重载：

重写只覆写方法体，返回值类型、方法名、形参类型都完全一样，是子类与父类之间的关系；重载是拓展新的方法，只发生在一个类内，不是多个类之间的关系

equals();toString();是Java中重写频率最高的两个方法

public Boolean equals(Object o){//因为重写要求形参类型不能变，所以隐式地将子类对象当作父类变量，upcasting
    if (o instanceof Employee){
        Employee e = (Employee)p;//downcasting
        return this.getName().equals(e.getName()) && this.getAddress().equals(e.getAddress()) && this.getSalary() == e.getSalary();
    }else{//this 指向调用该方法的实例对象，即equals左边的对象
        return false;
    }
}//逻辑运算符参与构成的逻辑表达式的运算结果任然是布尔型量

在大部分类中，继承自Object类的equals()方法都不适用，因此每个类都需要覆写该方法，API中“wrapper classes”、Date、String中可供调用的equals();方法都是经overwrite过的，先在形参除向上转型再在函数体内向下转型是重写equals();方法中的模板

public String toString(){
    return "name:" + name'
}

在大部分类中，继承自Object类的toString()方法也都不适用，因此每个类都需要覆写该方法，如果不覆写则返回@+字符串地址的Hash码；覆写后的toString();方法一般返回一个表示该对象特征的字符串

final关键字：

1）final类

　　final的类，不能被继承；

 2）final方法

　　父类中final的方法，子类中不能overwrite这个方法，但可以overload这个方法；

3）final变量

　　基本类型：不能被再次赋值；对象类型：不能修改指针，但可以修改指针指向的内部的值； 

[3]多态性：是由继承性带来的

多态的变量FacultyMember m;//静态绑定，允许将多种类型的子类变量当作一种数据类型来对待

多态的方法调用m.toString();//JVM会自动利用instanceof进行点运算符的动态绑定，从而可以区分不同子类之间的差异性

FacultyMember[] members = new FacultyMember [8];
for (int index = 0; index<members.length; index++){
    System.out.println(members[index].toString());
}

[4]“1对多”关联关系的实现

　　加<>, <>内为变量名，多个变量间用","间隔；泛型类内的数据类型、构造函数形参类型等均可待定，用<>内的变量表示即可；在声明泛型对象时，数据类型要具体化

　　如何撰写一个泛型类：

　　　　1)先写出一个实际的类；

　　　　2)将此类中准备改变的类型名(如应用时，可能int要改变为float或char)；即改用一个自己指定泛型参数(如E、A、B)；

　　　　3)类中的方法可以使用泛型参数类型，static方法无法访问泛型类的类型参数；(因为具体的参数类型在实例化的时候才知道)

　　　　4)使用泛型类时，必须在创建对象的时候指定类型参数的值；

　　方法也可以声明为泛型方法：

　　　　1)调用泛型方法与调用普通方法一样，不必指明参数类型；

　　　　2)泛型方法可以看作被无限次重载过；

public class GenericMethods{
    public <T> void f(T x){
        System.out.println(x.toString());
    }
    
    public static void main(String[] args){
        genericMethods gn = new GenericMethods();
        gn.f("Hello");
        gn.f(new Product("coffee", 27, "34"));
        gn.f(new Point2D(23, 45));
    }
}

 Arrays：管理对象个数确定

　　一维数组

　　多维数组：java中并没有真正的多维数组，只有数组的数组，java中多维数组不一定是规则的矩阵形式；

　　　　　　   每一行的大小可以单独定义如，int[][] xx;

　　　　　　　　　　　　　　　　　　　　　xx[0] = new int[3];

　　　　　　　　　　　　　　　　　　　　　xx[1] = new int[2];

容器类：管理对象个数不确定

　　Collection<E>：其内每个位置仅持有一个元素，提供add();方法添加元素，包括

　　　　　　　　　 List<E>：以特定次序存储一组元素； ArrayList<E>，Vector<E>

　　　　　　　　　 Set<E>：元素不得重复

　　Map<K, V>：其内每个位置所持有的时一群成对的key-value(键值-实值对)，类似小型数据库，提供put();方法添加元素

ArrayList<String> list = new ArrayList<String>();
    list.add("ArrayList");
    list.add("and");
    list.add("for-each");
    String result = "";
    for(String element : list){
        result +=element;
    }
    stdOut.println(result);

Collection<Point2D> c;
for(Point2D point : c){
    int x = point.getX();
}
//c为容器类型的变量，容器的名称
//Point2D为容器内的变量类型
//point为Point2D类型的变量，每次循环的执行都从容器中取出对象并赋给该变量来运用

[5]基类的重新考虑——继承与接口

基态类型的变量都是多态的；通过基态变量+“.”运算符激活的基态方法都是多态的，JVM会自动地动态绑定方法地调用和方法地方法体之间的关联关系；

抽象类存在的原因：

　　1)让客户端程序员无法产生(new一个)其对象，并因此确保这只是一个“接口”而无实体；//与非抽象基类的差异

　　2)共同的函数特征建立了一个基本形式，让程序员可以陈述所有子类的共同点，任何子类都可以以不同的方法体来表现此一共同的函数特征；

接口是一个"pure"抽象类：

　　1)接口内的所有变量都默认为是public static final的；接口类型不存在构造方法；接口内所有的方法都是static、public的；

　　2)在架构设计时，如何使用抽象类和接口来解决问题，是一个非常复杂的问题，抽象类更侧重于归纳同一父类的子类的共同特征，如果属性，方法；接口更侧重于定义任意的类有没有相同语义的方法，它是一个一经定义不轻易更改的规范，它的修改在项目中，往往是动一发而牵全身，即使有考虑不周到的地方，也会使用新增接口的形式去弥补。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

　　1)使用接口，能够实现子型别被向上转型至多个基类型别；

　　2)让客户端程序员无法产生其对象，并因此确保这知识一个“接口”而无实体；

　　3)共同的接口建立了一个基本形式，让程序员可以陈述所有的实现该接口的子型别的共同点。任何子型别都可以以不同的方法体来表现此共同接口，相比抽象类，“多态”程度更高；