Java~面向对象（上）

目录

• 1、面向过程与面向对象
• • 1.1、学习面向对象内容的三条主线
  • 1.2、面向对象的思想概述
• 2、 类和对象
• • 2.1、Java 类及类的成员
  • 2.2、类与对象的创建及使用
  • 2.3、对象的创建和使用：内存解析
• 3、类的成员之一：属性
• 4、类的成员之二：方法
• • 4.1、类中方法的声明和使用
  • 4.2、理解“万事万物皆对象”
  • 4.3、对象数组的内存解析
  • 4.4、匿名对象的使用
  • 4.5、自定义数组的工具类
  • 4.6、方法的重载(overload)
  • 4.7、可变个数的形参
  • 4.8、方法参数的值传递机制(重点！！！)
  • • 4.8.1、针对基本数据类型
    • 4.8.2、针对引用数据类型
  • 4.9、递归(recursion)方法
  • 4.10、练习
• 5、面向对象特征之一：封装与隐藏
• • 5.1、理解封装与隐藏
  • 5.2、练习
• 6、类的结构之三:构造器(构造方法)
• • 6.1、构造器的理解
  • 6.2、总结属性赋值的过程
  • 6.3、JavaBean 的使用
  • 6.4、UML 类图
  • 6.5、练习
• 7、this关键字
• • 7.1、this 调用属性、方法、构造器
  • 7.2、练习
• 8、package、import关键字
• • 8.1、package关键字
  • 8.2、import关键字

1、面向过程与面向对象

面向过程(POP) 与面向对象(OOP)

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

1.1、学习面向对象内容的三条主线

• Java 类及类的成员：属性、方法、构造器、代码块、内部类
• 面向对象的三大特征：封装、继承、多态性、(抽象性)
• 其它关键字：this、super、static、final、abstract、interface、package、import 等

1.2、面向对象的思想概述

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

2、 类和对象

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

• 可以理解为：类= 抽象概念的人；对象= 实实在在的某个人
  面向对象程序设计的重点是类的设计；
  设计类，其实就是设计类的成员。

2.1、Java 类及类的成员

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

2.2、类与对象的创建及使用

• 设计类、其实就是设计类的成员
  Field = 属性 = 成员变量 = 域、字段
  Method = (成员)方法 = 函数

• 创建类 = 类的实例化 = 实例化类

• 类和对象的使用(面向对象思想落地的实现)
  1.创建类，设计类的成员
  2.创建类的对象
  3.通过“对象.属性”或“对象.方法”调用对象的结构

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

public class PersonTest {
	public static void main(String[] args) {
		//2.创建 Person 类的对象
		//创建对象语法：类名 对象名 = new 类名();
		Person p1 = new Person();
		
		//调用类的结构：属性、方法
		//调用属性:“对象.属性”
		p1.name = "Tom";
		p1.age = 25;
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法:“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("chinese");
		//**********************
		Person p2 = new Person();
		System.out.println(p2.name); //null
		//**********************
		//将 p1 变量保存的对象地址值赋给 p3,导致 p1 和 p3 指向了堆空间中的一个对象实体。
		Person p3 = p1;
		System.out.println(p3.name);//Tom
		p3.age = 10;
		System.out.println(p1.age); //10
	}
}

//1.创建类，设计类的成员
class Person{
	
	//属性:对应类中的成员变量
	String name;
	int age;
	boolean isMale;
	
	//方法:对应类中的成员方法
	public void eat(){
		System.out.println("吃饭");
	}
	
	public void sleep(){
		System.out.println("睡觉");
	}
	
	public void talk(String language){
		System.out.println("人可以说话，使用的是：" + language);
	}
}

2.3、对象的创建和使用：内存解析

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

【案例 1】

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

【案例 2】

Person p1= newPerson();
p1.name = "胡利民";
p1.age = 23;
Person p2 = new Person();
p2.age = 10;

3、类的成员之一：属性

• 属性(成员变量)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)
      • 局部变量：加载到栈空间

public class UserTest {
	public static void main(String[] args) {
		User u1 = new User();
		System.out.println(u1.name);//null
		System.out.println(u1.age);//0
		System.out.println(u1.isMale);//false
		
		u1.talk("俄语");
	}
}
class User{
	//属性(或成员变量)
	String name;	//缺省
	public int age;	
	boolean isMale;
	
	public void talk(String language){//language:形参，也是局部变量
		System.out.println("我们使用" + language + "进行交流。");
	}
	
	public void eat(){
		String food = "石头饼";	//food:局部变量
		System.out.println("北方人喜欢吃:" + food);
	}
}

4、类的成员之二：方法 4.1、类中方法的声明和使用

• 方法：描述类应该具有的功能
  • 比如：Math类：sqrt()\random() …
    Scanner类：nextXxx() …
    Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …
  • 举例：
    public void eat(){}
    public void sleep(int hour){}
    public String getName(){}
    public String getNation(String nation){}
• 方法的声明：

权限修饰符 返回值类型 方法名(形参列表){
	方法体
}

​ 注意：static、final、abstract 也能修饰方法，后面讲

