4、Java面向对象（上）

最新推荐文章于 2024-05-28 09:25:21 发布

com.li

最新推荐文章于 2024-05-28 09:25:21 发布

阅读量180

点赞数

分类专栏： java 文章标签： java python 开发语言

本文链接：https://blog.csdn.net/LIJINGPO/article/details/132026108

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

4、面向对象（上）：

(一).面向对象三条主线：
1.Java类及类的成员：属性、方法、构造器；代码块、内部类
2.面向对象的三大特征：封装性、多态性、继承性、(抽象性)。
3.其他关键字：this、super、static、final、abstract、interface、package、import。

面向过程（POP）与面向对象（OOP）：

二者都是一种思想，面向对象是相对于面向过程而言的。
面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
面向对象：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向对象思想概念：
类（class）和对象（object）是面向对象的核心概念。
类：是一类事物的描述，是抽象的概念上的定义。
对象：是实际存在的该类事务的每个个体，因而也称为实例（万事万物皆对象）

jvm内存结构：《JVM规范》
编译完源程序以后，生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要
将字节码文件对应的类加载到内存中，涉及到内存解析。

虚拟机栈，即为平时提到的栈的结构。我们将局部变量存储在栈结构中
堆：我们将new出来的结构（比如：数组、对象）加载在堆空间中。补充：对象的属性（非static）加载在堆空间中。
方法区：类的加载信息、常量池、静态域。

封装和隐藏（高内聚，低耦合）
高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
低耦合：仅对外暴露少量的方法用于使用
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。
即就是把该隐藏的隐藏起来，该暴露的暴露出来即为封装的设计思想。
二.“人把对象装进冰箱”方面来理解面向对象和面向过程

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

① 把冰箱打开

② 抬起大象，塞进冰箱

③ 把冰箱门关闭

2.面向对象：将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

人{
	打开（冰箱）{
	冰箱.开开（）； 
}

抬起（大象）{
	大象.进入（冰箱）{

	}
}



冰箱{

开开（）{}

闭合（）{}	

}

大象{

进入（冰箱）{

}

}

}

（一）、面向对象的两个要素

三：面向对象的两个要素：

类：是一类事物的描述，是抽象的概念上的定义。

对象：是实际存在的该类事务的每个个体，因而也称为实例（万事万物皆对象）

面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。
public class OOPTest {
}

package com.li.java;
/*

类中方法的声明和使用

方法：描述类应该有的功能。

比如：Math类，sqrt()\random()\……

Scanner类，nextXxx()…

Array类,sort()\binarySearch()\toString()\equals()…

1.举例：

public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){} 

注：void 没有返回值；String 有返回值

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

public class CuetomerTest {
}
//客户
class Customer{
//属性
String name;
int age;
boolean isMale;

//方法
public void eat(){
	System.out.println("客户吃饭");
}

public void sleep(int hour) {
	System.out.println("休息了" + hour + "小时");
}

public String getName() {
	return name;
}

public String getNation(String nation) {
	String info = "我的国籍是" + nation;
	return info;
}
}

一、设计类：其实就是设计类的成员

属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的方法 = 类的实例化 = 实例化类
二、类和对象的使用（面向对象思想落地的实现）
1.创建类，设计类的成员
2.创建类的对象
3.通过“对象.属性”或“对象.方法”调用对象的结构
三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着，如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
四、对象的内存解析
堆：（Heap），在内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
栈：（Stack）通常所说栈，是指虚拟机栈，虚拟机栈用于存放局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（Boolean、byte、char、 short、int、foat、long、double）、对象引用（reference类型，他不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
方法区：（Method Aree）,用于存储已被虚拟机加载的信息类、常量、静态变量、即时编译器编译后的代码等数据。

	//测试类
public class PersonTest {
	public static void main(String[] args) {
		//创建Person类的对象
		Person p1 = new Person();
		//Scanner scanner = new Scanner(System.in);
	//调用对象的结构，属性、方法
	//调用属性：“对象.属性”
	p1.name = "Tom";
	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
	System.out.println(p2.isMale);//false
	
	//***********************************
	//将p1变量保存的对象地址值赋给p3，导致p1和p3共同拥有了堆空间的同一个对象实体
	Person p3 = p1;
	System.out.println(p3.name);//Tom
	
	p3.age = 10;
	System.out.println(p3.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);
}
}

（二）、类中属性的一个使用

属性（成员变量） 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);
		System.out.println(u1.age);
		System.out.println(u1.isMale);
u1.talk("日语");
	}
}

class User{
	String name ;
	int age;
	boolean isMale;
public void talk(String language) {   //language:形参，局部变量
	System.out.println("我们使用" + language + "进行交流");
}

public void eat() {
	String food = "烙饼";//局部变量
	System.out.println("北方人喜欢吃" + food);
}
}

	package com.li.exer;
/*
- 2.利用面向对象的编程方法，设计类Circle计算园的面积。
  */
