04_Java面向对象(上)

面向过程与面向对象

• 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
• 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象：Object Oriented Programming

面向过程：Procedure Oriented Programming

面向对象的三大特征

• 封装（Encapsulation）
• 继承（Inheritance）
• 多态（Polymorphism）

面向对象的思想概述

• 程序员从面向过程的执行者转化成了面向对象的指挥者
• 面向对象分析方法分析问题的思路和步骤
  • 根据问题需要，选择问题所针对的现实世界中的实体
  • 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序
    语言，把类构造成计算机能够识别和处理的数据结构
  • 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具

练习：抽象出下面系统中的类及其关系

class TravelAgency {
    book(){
        
    }
    chargeUp(){}
}
class FlightDir{
    book(){}
}
class Bill{  
}
class Passenger{
    // 账单号
    String accountNo;
    // 机票号
    String ticketNo;
}

类和对象

概述

• 类(Class)和对象(Object)是面向对象的核心概念。
  • 类是对一类事物的描述，是抽象的、概念上的定义
  • 对象是实际存在的该类事物的个体，因而也成为实例（instance）
• 万事万物皆对象

可以理解为类就是抽象概念的人，而对象是实实在在的某个人，张三和李四都是对象，他们都属于同一个类，都是人。

Java类与类的成员

• 属性：对应类中的成员变量
• 行为：对应类中的成员方法

Field = 属性 = 成员变量，Method = 成员方法 = 函数

类的语法格式

修饰符 class 类名 {
	成员变量
    成员方法
}

举例

public class Person {
    // 属性/成员变量
    String name;
    boolean isMarried;
    // 构造器
    public Person(){}
    public Person(String name, boolean isMarried){
        this.name = name;
        this.isMarried = isMarried;
    }
    // 方法/函数
    public void walk(){
        System.out.println("人走路");
    }

    public String display() {
        return "我的名字是" + name + "，Married:" + isMarried;
    }
    // 代码块
    {
        this.name = "zhangsanfeng";
        this.isMarried = false;
    }
    // 内部类
    class Pet{
        String name;
        String weight;
    }
}

对象的创建与使用

• 创建对象语法：类名 对象名 = new 类名();
• 使用”对象名.对象成员“的方式访问对象成员（包括属性和方法）

public class Animal {
    public int legs;

    public void eat() {
        System.out.println("Eating...");
    }

    public void move() {
        System.out.println("Moving...");
    }
}

public class Zoo {
    public static void main(String args[]) {
        Animal xb = new Animal();
        Animal xh = new Animal();
        xb.legs = 4;
        xh.legs = 0;
        System.out.println(xb.legs); // 4
        System.out.println(xh.legs); // 0
        xb.legs = 2;
        System.out.println(xb.legs); // 2
        System.out.println(xh.legs); // 0
    }
}

说明：如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

类的访问机制

• 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。(例外：static方法访问非static，编译不通过。)
• 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

对象的创建

class Person {
    int age;
    void shout(){
        System.out.println("oh my god! i am " + age);
    }
}

Person p1 = new Person();
//执行完成后的内存状态如下

对象的使用

class PersonTest{
    public static void main(String[] args) { //程序运行的内存布局如下图
        Person p1 = new Person();
        Person p2 =new Person();
        p1.age = -30;
        p1.shout();
        p2.shout();
    }
}

对象的生命周期

内存解析

• 堆：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
• 通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。 方法执行完，自动释放。
• 方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

匿名对象

• 我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。
  • 如：new Person().shout();
• 使用情况
  • 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象
  • 我们经常将匿名对象作为实参传递给一个方法调用

类的成员之一：属性

语法格式：修饰符 数据类型 属性名 = 初始化值;

public String name = null;

• 说明1：修饰符
  • 常用的权限修饰符有：private、缺省、protected、public
  • 其他修饰符：static、final
• 说明2：数据类型
  • 任何基本数据类型(如int、Boolean) 或 任何引用数据类型
• 说明3：属性名
  • 属于标识符，复合命名规则和规范即可。

举例

public class Person{
    private int age;// 声明private变量 age
    public String name = "Lisa";//声明public变量 name
}

变量的分类

• 在方法体外，类体内声明的变量称为成员变量
• 在方法体内部声明的变量称为局部变量
• 注意：二者在初始化方面的异同
  • 同：都有生命周期
  • 异：局部变量除形参外，均需显式初始化

	成员变量	局部变量
声明的位置	直接声明在类中	方法形参或内部、代码块内、构造器内等
修饰符	private、public、static、final等	不能用权限修饰符修饰，可以用final修饰
初始值	有默认初始化值	没有默认初始化值，必须显式赋值，方可使用
内存加载位置	堆空间或静态域内	栈空间

对象属性的默认初始化赋值

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型，如上面的Person及前面讲过的数组。

成员变量类型	初始值
byte	0
short	0
int	0
long	0L
float	0f
double	0.0
char	0或写为：‘\u0000’（表现为空）
boolean	false
引用类型	null

类的成员之二：方法

什么是方法（method、函数）