• 说明：
  • 关于权限修饰符：默认方法的权限修饰符先都使用public
    Java规定的4种权限修饰符：private、public、缺省、protected
  • 返回值类型： 有返回值 vs 没有返回值
    • 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
      return关键字来返回指定类型的变量或常量：“return 数据”。如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return。但是，如果使用的话，只能“return;”表示结束此方法的意思。
    • 我们定义方法该不该有返回值？① 题目要求 ② 凭经验：具体问题具体分析
  • 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
  • 形参列表：方法名可以声明0个、1个，或多个形参
    • 格式：数据类型1 形参1，数据类型2 形参2，…
    • 我们定义方法时，该不该定义形参？
      ① 题目要求
      ② 凭经验，具体问题具体分析
  • 方法体：方法功能的体现
• return关键字的使用
  • 1.使用范围：使用在方法体中
  • 2.作用：① 结束方法
    ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据
  • 3.注意点：return关键字后不可声明执行语句
• 方法的使用中
  • 可以调用当前类的属性或方法
  • 特殊的：方法A中又调用了方法A–>递归方法
  • 方法中不能定义其他方法。

public class CustomerTest {
	public static void main(String[] args) {
		
		Customer cust1 = new Customer();
		cust1.eat();
		
		cust1.sleep(8);
	}
}
//客户类
class Customer{
	
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat(){
		System.out.println("客户吃饭");
		return;//return后不可以声明表达式
	}
	
	public void sleep(int hour){
		System.out.println("休息了" + hour + "个小时");
		
		eat();//方法中能调用方法
//		sleep(10);//递归
	}
	
	public String getName(){
		if(age > 18){
			return name;
		}else{
			return "Tom";
		}
	}
	
	public String getNation(String nation){
		String info = "我的国籍是：" + nation;
		return info;
	}
	
	public void info(){
		//错误，方法中不能定义其他方法
//		public void swim(){
//			
//		}
	}
}

4.2、理解“万事万物皆对象”

• 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。
  • Scanner，String等
  • 文件：File
  • 网络资源：URL
• 涉及到Java语言与前端html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象

4.3、对象数组的内存解析

引用类型的变量，只可能存储量两类值：null或地址值（含变量类型）

Student[] stus= new Student[5];//引用数据类型都是null
stus[0] = new Student();//从这里开始将3个属性的地址值赋给stus[0]
sysout(stus[0].state);//1
sysout(stus[1]);//null
sysout(stus[1].number);//异常，没有new对象
stus[1] = new Student();
sysout(stus[1].number);//0

class Student{
  int number;//学号
  int state = 1;//年级
  int score;//成绩
}

4.4、匿名对象的使用

• 理解：我们创建的对象，没有显示的赋值给一个变量名，即为匿名对象

• 特征：匿名对象只能调用一次

public class InstanceTest {
	public static void main(String[] args) {
        
		Phone p = new Phone();
		System.out.println(p);//地址值
		
		p.sendEmail();//这两个p都指向堆空间中的同一个对象
		p.playGame();
		
		//匿名对象
		new Phone().sendEmail();//new Phone(),这里new了两个对象，堆空间中两个不同的区域
		new Phone().playGame();
		
		new Phone().price = 1999;//道理同上
		new Phone().showPrice();//0.0
		
		//*******************************
		PhoneMall mall = new PhoneMall();
		mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());	//new Phone()赋值给phone
	}
}

class PhoneMall{
    //方法中的形参可以是任意数据类型，可以使Phone类型，调用时往里面传Phone类型的对象
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
}

class Phone{
	double price;	//价格
	
	public void sendEmail(){
		System.out.println("发邮件");
	}
	public void playGame(){
		System.out.println("打游戏");
	}
	public void showPrice(){
		System.out.println("手机价格为:" + price);
	}
}

4.5、自定义数组的工具类

求数组的最大值、最小值、总和、平均值；反转数组、复制数组、数组排序、遍历数组、查找指定元素

class ArrayUtil {

	// 求数组的最大值
	public int getMax(int[] arr) {
		int maxValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (maxValue < arr[i]) {
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

	// 求数组的最小值
	public int getMin(int[] arr) {
		int minValue = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (minValue > arr[i]) {
				minValue = arr[i];
			}
		}
		return minValue;
	}

	// 求数组总和
	public int getSum(int[] arr) {
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		return sum;
	}

	// 求数组平均值
	public int getAvg(int[] arr) {//传递数组的地址值
		int avgValue = getSum(arr) / arr.length;
		return avgValue;
	}

	// 反转数组
	public void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}
	}

	// 复制数组
	public int[] copy(int[] arr) {//返回数组类型
		int[] arr1 = new int[arr.length];
		for (int i = 0; i < arr1.length; i++) {//i的大小是由arr1.length决定的
			arr1[i] = arr[i];
		}
		return null;
	}

	// 数组排序
	public void sort(int[] arr) {
		// 冒泡排序
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
//					int temp = arr[j];
//					arr[j] = arr[j + 1];
//					arr[j + 1] = temp;
					//或者
					swap(arr,j,j + 1);
				}
			}
		}
	}
	//交换数组中指定两个位置元素的值
	public void swap(int[] arr,int i,int j){
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	// 遍历数组
	public void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + ",");
		}
	}
    
	// 查找指定元素
	public int getIndex(int[] arr, int dest) {
		//线性查找
		for (int i = 0; i < arr.length; i++) {
			if (dest==arr[i]) {
				return i;
			}
		}
		return -1;//返回一个负数，表示没有找到
	}
}