//测试类
public class CircleTest {
	public static void main(String[] args) {
	Circle c1 = new Circle();	
	c1.radius = 2.1;
	//对应方式一：
	//		double area = c1.findArea();
//		System.out.println(area);
//对应方式二：
	c1.findArea();	
	}
}
//
class Circle{
	//属性
	double radius;
	//求园的面积
//方式一：
//	public double findArea() {
//		double area = Math.PI * radius * radius;
//		return area;
//	}
	//方式二：
	public void findArea() {
		double area = Math.PI * radius * radius;
		System.out.println("面积为：" + area);
	}	
}

package com.li.exer;
/*

- 3.1编写程序，声明一个method方法，在方法中打印一个10*8的“*”矩形，在main方法中调用该方法。
- 3.2修改上一个程序，在method方法中，除打印一个10*8的“*”矩形外，再计算该矩形面积，并将其作为方法返回值。在main方法中调
- 用该方法，接收返回的面积值并打印。
- 3.3修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，并计算该矩形的面积，将其作为方法返回值。在main方
- 法中调用该方法，接受返回的面积值并打印。
   */

public class Exer3Test {
	public static void main(String[] args) {
		Exer3Test test = new Exer3Test();
//3.1测试
//		test.method();
//3.2测试
	//方式一：
//		int area = test.method();
//		System.out.println("面积为" + area);
		//方式二：
//		System.out.println(test.method());
//3.3测试
	int area = test.method(12, 10);
	System.out.println("面积为" + area);
}
//3.1
//	public void method() {
//		for (int i = 0; i < 10; i++) {
//			for (int j = 0; j < 8; j++) {
//				System.out.print("* ");
//			}
//			System.out.println();
//		}
//	}
//3.2
//	public int method() {
//		for (int i = 0; i < 10; i++) {
//			for (int j = 0; j < 8; j++) {
//				System.out.print("* ");
//			}
//			System.out.println();
//		}
//		return 10 * 8;
//		
//	}
//3.3
public int method(int m,int n) {
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			System.out.print("* ");
		}
		System.out.println();
	}
	return m * n;
	
}
}

package com.li.exer;
/*

- 5.声明一个日期类型MyDate:有属性：年year、月month、日day。创建2个日期对象，分别赋值为：你的出生日期，

- 你对象的出生日期，并显示信息。
  */
  public class HomeTest {

  public static void main(String[] args) {
MyDate my = new MyDate();
my.year = 1999;
my.month = 07;
my.day = 31;
System.out.println("我的生日是：" + my.year + "年" + my.month + "月" + my.day + "日");

System.out.println("***************************");

MyDate myFriend = new MyDate();
myFriend.year = 2000;
myFriend.month = 11;
myFriend.day = 20;
System.out.println("我女朋友的生日是：" + myFriend.year + "年" + myFriend.month + "月" + myFriend.day + "日");
- }

}

class MyDate{
	int year;
	int month;
	int day;
}

package com.li.exer;
/*

- 创建一个Person类，其定义如下：
- 
- Person
- name:String
- age:int 
- sex:int
- +study():void
- +showAge():void
- +addAge(int i):int
- 
- 
- 要求：（1）创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”,调
- 用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
- （2）创建第一个类，执行上述操作，体会同一个类的不同对象之间的关系。
   */

public class Person {
	String name;
	int age;
	/**
	 * sex:1表明是男性
	 * sex:2表明是女性
	 */
	int sex;
public void study() {
	System.out.println("studying");
}

public void showAge() {
	System.out.println("age:" + age);
}

public int addAge(int i) {
	age += i;
	return age;
}	
}

	package com.li.exer;

/*

- 要求：（1）创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，输出字符串“studying”,调
- 用showAge()方法显示age值，调用addAge()方法给对象的age属性值增加2岁。
- （2）创建第一个类，执行上述操作，体会同一个类的不同对象之间的关系。
- */

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);
	System.out.println(p1.name + "的新年龄为：" + newAge);
	
	System.out.println(p1.age);//20
	
	//*****************************
	
	Person p2 = new Person();
	p2.showAge();//新造的对象，所以为默认值为0
	p2.addAge(10);
	p2.showAge();//10
	
	p1.showAge();
}
}

	package com.li.exer;