• 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
• 将功能封装为方法的目的是，可以实现代码重用，简化代码
• 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 返回值;
}

• 返回值类型：
  • 没有返回值：void
  • 有返回值，声明出返回值的类型。与方法体中return返回值类型一致
• 方法名：属于标识符，命名时遵循标识符命名规则和规范，见名知意
• 形参列表：可以包含0个，1个或多个参数。多个参数时用逗号隔开

注意：方法中只能调用方法或属性，不可以在方法内部定义方法。

方法的重载

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

特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

示例

//返回两个整数的和
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;}

可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

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

说明：

1. 声明格式：方法名(参数的类型名 …参数名)
2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
3. 可变个数形参的方法与同名的方法之间，彼此构成重载
4. 可变参数方法的使用与方法参数部分使用数组是一致的
5. 方法的参数部分有可变形参，需要放在形参声明的最后
6. 在一个方法的形参位置，最多只能声明一个可变个数形参

public void test(String[] msg){
System.out.println("含字符串数组参数的test方法 ");
}
public void test1(String book){
System.out.println("****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
System.out.println("****形参长度可变的test1方法****");
}
public static void main(String[] args){
    TestOverload to = new TestOverload();
    to.test1();//****形参长度可变的test1方法****
    to.test1("aa", "bb");//****形参长度可变的test1方法****
    to.test1("aa");//****与可变形参方法构成重载的test1方法****
    //下面将执行第一个test方法
    to.test(new String[]{"aa"});
}

方法参数的值传递机制※

方法参数

• 形参：方法声明时的参数
• 实参：方法调用时实际传给形参的参数值

Java的实参值如何传入方法呢？

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

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

基本数据类型参数传递

public static void main(String[] args) {
	int x = 5;
	System.out.println("修改之前x = " + x);// 5
	// x是实参
	change(x);
	System.out.println("修改之后x = " + x);// 5
}
public static void change(int x) {
	System.out.println("change:修改之前x = " + x);
	x = 3;
	System.out.println("change:修改之后x = " + x);
}

内存结构图

引用数据类型传递

public static void main(String[] args) {
    Person obj = new Person();
    obj.age = 5;
    System.out.println("修改之前age = " + obj.age);// 5
    // x是实参
    change(obj);
    System.out.println("修改之后age = " + obj.age);// 3
}
public static void change(Person obj) {
    System.out.println("change:修改之前age = " + obj.age);
    obj.age = 3;
    System.out.println("change:修改之后age = " + obj.age);
}
class Person{
	int age; 
}

public static void main(String[] args) {
    Person obj = new Person();
    obj.age = 5;
    System.out.println("修改之前age = " + obj.age);// 5
    // x是实参
    change(obj);
    System.out.println("修改之后age = " + obj.age);// 5
}
public static void change(Person obj) {
    obj = new Person();// 新建了一个对象
    System.out.println("change:修改之前age = " + obj.age);
    obj.age = 3;
    System.out.println("change:修改之后age = " + obj.age);
}
class Person{
	int age; 
}

递归方法

递归方法：一个方法体内调用它自身

• 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
• 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

//计算1-100之间所有自然数的和
public int sum(int num){
    if(num == 1){
    	return 1;
    }else{
    	return num + sum(num - 1);
    }
}
public static void main(String[] args){
    int sum = 0;
    s
}

类的成员之三：构造器（构造方法）

构造器的特征

• 它具有与类相同的名称

• 它不声明返回值类型。（与声明为void不同）

• 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用

作用：创建对象；给对象进行初始化

例如：

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

构造器的语法格式

修饰符 类名 (参数列表) {
	初始化语句;
}

举例：

public class Animal {
	private int legs;
    // 构造器
    public Animal() {
    	legs = 4;
    } 
    public void setLegs(int i) {
    	legs = i;
    }
    public int getLegs() {
    	return legs;
    }
}

构造器的分类

根据参数不同，构造器可以分为如下两类

• 隐式无参构造器（系统默认提供）

• 显式定义一个或多个构造器（无参、有参）

构造器重载

构造器一般用来创建对象的同时初始化对象，构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String n, int a, Date d) {
        name = n;
        age = a;
        birthDate = d;
    }
    public Person(String n, int a) {
        name = n;
        age = a;
    }
    public Person(String n, Date d) {
        name = n;
        birthDate = d;
    }
    public Person(String n) {
        name = n;
        age = 30;
    }
}

注意事项

• Java语言中，每个类都至少有一个构造器
• 默认构造器的修饰符与所属类的修饰符一致
• 一旦显式定义了构造器，则系统不再提供默认构造器
• 一个类可以创建多个重载的构造器
• 父类的构造器不可被子类继承

总结：类的赋值过程

赋值的位置

① 默认初始化

② 显式初始化

③ 构造器中初始化

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

赋值的顺序

① - ② - ③ - ④

面向对象特征之一：封装与隐藏

作用与含义

我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？

我们程序设计，追求”高内聚，低耦合“

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

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

未封装隐藏的情况

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。

