02 面向对象（上）

面向对象编程的三条主线

1. Java类及类的成员
2. 面向对象的三大特征
3. 其他关键字

1. 面向过程与面向对象

面向对象的三大特征

• 封装（Encapsulation）所有的内容对外不可见
• 继承（Inheritance）将其他的功能继承下来继续发展
• 多态（Polymorphism）方法的重载本身就是一个多态性的体现

2. Java基本元素：类和对象

类表示一个共性的产物，是一个综合的特征，而对象时一个个性的产物，是一个个体的特征。（图纸与实物的概念）。

类必须通过对象才可以使用，对象的所有操作都在类中定义。

类由属性和方法组成：

• 属性：就相当于人的一个个特征
• 方法：相当于人的一个个的行为。

class Person {
	// 属性，或成员变量
	String name;
	int age;
	boolean isMarried;
	
	// 方法，或函数
	public void walk() {
		System.out.println("人走路...");
	}
	public String display() {
		return "名字是：" + name + "，年龄是： " + age + ", Married: " + isMarried;
	}
}

class Person {
	// 属性，或成员变量
	String name;
	boolean isMarried;
	// 构造器
	public Person() {}
	public Person(String n, boolean im) {
		name = n;
		isMarried = im;
	}
	// 方法，或函数
	public void walk() {
		System.out.println("人走路...")
	}
	public String display() {
		return "名字是：" + name + ",Married:" + isMarried;
	}
	// 代码块
	{
		name = "HanMeiMei";
		age = 17;
		isMarried = true;
	}
	// 内部类
	class pet {
		String name;
		float weight;
	}
}

类的语法格式

修饰符 class 类名 {
	属性声明;
	方法声明;
}
说明：修饰符public：类可以被任意访问
	类的正文要用{}括起来

举例：

public class Person {
    private int age;	// 声明私有变量age
    public void showAge(int i) {	// 声明方法showAge()
        age = i;
    }
}

创建Java自定义类

步骤：

1. 定义类（考虑修饰符、类名）
2. 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）
3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

注：一个.java文件中，可以存在N个类，但是智能存在一个public修饰的类。.java文件的文件名称 必须与 public 修饰的类名完全一致。

3. 对象的创建和使用

如何使用java类？

java类的实例化，即创建类的对象

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

举例：

public class Animal {
	public int legs;
	public void eat() {
		System.out.println("Eating");
	}
	public void move() {
		System.out.println("Move.");
	}
}

Java中类与对象

说明：

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

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，编译不通过。）
• 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

对象的产生

Person p1 = new Person();执行完后的内存状态。其中类定义如下：

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

对象的使用

class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		Person p2 = new Person();
		p1.age = -30;
		p1.shout();
		p2.shout();
	}
}

对象的生命周期

内存解析（栈、堆）

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

Person p1 = new Person();
p1.name = "Tom";
p1.isMale = true;
Person p2 = new Person();
sysout(p2.name);	// null
Person p3 = p1;
p3.age = 10;

根据代码，画出内存图

class Car {
	String color = "red";
	int num = 4;
	void show() {
		System.out.println("color=" + color + "...num=" + num);
	}
}
class CarTest {
	public static void main(String[] args) {
		Car c1 = new Car();	// 建立对象c1
		Car c2 = new Car();	// 建立对象c2
		c1.color = "blue";		// 对对象的属性进行修改
		c1.show();	// 使用对象的方法
		c2.show();
	}
}

对象内存结构

class Person {	// 人类
	// 1. 属性
	String name;	// 姓名
	int age = 1;	// 年龄
	boolean isMale;	// 是否是男性
}

class PersonTest{
	main() {
		Person p = new Person();
		Person p1 = new Person();
		p1.name = "Tom";
		Person p2 = p1;
	}
}

class UserTest {
	main() {
		User user1 = new User();
		user1.age = 10;
		User user2 = new User();
		sysout(user2.age)	// 0
	}
}
class User {
	// 属性（或成员变量）
	String name;
	int age;
}

匿名对象

• 我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。 

• • 如：new Person().shout()

• 使用情况 

• • 如果对一个对象只需要进行一次方法调用，name就可以使用匿名对象。
  • 我们经常讲匿名对象作为实参传递给一个方法调用。

4. 类的成员之一：属性

语法格式

修饰符 数据类型 属性名 = 初始化值；

修饰符

• 常用的权限修饰符有：private、缺省、protected、public
• 其他修饰符：static、final（暂不考虑）

数据类型

• 任何基本数据类型（如int、Boolean）或任何引用数据类型。

属性名

• 属于标识符，符合命名规则和规范即可。

举例：

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

成员变量与局部变量

• 在方法体外，类体内声明的变量称为成员变量。
• 在方法体内部声明的变量称为局部变量。

成员变量

• 实例变量（不以static修饰）
• 类变量（以static修饰）

局部变量

• 形参（方法、构造器中定义的变量）
• 方法局部变量（在方法内定义）
• 代码块局部变量（在代码块内定义）

而只在初始化值方面的异同：

同：都有生命周期

异：局部变量除形参外，均需显式初始化。

成员变量（属性）和局部变量的区别？

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