/*

- 4.对象数组题目：
- 定义类Student包含三个属性：学号number(int)，年级state(int)，成绩score(int).创建20个学生对象，学号由1到20，年级和成绩
- 都有随机数确定。
- 问题一：打印出3年级（stae值为3）的学生信息
- 问题二：使用冒泡排序按学生及成绩排序，并遍历所有学生信息
- 
- 提示：
- 1）生成随机数：Math.randon(),返回值类型double;
- 2）四舍五入取整：Math.round(double d),返回值类型long.
- 
- */

public class StudentTest {
	public static void main(String[] args) {
	//声明一个Student类型数组
	Student[] stus = new Student[20];
	for (int i = 0; i < stus.length; i++) {
		//给数组元素赋值
		stus[i] = new Student();
		//给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年级（stae值为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];
				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;
}
}

	package com.li.exer;
/*

- 4.对象数组题目：
- 定义类Student包含三个属性：学号number(int)，年级state(int)，成绩score(int).创建20个学生对象，学号由1到20，年级和成绩
- 都有随机数确定。
- 问题一：打印出3年级（stae值为3）的学生信息
- 问题二：使用冒泡排序按学生及成绩排序，并遍历所有学生信息
- 
- 提示：
- 1）生成随机数：Math.randon(),返回值类型double;
- 2）四舍五入取整：Math.round(double d),返回值类型long.
- 
- 
- 此代码是对StudentTest.java的改进，将操作数组的功能封装到方法中。
- */

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();
		//给Student1对象属性赋值
		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对象
		StudentTest1 test = new StudentTest1();
		//遍历学生数组
	test.print(stus);
	
	System.out.println("******************************************");	
	//		 问题一：打印出3年级（stae值为3）的学生信息
		test.searchState(stus, 3);
		System.out.println("******************************************");
		
//		问题二：使用冒泡排序按学生及成绩排序，并遍历所有学生信息
		test.sort(stus);
//遍历学生数组
		test.print(stus);
}

  private void print(Student1[] stus) {
	// TODO Auto-generated method stub
	
}

//查找Student1数组中指定年级的学生信息
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;
}
}

（三）、理解“万事万物皆对象”

	package com.li.java;
/*
- 一、理解“万事万物皆对象”
- 1.在java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
- > Scanner,String等
- > 文件，File
- > 网络资源，URL
- 2.涉及到Java语言与前端HTML、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
- 二、内存解析的说明
- 1.引用类型的变量，只可能存储两类值，null  或  地址值（含变量的类型） 
- 三、匿名对象的使用
- 1.理解；创建的对象，没有显式的赋给一个变量名，即为匿名对象
- 2.特征：匿名对象只能调用一次。
- 3.使用：
- */
public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
//		p = null;
		System.out.println(p);
	p.sendEmail();
	p.playGame();
//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
new Phone().prise = 1999;
	new Phone().showPrice();//0.0	
	//*************************
	PhoneMall mall = new PhoneMall();
//		mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());
}
}
class PhoneMall{
public void show(Phone phone) {
	phone.sendEmail();
	phone.showPrice();
}
}
class Phone{
	double prise;//价格
public void sendEmail() {
	System.out.println("发送邮件");
}
public void playGame() {
	System.out.println("玩游戏");
}

public void showPrice() {
	System.out.println("手机价格为：" + prise);
}
}

package com.li.java;
/*
- 自定义工具类
- */
public 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 sumValue = 0;
	for (int i = 0; i < arr.length; i++) {
		sumValue += arr[i];
	}
	return sumValue;
}

//求数组平均值
public int getAvg(int[] arr) {
	
	return getSum(arr) / arr.length;
}

//反转数组
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 < arr.length; i++) {
		arr1[i] = arr[i];
	}
	return arr1;
}

//数组排序
public void sort(int[] arr) {
	//冒泡排序
			for(int i = 0;i < arr.length - 1;i++) {
				for(int j = 0;j < arr.length - i - 1;j++) {
					if(arr[j] > arr[j + 1]) {
//							int temp = arr[j];
//							arr[j] = arr[j + 1];
//							arr[j + 1] = temp;
						//错误的，
//							swap(arr[j],arr[j + 1]);
swap(arr ,j,j+1);
					}
					
				}
			}
}

//错误的：交换数组中指定两个位置元素的值
//	public void swap(int i,int j) {
//		int temp = i;
//		i = j;
//		j = temp;
//	}
//正确的：交换数组中指定两个位置元素的值
	public void swap(int[] arr,int i,int j) {
		int temp = arr[j];
		arr[j] = arr[j + 1];
		arr[j + 1] = temp;
	}