class Animal {
    public int legs;
    public void eat(){
    	System.out.println("Eating");
    }
    public void move(){
    	System.out.println("Moving.");
    }
}
public class Zoo {
    public static void main(String args[]) {
        Animal xb = new Animal();
       
        xb.legs = 4;
        System.out.println(xb.legs);
        xb.eat();
        xb.move();
    }
}
// 应该将legs属性保护起来，防止乱用。保护的方式：信息隐藏
// 问题：xb.legs = -1000;

信息封装及隐藏的情况

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

• 隐藏一个类中不需要对外提供的实现细节；

• 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

• 便于修改，增强代码的可维护性；

class Animal {
	private int legs;// 将属性legs定义为private，只能被Animal类内部访问
	public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
		if (i != 0 && i != 2 && i != 4) {
            System.out.println("Wrong number of legs!");
            return;
		}
		legs = i;
	}
    public int getLegs() {
        return legs;
    }
}
public class Zoo {
    public static void main(String args[]) {
        Animal xb = new Animal();
        xb.setLegs(4); // xb.setLegs(-1000);
        //xb.legs = -1000; // 非法
        System.out.println(xb.getLegs());
    }
}

四种访问权限修饰符

Java权限修饰符public、protected、(缺省)、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
public	YES	YES	YES	YES
protected	YES	YES	YES
缺省	YES	YES
private	YES

对于class的权限修饰只可以用public和default(缺省)。

• public类可以在任意地方被访问。

• default类只可以被同一个包内部的类访问。

JavaBean

JavaBean是一种Java语言写成的可重用组件，所谓javaBean，是指符合如下标准的Java类

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

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

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;
    }
}

UML类图

1. + 表示 public 类型， - 表示 private 类型，#表示protected类型
2. 方法的写法: 方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型

关键字this的使用

this是什么

• 在Java中，this关键字比较难理解，它的作用和其词义很接近。

  • 它在方法内部使用，即这个方法所属对象的引用；

  • 它在构造器内部使用，表示该构造器正在初始化的对象。

• this 可以调用类的属性、方法和构造器。

• 什么时候使用this关键字呢？

  • 当在方法内需要用到调用该方法的对象时，就用this。

    具体的：我们可以用this来区分属性和局部变量。

    比如：this.name = name;

使用this调用属性、方法

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(String name,int age){
    	this.name = name; 
    	this.age = age; 
    }
    public void getInfo(){
    	System.out.println("姓名：" + name) ;
    	this.speak();
    }
    public void speak(){
    	System.out.println(“年龄：” + this.age);
    }
}

注意事项

• 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。
• 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
• 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
• this可以作为一个类中构造器相互调用的特殊格式

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(){ // 无参构造器
    	System.out.println("新对象实例化") ;
    }
    public Person(String name){
    	this(); // 调用本类中的无参构造器
    	this.name = name ;
    }
    public Person(String name,int age){
    	this(name) ; // 调用有一个参数的构造器
    	this.age = age;
    }
    public String getInfo(){
    	return "姓名：" + name + "，年龄：" + age ;
    } 
}

• 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
• 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
• 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
• "this(形参列表)"必须声明在类的构造器的首行！
• 在类的一个构造器中，最多只能声明一个"this(形参列表)"

关键字package、import的使用

package的含义和作用

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。

它的格式为：package 顶层包名.子包名;

举例：

// pack1\pack2\PackageTest.java
package pack1.pack2; //指定类PackageTest属于包pack1.pack2

public class PackageTest{
    public void display(){
    	System.out.println("in method display()");
    }
}

• 包对应于文件系统的目录，package语句中，用“.” 来指明包(目录)的层次;
• 包通常用小写单词标识。通常使用所在公司域名的倒置：com.baidu.xxx

源文件布局

Java源文件的基本语法：

/*
[<包声明>]
[<导入声明>]
<类声明>+
*/
package shipping.reports;

import shipping.domain.*;
import java.util.List;
import java.io.*;

public class Test{
    private int num;
    ...
}

包的作用

• 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
• 包可以包含类和子包，划分项目层次，便于管理
• 解决类命名冲突的问题
• 控制访问权限

扩展：MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

• Model模型层 主要处理数据
  • 数据对象封装 model.bean/domain
  • 数据库操作类 model.dao
  • 数据库 model.db
• View视图层 显示数据
  • 相关工具类 view.utils
  • 自定义view view.ui
• Controller控制层 处理业务逻辑
  • 应用界面相关 controller.activity
  • 存放fragment controller.fragment
  • 显示列表的适配器 controller.adapter
  • 服务相关的 controller.service
  • 抽取的基类 controller.base

JDK中主要的包介绍

1. java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能

2. java.net----包含执行与网络相关的操作的类和接口。

3. java.io ----包含能提供多种输入/输出功能的类。

4. java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

5. java.text----包含了一些java格式化相关的类

6. java.sql----包含了java进行JDBC数据库编程的相关类/接口

7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

关键字import

• 为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。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. 如果需要导入多个类或接口，那么就并列显式多个import语句即可

4. 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。

5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。

6. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。

7. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。

8. import static组合的使用：调用指定类或接口下的静态的属性或方法