//@Description 测试类
public class ArrayUtilTest {

	public static void main(String[] args) {
		ArrayUtil util = new ArrayUtil();
		int[] arr = new int[]{32,5,26,74,0,96,14,-98,25};
		int max = util.getMax(arr);
		System.out.println("最大值为:" + max);
		
		System.out.print("排序前:");
		util.print(arr);
		
		util.sort(arr);
		System.out.print("排序后:");
		util.print(arr);
		
		System.out.println("查找:");
		int index = util.getIndex(arr, 5);
		if(index > 0){
			System.out.println("找到了，索引地址:" + index);
		}else{
			System.out.println("没找到");
		}
	}
}

4.6、方法的重载(overload)

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

​ “两同一不同”：同一个类、相同方法名

​ 形参列表不同（形参个数不同，形参类型不同）

• 判断是否重载与方法的返回值类型、权限修饰符、形参变量名、方法体都无关

• 在通过对象调用方法时，如何确定某一个指定的方法：

​ 方法名—》参数列表

public class OverLoadTest {
	
	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		test.getSum(1, 2);	//调用的第一个，输出1
	}

	//如下的四个方法构成了重载
	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){
		
	}
	
	//以下3个是错误的重载
//	public int getSum(int i,int j){
//		return 0;
//	}
	
//	public void getSum(int m,int n){
//		
//	}
	
//	private void getSum(int i,int j){
//		
//	}
}

判断是否与void show(int a,char b,double c){}构成重载

a)void show(int x,char y,double z){} // no
b)int show(int a,double c,char b){} // yes
c) void show(int a,double c,char b){} // yes
d) boolean show(int c,char b){} // yes
e) void show(double c){} // yes 
f) double show(int x,char y,double z){} // no
g) void shows(){double c} // no

4.7、可变个数的形参

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

• 具体使用：

  • 可变个数形参的格式：数据类型 … 变量名
  • 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个…
  • 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
  • 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
  • 可变个数形参在方法中的形参中，必须声明在末尾
  • 可变个数形参在方法中的形参中，最多只能声明一个可变形参

public class MethodArgs {

	public static void main(String[] args) {
		MethodArgs test = new MethodArgs();//创建当前类的对象，方法通过对象调用
		
		// test.show("hell0");
		// test.show("hello","world");
		// test.show();

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

	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){
	//
	// }

	public void show(int i, String... strs) {//必须声明在末尾

	}

	//The variable argument type String of the method show must be the last parameter
//	public void show(String... strs,int i,) {//错误，必须声明在末尾
//
//	}
}

4.8、方法参数的值传递机制(重点！！！)

关于变量的赋值

• 如果变量是基本数据类型，此时赋值的是变量所保存的数据值
• 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

public class ValueTransferTest {

	public static void main(String[] args) {
		
		System.out.println("**********基本数据类型：***********");
		int m = 10;
		int n = m;
		System.out.println("m = " + m + ", n = " + n);

		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);
		
		o2.orderId = 1002;
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
		
	}
}

class Order{
	int orderId;
}

4.8.1、针对基本数据类型

• 方法的形参的传递机制：值传递

  • 形参：方法定义时，声明的小括号内的参数

    实参：方法调用时，实际传递给形参的数据

  • 值传递机制：如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。

public class ValueTransferTest1 {

	public static void main(String[] args) {
		
		int m = 10;
		int n = 20;
		System.out.println("m = " + m + ", n = " + n);//10 20
		
		ValueTransferTest1 test = new ValueTransferTest1();
		test.swap(m, n);
		System.out.println("m = " + m + ", n = " + n);//10 20
		
	}
	//交换两个变量的值的 *** 作
	public void swap(int m,int n){//只是swap()方法中的m n变化，main中并没有改变
		int temp = m;
		m = n;
		n = temp;
	}
}

4.8.2、针对引用数据类型

如果参数是引用数据类型，此时实参赋值给形参的是实参存储数据的地址值

public class ValueTransferTest2 {

	public static void main(String[] args) {
		Data data = new Data();
		
		data.m = 10;
		data.n = 20;
		System.out.println("m = " + data.m + ", n = " + data.n);//10 20

		//交换m和n的值
//		int temp = data.m;
//		data.m = data.n;
//		data.n = temp;

		ValueTransferTest2 test = new ValueTransferTest2();
		test.swap(data);//理解：两个date都指向堆空间中同一个对象实体
		
		System.out.println("m = " + data.m + ", n = " + data.n);//20 10
	}
	