//遍历数组
public void print(int[] arr) {
	for (int i = 0; i < arr.length; i++) {
		System.out.print(arr[i] + "\t");
	}
}

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

	package com.li.java;

public class ArrayUtilTest {
	public static void main(String[] args) {
	//造对象
	ArrayUtil util = new ArrayUtil();
	 int[] arr= new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
	 int max = util.getMax(arr);
	 System.out.println("最大值为：" + max);
	 
	 System.out.print("排序前：");
	 util.print(arr);		 
	 System.out.println(); 
	 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("没找到：");
//		 }
	}
}

1、可变个数形参的方法

package com.li.java1;
/*

- 可变个数形参的方法：允许直接定义和多个实参相匹配的形参。从而，可以用一种更简单的方法，来传递个数可变的实参。
- 
- 1、jdk 5.0 新增的内容
- 2.具体的使用：
- 2.1可变个数形参的格式： 数据类型 ... 变量名
- 2.2当调用可变个数形参的方法时，传入的参数个数可以是，0个，1个，或多个
- 2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
- 2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
- 2.5可变个数形参在方法的形参中，必须声明在末尾
- 2.6可变个数形参在方法的形参中，最多只能声明一个可变形参。
- 
- public void show(String ...strs) {   
- }
- public void show(String[] strs) {		
- }
- 上面两种方法不能共存。
   */

public class MethodArgsTest {
public static void main(String[] args) {
	MethodArgsTest test = new MethodArgsTest();
	test.show(12);
	test.show("hello");
}

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) {
//		
//	}
public void show(int i ,String ...strs) {//此方法要将String ...strs写到末尾
	
}
}

2、方法的重载（overload）lading…

	package com.li.java1;
/*

- 方法的重载（overload）lading...
- 
- 1.在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或参数类型不同即可。
- 
- “两同一不同”：同一个类、相同方法名
- 参数列表不同：参数个数不同，参数类型不同
- 
- 2.举例：
- Arrays类中重载的sort() / binarySearch()
- 例：
- public void reverse(int[] arr);{
- }
- public void reverse(String[] arr);{
- }
- 
- 3.判断是否是重载：
- 跟方法的权限修饰符、返回值类型、形参变量名、方法体均无关！
- 
- 4.在通过对象调用方法时，如何确定某一个指定的方法：
- ① 方法名 --> 参数列表
   */

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

//2
public void getSum(double d1,double b2) {   //若注释掉方法1，则结果为：2；即没有方法1则会执行此方法（自动类型提升）
	System.out.println("2");
}

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

//4
public void getSum(int j, String s) {
	System.out.println("4");
}
//	public int getSum(int i,int j) {   //不为方法重载，参数个数、参数类型与1相同
//		
//	}
	
//	public void getSum(int m,int n) {  //不为方法重载，参数个数、参数类型与1相同（参数名无所谓）
//		
//	}
	
//	private void getSum(int i,int j) {  //不为方法重载，参数个数、参数类型与1相同(与权限修饰符无关)
//		
//	}	
}

3、关于变量的赋值

	package com.li.java1;
/*

- 
- 关于变量的赋值：
- 
- 如果变量是基本数据类型时，此时赋值的是变量所保存的数据值。
- 如果变量是引用数据类型时，此时赋值的是变量所保存的数据的地址值。
- */

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);
	n = 20;
	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);
	//o1.orderId = 1001o2.orderId = 1001
	System.out.println("********************************");
	o2.orderId = 1002;
	System.out.println("o1.orderId = " + o1.orderId + "o2.orderId = " + o2.orderId);
	//o1.orderId = 1002o2.orderId = 1002  (地址值相同，)
}
}
class Order{
	int orderId;
}

4、方法的形参的传递机制，值传递

	package com.li.java1;
/*
- 方法的形参的传递机制，值传递
- 1.形参，方法定义时，声明的小括号内的参数
- 实参，方法调用时，实际传递给形参的数据
- 2.值传递机制：
- 如果参数是基本数据类型，此时实参赋给形参的是实参真是存在的数据类型。
- */

public class ValueTransferTest1 {
	public static void main(String[] args) {
		//交换两个变量的值的操作
		int m = 10;
		int n = 20;
	System.out.println("m = " + m + ", n = " + n);
	
	//交换两个变量的值的操作
	//		int temp = m;
//		m = n;
//		n = temp;
ValueTransferTest1 test = new ValueTransferTest1();
	test.swap(m, n);
	
	System.out.println("m = " + m + ", n = " + n);
	//m = 10, n = 20;方法中交换了，但方法执行完毕已经销毁，因此输出的是main()中的m,n
}
public void swap(int m,int n) {
	int temp = m;
	m = n;
	n = temp;
	System.out.println("m = " + m + ", n = " + n);
	//m = 20, n = 10,内部交换了，并且main()中输出的也是交换过的值
}
}

