第四章 面向对象编程（上）

更好的阅读体验

• Java类及类的成员：属性、方法、构造器；代码块、内部类

• 面向对象的大特征：封装性、继承性、多态性、(抽象性)

• 其它关键字：this、super、static、final、abstract、interface、package、import等

面向过程与面向对象

1. 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

例子：把大象装进冰箱

类与对象

类(Class)和对象(Object)是面向对象的核心概念。

• 类是对一类事物的描述，是抽象的、概念上的定义
• 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
• 比如

类： 人
对象：乔布斯、雷军、小明

面向对象程序设计的重点是类的设计

类的设计，其实就是类的成员的设计

• 类的成员方法和类的成员变量
• 又叫行为和属性
• Mehtod和Field

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类

两者的关系

对象，是由类new出来的，派生出来的。

对象的创建和使用

创建对象语法： 类名 对象名 = new 类名();

使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

我new好多个呢？每个对象是独立的哦

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。

这里对象p1和p2是独立，不相关的，虽然它们都是抽象类Person的实例

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

内存解析

匿名对象

我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。

new Phone().sendEmail();
new Phone().playGame();

new Phone().price = 1999;
new Phone().showPrice();//0.0

使用场景

• 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。

• 我们经常将匿名对象作为实参传递给一个方法调用。

类的结构一：属性

属性 vs 局部变量

1.相同点：
 *      1.1  定义变量的格式：数据类型  变量名 = 变量值
 *      1.2 先声明，后使用
 *      1.3 变量都其对应的作用域 


2.不同点：
        2.1 在类中声明的位置的不同
 *      属性：直接定义在类的一对{}内
 *      局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
 *      
 *      2.2 关于权限修饰符的不同
 *      属性：可以在声明属性时，指明其权限，使用权限修饰符。
 *          常用的权限修饰符：private、public、缺省、protected  --->封装性
 *          目前，大家声明属性时，都使用缺省就可以了。
 *      局部变量：不可以使用权限修饰符。
 * 
 *      2.3 默认初始化值的情况：
 *      属性：类的属性，根据其类型，都默认初始化值。
 *          整型（byte、short、int、long：0）
 *          浮点型（float、double：0.0）
 *          字符型（char：0  （或'\u0000'））
 *          布尔型（boolean：false）
 * 
 *          引用数据类型（类、数组、接口：null）
 * 
 *      局部变量：没默认初始化值。
 *          意味着，我们在调用局部变量之前，一定要显式赋值。
 *          特别地：形参在调用时，我们赋值即可。
 * 
 *      2.4 在内存中加载的位置：
 *      属性：加载到堆空间中   （非static）
 *      局部变量：加载到栈空间

类的结构二：方法

• Java里的方法不能独立存在，所有的方法必须定义在类里。
• 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中 也称为函数或过程。

public class Person{
    private int age; 
    public int getAge() { //声明方法getAge()
        return age;
    }
    public void setAge(int i) { //声明方法setAge
        age = i; //将参数i的值赋给类的成员变量age
}

方法的声明

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
    方法体程序代码
    return 返回值;
｝

方法的调用

方法通过方法名被调用，且只有被调用才会执行

Person p = new Person();
p.say();  //调用say， 假设我们定义了一个Person类，有一个say方法

注意

• 方法被调用一次，就会执行一次
• 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法
• 方法中只能调用方法或属性，不可以在方法内部定义方法。

方法的重载

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

重载的关键：只看参数列表和方法名，且参数列表必须不同,根据方法参数列表的不同来区别,不看返回值类型

例子

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

public void getSum(int i,int j){
    System.out.println("1");
}

public void getSum(double d1,double d2){
    System.out.println("2");
}

public void getSum(String s ,int i){
    System.out.println("3");
}

public void getSum(int i,String s){
    System.out.println("4");
}

使用重载方法，可以为编程带来方便。

总结：“两同一不同”:

• 同一个类、相同方法名，
• 参数列表不同：参数个数不同，参数类型不同“

可变参数

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);


//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

• 声明格式：方法名(参数的类型名 ...参数名)

• 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个

• 可变个数形参的方法与同名的方法之间，彼此构成重载
• 方法的参数部分有可变形参，需要放在形参声明的最后
• 在一个方法的形参位置，最多只能声明一个可变个数形参

例子

public void show(int i){

}

public void show(String s){
    System.out.println("show(String)");
}

public void show(String ... strs){
    System.out.println("show(String ... strs)");

    for(int i = 0;i < strs.length;i++){
        System.out.println(strs[i]); //取可变参数
    }
}


//不能与上一个方法同时存在
//  public void show(String[] strs){
//      
//  }

//调用
test.show("hello");
test.show("hello","world");
test.show();

test.show(new String[]{"AA","BB","CC"});

*Java的值传递机制

Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本 （复制品）传入方法内，而参数本身不受影响

• 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
• 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;

System.out.println("m = " + m + ", n = " + n);
//ans: m = 10, n = 10