	public void swap(Data data){//因为m和n在Data类中，需要用Data类的对象调用，所以Data类的对象作为形参
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
}

class Data{
	int m;
	int n;
}

同一个类中：由static修饰的方法不能调用非static修饰的方法；特例：由static修饰的main()方法可以调用非static修饰的方法，但要先建立当前类的对象，再用对象来调用即可。如果两个方法都是非static的，就可以直接调用，不必创建对象来调用。

不同的类中：调用方法时必须用对象来调用

4.9、递归(recursion)方法

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

public class RecursionTest {

	public static void main(String[] args) {

		// 例1:计算1-100之间所有自然数的和
		// 方法1:
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			sum += i;
		}
		System.out.println("sum = " + sum);

		// 方法2:递归
		RecursionTest test = new RecursionTest();
		int sum1 = test.getSum(100);
		System.out.println("sum1 = " + sum1);
        
        System.out.println("*****************");
		int value = test.f(10);
		System.out.println(value);
	}

	// 例1:计算1-n之间所有自然数的和
	public int getSum(int n) {
		if (n == 1) {//先算1
			return 1;
		} else {
			return n + getSum(n - 1);//从大往小进行计算
		}
	}

	// 例2:计算1-n之间所有自然数的乘积
	//归求阶乘(n!)的算法
	public int getSum1(int n) {
		if (n == 1) {
			return 1;
		} else {
			return n * getSum1(n - 1);//从大往小进行计算
		}
	}
    
    //例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	//其中n是大于0的整数，求f(10)的值。
	public int f(int n){
		if(n == 0){//从小的开始计算
			return 1;
		}else if(n == 1){
			return 4;
		}else{
			return 2*f(n - 1) + f(n - 2);//f(n)=f(n+2) - 2f(n+1)这样写会栈溢出
		}
	}
 
    //例4：斐波那契数列
	
	//例5：汉诺塔问题
	
	//例6：快排
    
}

4.10、练习

练习1

【题目描述】

【代码实现】

public class Person {
	String name;
	int age;
	int sex;//sex=1表示为男性,sex=0表示为女性
	
	public void study(){
		System.out.println("studying");
	}
	
	public void showAge(){
		System.out.println("age:" + age);
	}
	
	public int addAge(int i){
		age += i;
		return age;
	}
}

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		
		p1.name = "Tom";
		p1.age = 18;
		p1.sex = 1;
		
		p1.study();
		p1.showAge();
		
		int newAge = p1.addAge(2);//用int型接受，因为下面要用到这个改变的年龄
		System.out.println(p1.name + "的年龄为" + newAge);
		System.out.println(p1.age);	//20
		
		//*******************************
		Person p2 = new Person();
		p2.showAge();	//0
		p2.addAge(10);//也可以不用int类型接受，因为不需要输出信息，但是age已经改变
		p2.showAge();	//10
		
		p1.showAge();	//20
	}
}

练习2（对象数组题目）

【题目描述】

定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：
1) 生成随机数：Math.random()，返回值类型double;  
2) 四舍五入取整：Math.round(double d)，返回值类型long

【代码实现1】