package com.li.java1;
/*

方法的形参的传递机制，值传递
1.形参，方法定义时，声明的小括号内的参数
实参，方法调用时，实际传递给形参的数据
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);
//交换m和n的值
//		int temp = data.m;
//		data.m = data.n;
//		data.m = temp;
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ",n = " + data.n);	
}
- public void swap(Data data){
  	int temp = data.m;
  	data.m = data.n;
  	data.n = temp;
  }
}
class Data{
	int m;
	int n;
}

5、递归方法

package com.li.java2;
/*

- 

- 1.递归方法：一个方法体内调用自身。
- 2.方法递归包含了一种隐式的循环，他会重复执行某段代码，但这种重复执行无需循环控制
- 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
- */
  public class RecursionTest {

  public static void main(String[] args) {
//例1，计算1-100之间自然数的和
//方式一：
int sum = 0;
for (int i = 0; i <= 100; i++) {
	sum += i;
}
System.out.println(sum);

//方式二：
RecursionTest test = new RecursionTest();
int sum1 = test.getSum(100);
System.out.println(sum1);

System.out.println("*************************");
int value = test.f(10);
System.out.println(value);

System.out.println("*************************");
int value1 = test.fib(7);
System.out.println(value1);
  }
      public int getSum(int n) {
	if(n == 1) {
		return 1;
	}else {
		return n + getSum(n - 1);
	}
}

//例2：计算1~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 f(n+2) - 2*f(n+1);//越算越大，无法计算出结果
		return 2*f(n - 1) + f(n - 2);
	}
}
//例4：输入一个数据n，计算斐波那契数列的第n个值 0 1 1 2 3 5 8 13 21 34 55
	//规律：一个数等于前两个数之和
	//要求：计算斐波那契数列的第n个值，并将整个数列打印出来
	public int fib(int n) {
		if(n == 0) {
			return 0;
		}else if(n == 1){
			return 1;
		}else {
			return fib(n - 1) + fib(n - 2);
		}
	}	
	
//例5：汉诺塔问题
	
//例6：快排
}

package com.li.exer;
/*
- 2.编写程序：定义三个重载方法并调用。方法名为mOL。
- > 三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，输出字符串信息。
- > 在主类的main()方法中分别用参数调用三个方法。
- 3.定义三个重载方法max()，第一个方法求两个 int值中的最大值，第二个方法求两个double值中的最
- 大值，第三个方法求三个double值中的最大值，并分别调用三个方法。
- */
  public class OverLoadExer {
  public static void main(String[] args) {
//2
//		OverLoadExer ol = new OverLoadExer();
//		ol.mOL(1);
//		ol.mOL("李竟坡");
//		ol.mOL(2, 2);
//3
OverLoadExer max = new OverLoadExer();
int a = max.max(2, 8);
System.out.println(a);
double b = max.max(4, 7);
System.out.println(b);
double c = max.max(5.0,9 , 11);
System.out.println(c);
}

//2.如下的三个方法构成重载
//	public void mOL(int i) {
//		System.out.println(i * i);
//	}
//	
//	public void mOL(int i,int j) {
//		System.out.println(i * j);
//	}
//	
//	public void mOL(String s) {
//		System.out.println(s);
//	}

//	3
	public int max(int i,int j) {
		return (i > j) ? i : j;
	}
	public double max(double i,double j) {
	return (i > j) ? i : j;
}

public double max(double i,double j,double k) {
	double max = (i > j) ? i : j;
	return (max > k) ? max : k;
}
}

6、将对象作为参数传递给方法

package com.li.exer1;
/*

- 将对象作为参数传递给方法
- 
- 1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积
- 2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c,int time)
- 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如：time为5，则输出半径：1，2，3，4，5，以及对应的园的面积。
- 3）在main方法中调用printAreas()方法，调用完毕后输出当前半径。
- */

public class Circle {
	double radius;//半径
//求圆的面积
public double findArea() {
	return Math.PI * radius * radius;
}
}

package com.li.exer1;