n = 20;

System.out.println("m = " + m + ", n = " + n);
//ans: m = 10, n = 20 

System.out.println("***********引用数据类型：****************");

Order o1 = new Order();
o1.orderId = 1001;

Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。

System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
//ans: o1.orderId = 1001,o2.orderId = 1001

o2.orderId = 1002;

System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
//ans: o1.orderId = 1002,o2.orderId = 1002

class Order{
    int orderId;
}

例子

面向对象的特征一：封装性

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

追求：高内聚，低耦合

• 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
• 低耦合 ：仅对外暴露少量的方法用于使用。

Java中通过将数据声明为私有的(private)，再提供公共的（public） 方法:getXxx()和setXxx()实现对该属性的操作，

private double radius;
public void setRadius(double radius){
    this.radius = radius;
}
public double getRadius(){
    return radius;
}

封装性的几种体现

• 体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

• 体现二：不对外暴露的私有的方法

• 体现三：单例模式（将构造器私有化）
• 体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

四种权限修饰符

权限从小到大顺序为：private < 缺省 < protected < public

4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

修饰类的话，只能使用：缺省、public, 注意（private 可以用来修饰内部私有类，类种类）

类的结构三：构造器

构造器的作用

• 创建对象

• 初始化对象的信息

构造器的特征

• 它具有与类相同的名称
• 不能被static、final、synchronized、abstract、native修饰，不能有 return语句返回值
• 它不声明返回值类型。（与声明为void不同） 直接不写

Order o = new Order(); Person p = new Person(“Peter”,15);

一个类中，至少会有一个构造器。

一个类中定义的多个构造器，彼此构成重载

一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

你不写的化，默认一个无参构造器

例子

//构造器
public Person(){
    System.out.println("Person().....");
}

public Person(String n){
    name = n;

}

public Person(String n,int a){
    name = n;
    age = a;
}

属性赋值先后

① 默认初始化

② 显式初始化

③ 构造器中初始化

④ 通过”对象.方法” 或 “对象.属性”的方式，赋值

以上操作的先后顺序：① - ② - ③ - ④

JavaBean

有的地方也叫POJO

所谓JavaBean，是指符合如下标准的Java类：

• 类是公共的
• 一个无参的公共的构造器
• 属性，且对应的get、set方法

例子

public class JavaBean {
    private String name; // 属性一般定义为private
    private int age;    

    public JavaBean() { 
    }

    public int getAge() {
        return age;
    }

    public void setAge(int a) {
        age = a;
    }

    public String getName() {
        return name;
    }

    public void setName(String n) {
        name = n;   
    }
}

JavaBean的优势？

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以 用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用 户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关 心任何改变。

UML图

this关键字

可以调用的结构：属性、方法；构造器

• 它在方法内部使用，即这个方法所属对象的引用
• 它在构造器内部使用，表示该构造器正在初始化的对象

使用this，调用属性、方法

public void getInfo(){
    System.out.println("姓名：" + name) ;
    this.speak();
}

当形参与成员变量同名时， 如果在方法内或构造器内需要 使用成员变量，必须添加this来 表明该变量是类的成员变量

public boolean compare(Person p){
    return this.name==p.name;
} 

this与构造器

public Person(){ // 无参构造器
    System.out.println("新对象实例化") ;
}

public Person(String name){
    this(); // 调用本类中的无参构造器
    this.name = name ;
}

public Person(String name,int age){
    this(name) ; // 调用有一个参数的构造器
    this.age = age;
}

• 在构造器中用this调用别的构造器

• 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 “this(形参列表)”

• this(形参列表)”必须声明在类的构造器的首行！
• 在类的一个构造器中，最多只能声明一个”this(形参列表)”

package/import关键字

• 为了更好的实现项目中类的管理，提供包的概念

• 使用package声明类或接口所属的包，声明在源文件的首行

• 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”

• 每.一次，就代表一层文件目录。

package pack1.pack2; //指定类PackageTest属于包pack1.pack2
public class PackageTest{
    public void display(){
        System.out.println("in method display()");
    }
}

包的作用

• 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式

• 包可以包含类和子包，划分项目层次，便于管理

• 解决类命名冲突的问题
• 控制访问权限

JDK中主要的包

import的使用

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类 或全部类(.*)。import语句告诉编译器到哪里去寻找类

import pack1.pack2.Test; //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构

public class PackTest{
    public static void main(String args[]){
        Test t = new Test(); //Test类在pack1.pack2包中定义
        t.display();    
    }
}

注意点

 * 1. 在源文件中显式的使用import结构导入指定包下的类、接口
 * 2. 声明在包的声明和类的声明之间
 * 3. 如果需要导入多个结构，则并列写出即可
 * 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所结构
 * 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
 * 6. 如果使用的类或接口是本包下定义的，则可以省略import结构
 * 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
 * 8. 使用"xxx.*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
 * 9. import static:导入指定类或接口中的静态结构:属性或方法。