public class StudentTest {
	public static void main(String[] args) {
		
//		Student s1 = new Student();//new20个对象
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
		
		//声明Student类型的数组
		Student[] stus = new Student[20];  //String[] arr = new String[10];
		//用Student类型的数组存放
		for(int i = 0;i < stus.length;i++){
			//给数组元素赋值
			stus[i] = new Student();//给每一个元素new一个对象，stus[i]就是对象
			//给Student对象的属性赋值
			stus[i].number = (i + 1);
			//年级：[1,6]
			stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			//成绩：[0,100]
			stus[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		//遍历学生数组
		for(int i = 0;i <stus.length;i++){
//			System.out.println(stus[i].number + "," + stus[i].state 
//					+ "," + stus[i].score);
			
			System.out.println(stus[i].info());
		}
		
		System.out.println("********************");
		
		//问题一：打印出3年级(state值为3）的学生信息。
		for(int i = 0;i <stus.length;i++){
			if(stus[i].state == 3){
				System.out.println(stus[i].info());
			}
		}
		
		System.out.println("********************");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		for(int i = 0;i < stus.length - 1;i++){
			for(int j = 0;j < stus.length - 1 - i;j++){
				if(stus[j].score > stus[j + 1].score){
					//如果需要换序，交换的是数组的元素：Student对象！！！
					Student temp = stus[j];//[注意]：Student temp  这里是将整个对象换位置
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
		
		//遍历学生数组
		for(int i = 0;i <stus.length;i++){
			System.out.println(stus[i].info());
		}
		
	}
}

class Student{
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;//谁调用就是谁的
	}
}

【代码实现2】（用封装的思想）

//此代码是对StudentTest.java的改进：将 *** 作数组的功能封装到方法中。
//优化时是将遍历 冒泡 查找三种方法封装到StudentTest1类中的，所以建立对象要用StudentTest1类，也可以新建立一个类，用这个类new对象（方法不能套方法）

public class StudentTest1 {
	public static void main(String[] args) {
		
		//声明Student类型的数组
		Student1[] stus = new Student1[20];  
		
		for(int i = 0;i < stus.length;i++){
			//给数组元素赋值
			stus[i] = new Student1();
			//给Student对象的属性赋值
			stus[i].number = (i + 1);
			//年级：[1,6]
			stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			//成绩：[0,100]
			stus[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		StudentTest1 test = new StudentTest1();
		
		//遍历学生数组
		test.print(stus);
		
		System.out.println("********************");
		
		//问题一：打印出3年级(state值为3）的学生信息。
		test.searchState(stus, 3);
		
		System.out.println("********************");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		test.sort(stus);
		
		//遍历学生数组
		test.print(stus);
		
	}
	
	//遍历Student1[]数组的 *** 作
	public void print(Student1[] stus){
		for(int i = 0;i <stus.length;i++){
			System.out.println(stus[i].info());
		}
	}
	//查找Stduent数组中指定年级的学生信息
	public void searchState(Student1[] stus,int state){//在那个数组中找，找那个年纪的
		for(int i = 0;i <stus.length;i++){
			if(stus[i].state == state){
				System.out.println(stus[i].info());
			}
		}
	}
	
	//给Student1数组排序
	public void sort(Student1[] stus){
		for(int i = 0;i < stus.length - 1;i++){
			for(int j = 0;j < stus.length - 1 - i;j++){
				if(stus[j].score > stus[j + 1].score){
					//如果需要换序，交换的是数组的元素：Student对象！！！
					Student1 temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
	}
}

class Student1{
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;
	}
}

练习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;//这里的i是first()方法中传过来的，在栈空间中i从5变为0
		v.i=20;
		Value val=new Value();
		v=val;
		System.out.println(v.i+" "+i);
		
	}
}
class Value {
	int i= 15;
} 

练习4：貌似是考察方法的参数传递

【题目描述】

【代码实现】

public static void method(int a,int b){
	a = a * 10;
	b = b * 20;
	System.out.println(a);
	System.out.println(b);
	System.exit(0);//不让main方法中的Sysout输出
}

练习5

【题目描述】

定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。

【代码实现】

//错误写法
for(int i= 0;i < arr.length;i++){
	arr[i] = arr[i] / arr[0];
}

//正确写法1, 倒着写
for(int i = arr.length –1;i >= 0;i--){
	arr[i] = arr[i] / arr[0];
}

//正确写法2
int temp = arr[0];
for(int i= 0;i < arr.length;i++){
	arr[i] = arr[i] / temp;
}

练习6

【题目描述】

int[] arr = new int[10];
System.out.println(arr);//地址值?

char[] arr1 = new char[10];
System.out.println(arr1);//地址值?

【代码实现】

public class ArrayPrint {

	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3};
        //传进去的是一个Object的对象
		System.out.println(arr);//地址值
		
		char[] arr1 = new char[]{'a','b','c'};
        //传进去的是一个数组，里面遍历数据了
		System.out.println(arr1);//abc（看源码）
	}
}

练习7

【题目描述】

输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值
	1  1  2  3  5  8  13  21  34  55
	规律：一个数等于前两个数之和
	要求：计算斐波那契数列(Fibonacci)的第n个值，并将整个数列打印出来

【代码实现】

public class Recursion {

	public static void main(String[] args) {
		Recursion2 test = new Recursion2();
		int value = test.f(10);
		System.out.println(value);
	}
	
	public int f(int n) {
		if (n == 1 || n == 2) {
			return 1;
		} else {
			return f(n - 1) + f(n - 2);
		}
	}
}

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

5.1、理解封装与隐藏

• 一、问题的引入：

  当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值 *** 作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说setLegs，同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)

  此时，针对于属性就体现了封装性。

• 二、封装性的体现：

  我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)

  拓展：封装性的体现：① 如上 ② 单例模式 ③ 不对外暴露的私有方法

• 三、封装性的体现，需要权限修饰符来配合。

  1.Java 规定的 4 种权限：(从小到大排序)private、缺省、protected、public

  2.4 种权限用来修饰类及类的内部结构：属性、方法、构造器、内部类

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

总结封装性：Java 提供了 4 中权限修饰符来修饰类及类的内部结构，体现类及类的内部结构的可见性的方法

public class AnimalTest {

	public static void main(String[] args) {
		Animal a = new Animal();
		a.name = "大黄";
//		a.age = 1;
		a.show();
		
//		a.legs = -4;//The field Animal.legs is not visible;leg是用private修饰的，不能直接赋值
		a.show();
		
        a.setLegs(6);
//		a.setLegs(-6);
        
		System.out.println(a.name);//大黄
		System.out.println(a.getLegs());//6
	}
}
class Animal{
	
	String name;
	private int age;//其他类不能调用
	private int legs; //腿的个数
	
	//对于属性的设置
	public void setLegs(int l){//对腿做限制：正的偶数
		if(l >= 0 && l % 2 == 0){
			legs = l;
		}else{
			legs = 0;
		}
	}
	
	//对于属性的获取
	public int getLegs(){
		return legs;
	}
	
	public void eat(){
		System.out.println("动物进食");
	}
	
	public void show(){//谁调用show方法,下面的属性值就是谁的
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
}

5.2、练习

【题目描述】

1.创建程序,在其中定义两个类：Person 和 PersonTest 类。
定义如下：用 setAge()设置人的合法年龄(0~130)，用 getAge()返回人的年龄。
 
2.在 PersonTest 类中实例化 Person 类的对象 b，
调用 setAge()和 getAge()方法，体会 Java 的封装性。

public class Person {

	private int age;
	
	public void setAge(int a){
		if(a < 0 || a > 130){
			System.out.println("传入的数据据非法");
			return;
		}
		age = a;
	}
	
	public int getAge(){
		return age;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		Person p1 = new Person();
//		p1.age = 1;	//编译不通过
		
		p1.setAge(12);
		
		System.out.println("年龄为:" + p1.getAge());
	}
}

6、类的结构之三:构造器(构造方法) 6.1、构造器的理解

• 一、构造器的作用
  • 1.创建对象
  • 2.初始化对象的属性
• 二、说明
  • 如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
  • 定义构造器的格式：权限修饰符 类名(形参列表) { }
  • 一个类中定义的多个构造器，彼此构成重载
  • 一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器（用到时就写空参构造器，否则不写）
  • 一个类中，至少会有一个构造器
  • 构造器的权限和类的权限相同

public class PersonTest {

	public static void main(String[] args) {
		//创建类的对象:new + 构造器
		Person p = new Person();//Person()这就是构造器
		
		p.eat();
		
		Person p1 = new Person("Tom");
		System.out.println(p1.name);
	}
}
class Person{
	
	String name;
	int age;
	
	//构造器
	public Person(){//系统默认
		System.out.println("Person()......");
	}
	
	public Person(String n){//name是p1的，谁调用就是谁的
		name = n;
	}
	
	public Person(String n,int a){//构造器的重载，类似方法重载
		name = n;
		age = a;
	}
	
	//方法
	public void eat(){
		System.out.println("人吃饭");
	}

}

6.2、总结属性赋值的过程

属性赋值的先后顺序

• ① 默认初始化值
• ② 显式初始化
• ③ 构造器中赋值
• ④ 通过"对象.方法" 或 “对象.属性”的方式，赋值

以上 *** 作的先后顺序:① - ② - ③ - ④

public class UserTest {

	public static void main(String[] args) {
		User u = new User();
		
		System.out.println(u.age);
		
		User u1 = new User(2);//③ 构造器中赋值
		
		u1.setAge(3);//④ 通过"对象.方法" 或 “对象.属性”的方式，赋值
		
		System.out.println(u1.age);
	}
}
class User{
	String name;//① 默认初始化值
	int age = 1;//②显式初始化
	
	public User(){
		
	}
	
	public User(int a){//构造器
		age = a;
	}
	
	public void setAge(int a){
		age = a;
	}
}

6.3、JavaBean 的使用

• JavaBean 是一种 Java 语言写成的可重用组件
• 所谓 javaBean，是指符合如下标准的 Java 类：
  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的 get、set 方法

public class Customer {
	
	private String name;

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

6.4、UML 类图

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

6.5、练习

练习 1

【题目描述】

在Person类中添加构造器，
1.利用构造器设置所有人的 age 属性初始值都为 18
2.利用构造器使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值

【代码实现】

class Person {

	private int age;
	private String name;
	
	public Person(){
		age = 18;
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}
	
	public void setName(String n){
		name = n;
	}
	
	public String getName(){
		return name;
	}
	
	public void setAge(int a){
		if(a < 0 || a > 130){
//			throw new RuntimeException("传入的数据据非法");
			System.out.println("传入的数据据非法");
			return;
		}
		age = a;
	}
	
	public int getAge(){
		return age;
	}
}

public class PersonTest {

	public static void main(String[] args) {
		
		Person p2 = new Person("Tom",21);
		
		System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());
	}
}

练习 2

【题目描述】

编写两个类，TriAngle 和 TriAngleTest，
其中 TriAngle 类中声明私有的底边长 base 和高 height，同时声明公共方法访问私有变量。
此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。

【代码实现】

public class TriAngle {

	private double base;//底边长
	private double height;//高
	
	public TriAngle(){
		
	}
	
	public TriAngle(double b,double h){
		base = b;
		height = h;
	}
	
	public void setBase(double b){
		base = b;
	}
	
	public double getBase(){
		return base;
	}
	
	public void setHeight(double h){
		height = h;
	}
	
	public double getHeight(){
		return height;
	}
}

public class TriAngleTest {

	public static void main(String[] args) {
		
		TriAngle t1 = new TriAngle();
		t1.setBase(2.0);
		t1.setHeight(2.5);
//		t1.base = 2.5;//The field TriAngle.base is not visible	
		System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());
		
		TriAngle t2 = new TriAngle(5.1,5.6);
		System.out.println("面积 : " + t2.getBase() * t2.getHeight() / 2);
	}
}

7、this关键字 7.1、this 调用属性、方法、构造器

this 关键字的使用

• this 用来修饰、调用：属性、方法、构造器
• this 修饰属性和方法——this 理解为：当前对象,或当前正在创建的对象（当前对象：谁调用就是谁）
  • 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性和方法。通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
  • 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用正在创建的对象属性和方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
• this 调用构造器
  • 我们可以在类的构造器中，显式的使用"this(形参列表)"的方式，调用本类中重载的其他的构造器
  • 构造器中不能通过"this(形参列表)"的方式调用自己。
  • 如果一个类中声明了n个构造器，则最多有n -1个构造器中使用了"this(形参列表)"。
  • "this(形参列表)"必须声明在类的构造器的首行
  • 在类的一个构造器中，最多只能声明一个"this(形参列表)"。

public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		
		p1.setAge(1);
		System.out.println(p1.getAge());
		
		p1.eat();
		
		System.out.println();
		
		Person p2 = new Person("Jerry",20);
		System.out.println(p2.getAge());
	}
}