/*
- 定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c,int time)

- 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如：time为5，则输出半径：1，2，3，4，5，以及对应的园的面积。

- */
  public class PassObject {
  public static void main(String[] args) {
  	PassObject test = new PassObject();
Circle c = new Circle();
test.printAreas(c, 5);
System.out.println("now radius is " + (c.radius + 1.0));
}
public void printAreas(Circle c,int time) {
System.out.println("Radius\t\tArea");
for (int i = 1; i <= time; i++) {
c.radius = i;
double area = c.findArea();
System.out.println(c.radius + "\t\t" + area);
}
}
}

7、面向对象之一：封装与隐藏

package com.li.java;
/*
- 面向对象的特征一：封装与隐藏
- 一、问题的引入
- 当创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值。这里赋值操作要受到属性的数据类型
- 存储范围的制约。但除此之外没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。该条
- 件就不能在属性声明时体现，只能通过方法进行限制条件的添加（例：setLegs()），同时，需要避免用户再使用“对象.属性”
- 的方式对属性进行赋值。则需要将属性声明为私有的（private）。---->此时对属性就体现了封装性。 
- 二、封装性的体现
- 我们将类的属性xxx私有化（private），同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值

- 封装和隐藏（高内聚，低耦合）
   *高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
   *低耦合：仅对外暴露少量的方法用于使用

- 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。
   *即就是把该隐藏的隐藏起来，该暴露的暴露出来即为封装的设计思想。
- 拓展：封装性的体现：①如上 ② 不对外暴露私有属性方法 ③单列模式
- 三、封装性的体现需要权限修饰符来配合。
- 1.java规定的四种权限（从小到大）private、缺省、protected、public  
- 修饰符         类内部    同一个包     不同包的子类   同一个工程
- private        √
- （缺省）       √           √
- protected      √           √               √          
- public         √           √               √               √
- 对于class的权限修饰符只可以用public和default(缺省)。
- public类可以在任意地方被访问
- default类只可以被同一个包内部的类访问 
- 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
- 3.具体的4种权限都可用来修饰类的内部结构：属性、方法、构造器、内部类
- 修饰类的话只能使用：缺省、public
- 总结：Java提供了四种权限修饰符来修饰类及类的内部结构，体现类及类内部结构在调用时的可见性大小。
  */
  public class AnimalTest {
  public static void main(String[] args) {
  	Animal a = new Animal();
  	a.name = "大黄";
  //		a.age = 1;
  //		a.legs = 4;  //The field Animal.legs is not visible
  	

  ```
  a.show();
  
  a.setLegs(6);
  a.show();	
  ```

  }
  }

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() {
	System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
}

//提供关于属性age的get和set方法
public int getAge() {
	return age;
}
public void setAge(int a) {
	age = a;
}
}

package com.li.java;

public class Order {
	private int orderPrivate;
	int orderDefault;
	public int orderPublic;
	private void methodPrivate(){
	orderPrivate = 1;
	orderDefault = 2;
	orderPublic = 3;
}

void methodDefault() {
	orderPrivate = 1;
	orderDefault = 2;
	orderPublic = 3;
}

public void methodPublic() {
	orderPrivate = 1;
	orderDefault = 2;
	orderPublic = 3;
}
}

package com.li.java;