class Person {	// 人类
    // 1. 属性
    String name;	// 姓名
    int age = 1;	// 年龄
    boolean isMale;	// 是否是男性
    
    public void show(String nation) {	// nation：局部变量
        String color;	// color: 局部变量
        color = "yellow";
    }
}

// 测试类
class PersonTest {
    public static void main(String[] args) {
        Person p = new Person();
        p.show("USA");
    }
}

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

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

成员变量类型	初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或写为: '\u0000'(表现为空)
boolean	false
引用类型	null

5. 类的成员之二：方法

方法的声明格式：

修饰符 返回值类型 方法名 （参数类型 形参1， 参数类型 形参2， ...） {
	方法体积程序代码
	return 返回值；
}

其中：

修饰符：public，缺省，private，protected等

返回值类型：

• 没有返回值：void。
• 有返回值，声明出返回值类型。

方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”

形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“，”隔开。

返回值：方法在执行完毕后返回给调用它的程序的数据。

-	无返回值	有返回值
无形参	void 方法名 () {}	返回值的类型 方法名 (){}
有形参	void 方法名 (形参列表) {}	返回值的类型 方法名 (形参列表) {}

6. 再谈方法

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

public void println(byte x)
public void println(short x)
public void println(int x)
public void println(long x)
public void println(float x)
public void println(double x)
public void println(char x)
public void println(double x)
public void println()

2. 可变形参的方法

JDK5.0，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

// 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();
	//下面两次调用将执行第二个test方法
	to.test1();
	to.test1("aa" , "bb");
	//下面将执行第一个test方法
	to.test(new String[]{"aa"});
}

3. 方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

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

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

其中Person类定义为：

class Person {
	int age;
}

例题1：方法的参数传递

public class TransferTest1 {
    public void swap(int a, int b) {
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("swap方法里，a的值是" + a + ";b的值是 " + b);
    }
    
    public static void main(String[] args) {
        TransferTest1 test = new TransferTest1();
        int a = 5;
        int b = 10;
        test.swap(a, b);
        System.out.println("交换结束后，变量a的值是" + a + " ;变量b的值是" + b);
    }
}

参数类型为：基本数据类型

例题2：方法的参数传递

class DataSwap {
	public int a;
	public int b;
}

public class TransferTest2 {
	public static void swap(DataSwap ds) {
		int temp = ds.a;
		ds.a = ds.b;
		ds.b = temp;
		System.out.println("swap方法里，a Field的值是" + ds.a + ";b Field的值是" + ds.b);
	}
	public static void main(String[] args) {
		DataSwap ds = new DataSwap();
		ds.a = 5;
		ds.b = 10;
		swap(ds);
		System.out.println("交换结束后，a Field的值是" + ds.a + ";b Field的值是" + ds.b);
	}
}

参数类型为：引用数据类型

例题3：方法的参数传递

public class TransferTest3 {
    public static void main(String args[]) {
        TransferTest3 test = new TransferTest3();
        test.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
    }
}

7. OOP特征一：封装与隐藏

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

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

四种访问权限修饰符

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

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

• public类可以在任意地方被访问。
• default类只可以被同一个包内部的类访问。

8. 类的成员之三：构造器

构造器的特征

• 它具有与类相同的名称
• 它不声明返回值类型。（与声明为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;
	}
}

创建Animal类的实例：Animal a = new Animal();

调用构造器，将legs初始化为4.

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

• 隐藏无参构造器（系统默认提供）
• 显式定义一个或多个构造器（无参、有参）

注意：

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

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. 方法的写法：方法的类型(+、-) 方法名（参数名：参数类型）: 返回值类型

9. 关键字：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);
    }
}

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

class Person {	// 定义Person类
    String name;
   	Person(String name) {
        this.name = name;
    }
    public void getInfo() {
        System.out.println("Person类-->" + this.name);
    }
    public boolean compare(Person p) {
        return this.name == p.name;
    }
}
public class PersonTest{
    public static void main(String args[]) {
        Person per1 = new Person("张三");
        Person per2 = new Person("李四");
        per1.getInfo();		// 当前调用getInfo()方法的对象是per1
        per2.getInfo();		// 当前调用getInfo()方法的对象是per2
        boolean b = per1.compare(per2);
    }
}

• 使用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（形参列表）”

10. 关键字：package、import

• 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.atguigu.xxx

源文件布局

Java源文件的基本语法：

[<包声明>]

[<导入声明>]

<类声明>+

示例，VehicleCapacityReport.java文件：

package shipping.reports;

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

public class VehicleCapacityReport {
	private List vehicles;
	public void generateReport(Writer output) {...}
}

包的作用

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

例：某航运软件系统包括：一组域对象、GUI和reports子系统

MVC设计模式

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

模型层 model主要处理数据

• 数据对象封装 model.bean/domain
• 数据库操作类 model.dao
• 数据库 model.db

控制层 controller 处理业务逻辑

• 应用界面相关  controller.activity
• 存放fragment  controller.fragment
• 显示列表的适配器  controller.adapter
• 服务相关的  controller.service
• 抽取的基类  controller.base

视图层  view显示数据

• 相关工具类  view.utils
• 自定义view  view.ui

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组合的使用：调用指定类或接口下的静态的属性或方法。