class Person{
	
	private String name;
	private int age;
	
	public Person(){
		this.eat();//调用方法
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}
	
	public Person(String name){
		this();//调用无参构造器
		this.name = name;
	}
	
	public Person(int age){
		this();//调用无参构造器
		this.age = age;
	}
	
	public Person(String name,int age){
		this(age);//调用构造器3
		this.name = name;
		//this.age = age;
		//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
		this.study();
	}
	public void study(){
		System.out.println("人学习");
	}
}

7.2、练习

练习1

【题目描述】

【代码实现】

public class Boy {

	private String name;
	private int age;
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	public Boy(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public void marry(Girl girl){
		System.out.println("我想娶" + girl.getName());
	}
	
	public void shout(){
		if(this.age >= 22){
			System.out.println("可以考虑结婚");
		}else{
			System.out.println("好好学习");
		}
	}
}

public class Girl {
	
	private String name;
	private int age;
	
	public Girl() {
        
	}
	public Girl(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
    
	public void marry(Boy boy){
		System.out.println("我想嫁给" + boy.getName());
		boy.marry(this);
	}
	
	/**
	 * 
	 * @Description 比较两个对象的大小，只能比较具体数值，比较地址无意义
	 * @author shkstart
	 * @date 2019年1月18日下午4:02:09
	 * @param girl
	 * @return  正数：当前对象大；  负数：当前对象小  ； 0：当前对象与形参对象相等
	 */
	public int compare(Girl girl){
//		if(this.age > girl.age){
//			return 1;
//		}else if(this.age < girl.age){
//			return -1;
//		}else{
//			return 0;
//		}
		//或者		
		return this.age - girl.age;
	}
}

public class BoyGirlTest {