public class OrderTest {
	public static void main(String[] args) {
		

```
	Order order = new Order();
	
	order.orderDefault = 1;
	order.orderPublic = 1;
	//出了Order类之后，私有的结构就不可以被调用了


//		order.orderprivate = 1;
		


}


}

8、JavaBean

JavaBean
JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean，是指符合如下标准的Java类：
①类是公开的
②有一个无参的公开的构造器
③有属性，且有对应的get和set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且
其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户
可以认为JavaBean提供了一个随时随地的复制和粘贴的功能，而不用关心任何改变。

package com.li.java1;
/*

- JavaBean是一种Java语言写成的可重用组件。
- 所谓JavaBean，是指符合如下标准的Java类：
- ①类是公开的
- ②有一个无参的公开的构造器
- ③有属性，且有对应的get和set方法
  */

public class Customer {
	private int id;
	private String name;
	
	

```
public Customer() {
	
}

public void setId(int i) {
	id = i;
}

public int getId() {
	return id;
}

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

public String getName() {
	return name;
}
```

}

9、构造器（或构造方法、constructor）的使用

package com.li.java1;

import com.li.java.Order;

public class OrderTest {
	public static void main(String[] args) {
		Order order = new Order();
		

```
	//出了Order类所属的包之后，私有、缺省声明的结构就不可以被调用了
```

//		order.orderDefault = 1;
		order.orderPublic = 1;
		//出了Order类之后，私有的结构就不可以被调用了
//		order.orderprivate = 1;
	}
}

package com.li.java1;
/*

- 类的结构之三：构造器（或构造方法、constructor）的使用
- construct：建设、建造   construction：CCB    constructor：建设者
- 一、构造器的作用。只要造对象就得用构造器
- 1.创建对象
- 2.初始化对象的属性
- 二、说明：
- 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
- 2.定义构造器的格式：权限修饰符  类名（形参列表）{}      【类名就是构造器名】
- 3.一个类中定义多个构造器，彼此之间构成重载。
- 4.一旦我们显式的定义了类的构造器这个后，系统就不再提供默认的空参构造器。
- 5.一个类中，至少会有一个构造器
- */
  public class PersonTest {
  public static void main(String[] args) {
  	//创建类的对象：new + 构造器
  	Person p = new 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 = n;
}

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

public void eat(){
	System.out.println("人吃饭");
}

public void study() {
	System.out.println("人可以学习");
}
```

}

10、属性赋值的先后顺序

package com.li.java1;
/*

- 总结：属性赋值的先后顺序
- ①：默认初始化
- ②：显式初始化
- ③：构造器中赋值
- ④：通过“对象.方法”或“对象.属性”的方式赋值

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

public class UserTest {
	public static void main(String[] args) {
		User u = new User(0);
		
```
	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(int a) {
	age = a;
}	

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

}

11、package关键字的使用

12、MVC设计模式

13、import关键字的使用

package com.li.java2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

import com.li.exer4.Bank;

/*

- 一、package关键字的使用
- 1.为了更好的实现项目中类的管理，提供包的概念
- 2.使用package声明类或者接口所属的包，声明在源文件的首行
- 3.包，属于标识符，遵循表示符的命名规则、规范（xxxyyyzzz）、“见名知意”
- 4.每“.”一次，就代表一层文件目录

- 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
- 
- 补充：同一个包下，不能命名同名的接口、类。
- 同一个包下，可以命名同名的接口、类。
- 
- 
- 二、import关键字的使用
- import：导入
- 1.在源文件中显式的使用import结构导入指定包下的类、接口。
- 2.声明在包的声明和类的声明声明之间
- 3. 如果需要导入多个类或接口，那么就并列显式多个import语句即可
- 4. 可以使用xxx.*的方式，一次性导入xxx包下所有的类或接口。 举例：java.util.*，一次性导入util包下所有的类或接口。
- 5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
- 6. 如果调用的是本包下的，即可以省略。
- 7. 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
- 8. 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
- 9. import static组合的使用：调用指定类或接口下的静态的属性或方法
- */

public class PackageImportTest {
```java
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");
	}
	}
```

13、this关键字的使用

package com.li.java2;
/*
- this关键字的使用
- 1.this可以用来修饰、调用：属性、方法、构造器
- 2.this修饰属性和方法：
- this理解为当前对象或当前正在创建的对象
- 2.1在类的方法中，可以使用“this.属性”“this.方法”的方式，调用当前属性或方法。通常情况下，都省略“this”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性而非形参。
- 
- 2.2在类的构造器中，可以使用“this.属性”“this.方法”的方式，调用当前正在创建的属性或方法。通常情况下，都省略“this”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性而非形参。
- 
- 3.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();
  ```

  }
  }
  class Person{

  private String name;
  private int age;

  public Person() {
  	
  }

  public Person(String name) {
  	this();
  	this.name = name;
  }
  public Person(int age) {
  	this.age = age;
  }

  public Person(String name,int age) {
  	this.name = name;
  	this.age = 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 void eat() {
  	System.out.println("人吃饭");
  	this.study();
  }
  public void study() {
  	System.out.println("人学习");
  }
  }

package com.li.exer;
/*

- 1.创建程序，在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄（0~130），用getAge()返回人的年龄。
- 在PersonTest类中实例化Person类的对象b，调用setAge()和getAge()方法，体会Java的封装性。
- 
- Person
- -age.int
- +setAge(i:int)
- +getAge():int
- 
- 
- 2.1在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18.
- 2.2修改上题中类和构造器，增加name属性，使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
- Person
- -name:String
- +setName(i:String)
- +getName();String
  */

public class Person {
private int age;
private String name;

public Person() {
	age = 18;
}

public Person(String n,int a) {
	name = n;
	age = a;
}
public void setAge(int a) {
	if(a < 0 || a > 130) {
		System.out.println("传入的数据非法！");
	}else {
		age = a;
	}
}
	public int getAge() {
		return age;
	}
	