	public static void main(String[] args) {
		
		Boy boy = new Boy("罗密欧",21);
		boy.shout();
		
		Girl girl = new Girl("朱丽叶", 18);
		girl.marry(boy);
		
		Girl girl1 = new Girl("祝英台", 19);
		int compare = girl.compare(girl1);
		if(compare > 0){
			System.out.println(girl.getName() + "大");
		}else if(compare < 0){
			System.out.println(girl1.getName() + "大");
		}else{
			System.out.println("一样的");
		}
	}
}

练习2

【题目描述】

实验1：Account_Customer.pdf

【代码实现】

public class Account {
	private int id;//账号
	private double balance;//余额
	private double annualInterestRate;//年利率
	
	public Account (int id, double balance, double annualInterestRate ){//创建账户时直接规定账号 余额 年利率
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}

	public double getAnnualInterestRate() {
		return annualInterestRate;
	}
	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
    
	//在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
	public void withdraw (double amount){//取钱
		if(balance < amount){
			System.out.println("余额不足，取款失败");
			return;
		}
		balance -= amount;
		System.out.println("成功取出：" + amount);
	}
	
	public void deposit (double amount){//存钱
		if(amount > 0){
			balance += amount;
			System.out.println("成功存入：" + amount);
		}
	}
}

public class Customer {
	
	private String firstName;//名
	private String lastName;//性
	private Account account;//注意是Account类型，顾客需要开账户时用Customer类型的对象调用setAccount()方法来为顾客添加账户
	
	public Customer(String f,String l){//创建对象时直接起名字
		this.firstName = f;
		this.lastName = l;
	}

	public Account getAccount() {
		return account;
	}
	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}

	public String getLastName() {
		return lastName;
	}
}

/*
写一个测试程序。
（1）	创建一个Customer ，名字叫 Jane Smith, 
他有一个账号为1000，余额为2000元，年利率为 1.23％ 的账户。
（2）	对Jane Smith *** 作。
存入 100 元，再取出960元。再取出2000元。
打印出Jane Smith 的基本信息

成功存入 ：100.0
成功取出：960.0
余额不足，取款失败
Customer [Smith, Jane] has a account: id is 1000, 
annualInterestRate is 1.23％, balance is 1140.0
 */
public class CustomerTest {
	public static void main(String[] args) {
		Customer cust = new Customer("Jane", "Smith");//造一个顾客
		
		Account acct = new Account(1000, 2000, 0.0123);//造一个账户
		
		cust.setAccount(acct);//顾客开账户
		
        //存钱                               //存钱方法在Account类中
//		Account account = cust.getAccount();//1.顾客存钱，顾客先得到自己的账户对象
//		account.deposit(100);               //2.用账户对象调用存钱方法
		//或者
		cust.getAccount().deposit(100);
        
		cust.getAccount().withdraw(960);
		cust.getAccount().withdraw(2000);
		
		System.out.println("Customer[" + cust.getLastName() + "," + cust.getFirstName() + 
				"] has a account: id is " + cust.getAccount().getId() + ",annualInterestRate is "+
		cust.getAccount().getAnnualInterestRate() * 100 + "% ,balance is " + cust.getAccount().getBalance());
	}
}

练习3

【题目描述】

实验2：Account_Customer_Bank.pdf

【代码实现】

public class Account {

	private double balance;

	public double getBalance() {
		return balance;
	}

	public Account(double init_balance){//创建账户时存的余额
		this.balance = init_balance;
	}
	
	//存钱 *** 作
	public void deposit(double amt){
		if(amt > 0){
			balance += amt;
			System.out.println("存钱成功");
		}
	}
	
	//取钱 *** 作
	public void withdraw(double amt){
		if(balance >= amt){
			balance -= amt;
			System.out.println("取钱成功");
		}else{
			System.out.println("余额不足");
		}
	}
}

public class Customer {

	private String firstName;
	private String lastName;
	private Account account;//理解同上
	
	public Customer(String f, String l) {
		this.firstName = f;
		this.lastName = l;
	}

	public Account getAccount() {
		return account;
	}
	public void setAccount(Account account) {
		this.account = account;
	}

	public String getFirstName() {
		return firstName;
	}
    
	public String getLastName() {
		return lastName;
	}
}

public class Bank {

	private Customer[] customers;// 存放多个客户的数组
	private int numberOfCustomers;// 记录客户的个数

	public Bank() {
		customers = new Customer[10];
	}

	// 添加客户
	public void addCustomer(String f, String l) {
		Customer cust = new Customer(f, l);//
		// customers[numberOfCustomers] = cust;
		// numberOfCustomers++;
		// 或
		customers[numberOfCustomers++] = cust;
	}

	// 获取客户的个数
	public int getNumOfCustomers() {
		return numberOfCustomers;
	}

	// 获取指定位置上的客户
	public Customer getCustomer(int index) {
		// return customers[index];//可能报异常
		if (index >= 0 && index < numberOfCustomers) {
			return customers[index];
		}
		return null;
	}
}

public class BankTest {
	public static void main(String[] args) {
		
		Bank bank = new Bank();//1.先创建银行对象
		
		bank.addCustomer("Jane", "Smith");//2.添加客户
		
		//连续 *** 作
		bank.getCustomer(0).setAccount(new Account(2000));//用bank.getCustomer(0)先找到顾客，顾客开账户
		
		bank.getCustomer(0).getAccount().withdraw(500);//取500
		
		double balance = bank.getCustomer(0).getAccount().getBalance();//打印余额
		System.out.println("客户：" + bank.getCustomer(0).getFirstName() + "的账户余额为：" + balance);
		
		System.out.println("***********************");
		bank.addCustomer("万里", "杨");
		
		System.out.println("银行客户的个数为：" + bank.getNumOfCustomers());
	}
}

8、package、import关键字 8.1、package关键字

package 关键字的使用

• 为了更好的实现项目中类的管理，提供包的概念
• 使用 package 声明类或接口所属的包，声明在源文件的首行
• 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
• 每“.”一次,就代表一层文件目录。
• 补充：
  • 同一个包下，不能命名同名接口或同名类
  • 不同包下，可以命名同名的接口、类。

JDK 中主要的包介绍

• java.lang----包含一些 Java 语言的核心类，如 String、Math、Integer、System 和 Thread，提供常用功能
• java.net----包含执行与网络相关的 *** 作的类和接口
• java.io----包含能提供多种输入/输出功能的类
• java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数
• java.text----包含了一些 java 格式化相关的类
• java.sql----包含了 java 进行 JDBC 数据库编程的相关类/接口
• java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。B/S C/S

8.2、import关键字

import关键字的使用

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

package com.atguigu.java2;

import java.lang.reflect.Field;
import java.util.*;

import com.atguigu.exer4.Account;
import com.atguigu.exer4.Bank;
import com.atguigu.java2.java3.Dog;

import static java.lang.System.*;
import static java.lang.Math.*;

public class PackageImportTest {
	public static void main(String[] args) {
		
		String info = Arrays.toString(new int[]{1,2,3});
		
		Bank bank = new Bank();
		
		ArrayList list = new ArrayList();
		HashMap map = new HashMap();
		
		Scanner s = null;
		
		System.out.println("hello!");
		
		Person p = new Person();
		
		Account acct = new Account(1000);
		//全类名的方式显示
		com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123);
		
		Date date = new Date();
		java.sql.Date date1 = new java.sql.Date(5243523532535L);
		
		Dog dog = new Dog();
		
		Field field = null;
		
		out.println("hello");
		
		long num = round(123.434);
	}
}