	//绝对的错误
public int doAge(int a) {
	age = a;
	return age;
}

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

package com.li.exer;
/*

在PersonTest类中实例化Person类的对象b，调用setAge()和getAge()方法，体会Java的封装性。
*/
public class PersonTest {
public static void main(String[] args) {

Person p1 = new Person();

p1.setAge(12);

System.out.println("年龄为：" + p1.getAge());
}
}

package com.li.exer1;
/*练习：

- 编写两个类TirAngle和TirAngleTest，其中TirAngle类中声明私有的底边长base和高height,同时声明
- 公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形面积。
  */
public class TirAngle {
private double base;//底边长
private double height;//高

public TirAngle() {
	
}

public TirAngle(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;
}
}

package com.li.exer1;

public class TirAngleTest {
	public static void main(String[] args) {
		TirAngle t1 = new TirAngle();
		t1.setBase(2.0);
		t1.setHeight(2.4);
		System.out.println("base:" + t1.getBase() + ",height:" + t1.getHeight());
	TirAngle t2 = new TirAngle(5.1,5.2); 
	System.out.println("base:" + t2.getBase() + ",height:" + t2.getHeight());
}
}

package com.li.exer2;

public class Boy {
private String name;
private int age;
public Boy(String name, int age) {
}

public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	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("先多谈谈恋爱~~~");
	}
}
}

package com.li.exer2;

public class BoyGirlTest {
	public static void main(String[] args) {
	Boy boy = new Boy("罗密欧",21);
	boy.shout();
	
	Girl girl = new Girl("朱丽叶",18);
	girl.marry(boy);
}
}

package com.li.exer2;

public class Girl {
private String name;
private int age;

public Girl(String name,int age) {
	this.name = name;
	this.age = 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 void marry(Boy boy) {
	System.out.println("我想嫁给" + boy.getName());
	boy.marry(this);
}

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

package com.li.exer3;

public class Account {
	private int id;//账号
	private double balance;//余额
	private double annuallnterestRate;//年利率
public Account (int id,double balance,double annuallnterestRate) {
	this.id = id;
	this.balance = balance;
	this.annuallnterestRate = annuallnterestRate;
}

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 getAnnuallnterestRate() {
	return annuallnterestRate;
}

public void setAnnuallnterestRate(double annuallnterestRate) {
	this.annuallnterestRate = annuallnterestRate;
}

//取钱
public void withdraw (double amount) {
	if(balance < amount) {
		System.out.println("对不起，您的取款失败！");
		return;
	}else {
		balance -= amount;
		System.out.println("成功取出" + amount);
	}
}

//存钱
public void deposit (double amount) {
	if(amount > 0) {
		balance += amount;
		System.out.println("您已成功存入：" + amount);
	}
}
}

package com.li.exer3;

public class Custome {
	private String firstName;
	private String lastName;
	private Account account;
public Custome(String f,String l){
	this.firstName = f;
	this.lastName = l;
}

public String getFirstName() {
	return firstName;
}
public String getLastName() {
	return lastName;
}
public Account getAccount() {
	return account;
}
public void setAccount(Account account) {
	this.account = account;
}
}

package com.li.exer3;
/*

- 写一个测试程序。
  (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 Test {
public static void main(String[] args) {
	Custome cust = new Custome("Jane", "Smith");
Account acct = new Account(1000,2000,0.0123);

cust.setAccount(acct);

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().getAnnuallnterestRate()*100  + "%" + ",  balance  is" 
+ cust.getAccount().getBalance());
}
}

package com.li.exer4;

public class Account {
private double balance;
public Account(double init_balance) {
	this.balance = init_balance;
}

public double getBalance() {
	return 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("取款失败");
	}
}
}

package com.li.exer4;

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

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

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

package com.li.exer4;

public class BankTest {
	public static void main(String[] args) {
Bank bank = new Bank();
	
bank.addCustomer("Jame", "Smith");

bank.getCustomer(0).setAccount(new Account(2000));

bank.getCustomer(0).getAccount().withdraw(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());
}
}

package com.li.exer4;

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 String getFirstName() {
	return firstName;
}
public String getLastName() {
	return lastName;
}
public Account getAccount() {
	return account;
}
public void setAccount(Account acct) {
	this.account = acct;
}
}

com.li

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
4、Java面向对象（上）

局部变量表存放了编译期可知长度的各种基本数据类型（Boolean、byte、char、 short、int、foat、long、double）、对象引用（reference类型，他不等同于对象本身，是对象在堆内存的首地址）。”表示结束此方法的意思。3.其他关键字：this、super、static、final、abstract、interface、package、import。方法区：（Method Aree）,用于存储已被虚拟机加载的信息类、常量、静态变量、即时编译器编译后的代码等数据。
复制链接

扫一扫