Java基础学习-day8，day9，day10（面向对象的学习）
1、面向对象
学习面向对象的三条主线：
1、类和类的成员（属性、方法、构造器、代码块、内部类）
2、面向对象的三大特征：封装、继承、多态、(抽象性)
3、其他关键字：super、this、static、final、abstract、interface、、、
2、面向过程VS 面向对象
例子：人把大象装进冰箱
3、类和对象
4、类和类的成员
设计类就是设计类的成员
package com.chb.day08;
/*
* 一、设计类，其实就是设计类的成员
*
* 属性 = 成员变量 = field = 域、字段
* 方法 = 成员方法 = 函数 = method
*
* 创建类的对象 = 类的实例化 = 实例化类
*
* 二、类和对象的使用（面向对象思想落地的实现）：
* 1.创建类，设计类的成员
* 2.创建类的对象
* 3.通过“对象.属性”或“对象.方法”调用对象的结构
*
* 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
* 意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
*
* 四、对象的内存解析
*/
//测试类
public class PersonTest {
public static void main(String[] args) {
// 2. 创建Person类的对象
Person p1 = new Person();
// 调用对象的结构：属性、方法
// 调用属性：“对象.属性”
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(p1.age);//10
}
}
//1.创建类，设计类的成员
class Person {
// 属性
String name;
int age = 1;
boolean isMale;
// 方法
public void eat() {
System.out.println("人可以吃饭");
}
public void sleep() {
System.out.println("人可以睡觉");
}
public void talk(String language) {
System.out.println("人可以说话,使用的是：" + language);
}
}
运行结果：
5、对象的创建和使用
（1）类的成员之一：属性
package com.chb.day08;
/*
* 类中属性的使用
*
* 属性（成员变量） 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("中文");
u1.eat();
}
}
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);
}
}
运行结果：
（2）类的成员之二：方法
package com.chb.day08;
/*
* 类中方法的声明和使用
*
* 方法：描述类应该具有的功能。
* 比如：Math类：sqrt()\random() \...
* Scanner类：nextXxx() ...
* Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
*
* 1.举例：
* public void eat(){}
* public void sleep(int hour){}
* public String getName(){}
* public String getNation(String nation){}
*
* 2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
* 注意：static、final、abstract 来修饰的方法，后面再讲。
*
* 3. 说明：
* 3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
* Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说
*
* 3.2 返回值类型： 有返回值 vs 没有返回值
* 3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
* return关键字来返回指定类型的变量或常量：“return 数据”。
* 如果方法没有返回值，则方法声明时，使用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关键字后面不可以声明执行语句。
*
* 5. 方法的使用中，可以调用当前类的属性或方法
* 特殊的：方法A中又调用了方法A:递归方法。
* 方法中，不可以定义方法。
*/
public class CustomerTest {
public static void main(String[] args) {
Customer c1=new Customer();
c1.eat();
c1.sleep(5);
}
}
class Customer {
// 属性
String name;
int age;
boolean isMale;
// 方法
public void eat() {
System.out.println("客户吃饭");
return;
// return后不可以声明表达式
// System.out.println("hello");
}
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;
}
}
package com.chb.day08;
/*
* 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
生成随机数：Math.random()，返回值类型double;
*/
public class StudentTest {
public static void main(String[] args) {
Student[]student=new Student[20];
for (int i = 0; i < student.length; i++) {
//给数组元素赋值
student[i]=new Student();//少了这个会出现空指针异常
//number
student[i].number=(i+1);
//年级：[1,6]
student[i].state=(int) (Math.random()*6+1);
//成绩：[0,100]
student[i].score=(int) (Math.random()*101);
}
//打印出3年级(state值为3）的学生信息。
StudentTest.searchState(student, 3);
System.out.println("================================================================");
StudentTest.maopao(student);
//打印
for (int i = 0; i < student.length; i++) {
System.out.println(student[i].toString());
}
}
public static void searchState(Student[] student,int state){
for(int i = 0;i <student.length;i++){
if(student[i].state == state){
System.out.println(student[i].toString());
}
}
}
public static void maopao(Student []student) {
for (int i = 0; i < student.length; i++) {
for (int j = 0; j < student.length-i-1; j++) {
if(student[j].score>student[j+1].score) {
//如果需要换序，交换的是Student对象,不是score！！！
Student temp=student[j];
student[j]=student[j+1];
student[j+1]=temp;
}
}
}
}
}
class Student{
int number;
int state;
int score;
@Override
public String toString() {
return "Student [number=" + number + ", state=" + state + ", score=" + score + "]";
}
}
运行结果：
package com.chb.day09;
/*
* 一、理解“万事万物皆对象”
* 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().price = 1999;
new Phone().showPrice();//0.0,不是1999是因为他们不是同一个对象
PhoneFactor p1=new PhoneFactor();
p1.show(new Phone()); //匿名对象的使用
}
}
class PhoneFactor{
public void show(Phone p) {
p.sendMessage();
p.PlayGame();
}
}
class Phone {
double price;// 价格
public void sendEmail() {
System.out.println("发送邮件");
}
public void playGame() {
System.out.println("玩游戏");
}
public void showPrice() {
System.out.println("手机价格为：" + price);
}
}
代码小练
package com.chb.day09;
/*
* 自定义数组的工具类
*
*/
public class ArrayUtil {
// 求数组的最大值
public static int getMax(int[]a) {
int max=a[0];
for (int i = 1; i < a.length; i++) {
if(a[i]>max) {
max=a[i];
}
}
return max;
}
// 求数组的最小值
public static int getMin(int[]a) {
int min=a[0];
for (int i = 1; i < a.length; i++) {
if(a[i]<min) {
min=a[i];
}
}
return min;
}
// 求数组的总和
public static int getSum(int[]a) {
int sum=0;
for (int i = 0; i < a.length; i++) {
sum+=a[i];
}
return sum;
}
// 求数组的平均值
public static int getAvg(int[]a) {
return getSum(a)/a.length;
}
// 复制数组
public static int[] copy(int[]a) {
int []b=new int[a.length];
for (int i = 0; i < a.length; i++) {
b[i]=a[i];
}
return b;
}
// 数组排序
public static void sort(int[]a) {
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length-i-1; j++) {
if(a[j]>a[j+1]) {
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
// 反转数组
public static void reverse(int[]a) {
for (int i = 0; i < a.length/2; i++) {
int temp = a[i];
a[i]=a[a.length-i-1];
a[a.length-i-1]=temp;
}
}
// 遍历数组
public static void show(int[]a) {
for (int i : a) {
System.out.print(i+" ");
}
System.out.println();
}
// 查找指定元素
public static int getIndex(int[]a,int dest) {
for (int i = 0; i < a.length; i++) {
if(a[i]==dest) {
return i;
}
}
return -1;//返回一个负数，表示没有找到
}
}
package com.chb.day09;
public class ArrayUtilTest {
public static void main(String[] args) {
int[] arr = new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
int max=ArrayUtil.getMax(arr);
System.out.println("最大值为"+max);
int min=ArrayUtil.getMin(arr);
System.out.println("最大值为"+min);
int sum=ArrayUtil.getSum(arr);
System.out.println("总和为"+sum);
int avg=ArrayUtil.getAvg(arr);
System.out.println("平均数和为"+avg);
int[]b=ArrayUtil.copy(arr);//复制数组
ArrayUtil.show(b);//打印
ArrayUtil.reverse(arr);//反转
ArrayUtil.show(arr);
ArrayUtil.sort(arr);
ArrayUtil.show(arr);
}
}
运行结果：
方法的重载：
package com.chb.day09;
/*
* 方法的重载（overload） loading...
*
* 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
*
* "两同一不同":同一个类、相同方法名
* 参数列表不同：参数个数不同，参数类型不同
*
* 2. 举例：
* Arrays类中重载的sort() / binarySearch()
*
* 3.判断是否是重载：
* 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
*
* 4. 在通过对象调用方法时，如何确定某一个指定的方法：
* 方法名 ---> 参数列表
*/
public class testOverload {
public static int max(int a,int b) {
return (a>b)?a:b;
}
public static double max(double a,double b) {
return (a>b)?a:b;
}
public static double max(double a,double b,double c) {
double max=(a>b)?a:b;
return (max>c)?max:c;
}
public static void main(String[] args) {
System.out.println(max(1,2));
System.out.println(max(2.0,1.0));
System.out.println(max(2.0,1.0,3.0));
}
}
运行结果
可变个数的形参
package com.chb.day09;
/*
* 可变个数形参的方法
*
* 1.jdk 5.0新增的内容
* 2.具体使用：
* 2.1 可变个数形参的格式：数据类型 ... 变量名
* 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
* 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
* 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
* 2.5 可变个数形参在方法的形参中，必须声明在末尾
* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
*
*/
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest t = new MethodArgsTest();
t.show(new String[]{"AA","BB","CC"});
}
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) {
//
// }
}
方法参数的值传递机制
package com.chb.day09;
/*
关于变量的赋值：
* 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
* 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
*/
public class test1 {
public static void main(String[] args) {
int m=10;
int n=m;
System.out.println("m="+m+",n="+n);
n=20;
System.out.println("m="+m+",n="+n);
Teacher s1=new Teacher();
s1.id=1001;
Teacher s2=s1;//s1和s2的地址值相同
System.out.println("s1.id="+s1.id+",s2.id="+s2.id);
s2.id=1002;
System.out.println("s1.id="+s1.id+",s2.id="+s2.id);
}
}
class Teacher{
int id;
}
运行结果：
package com.chb.day09;
/*
* 方法的形参的传递机制：值传递
*
* 1.形参：方法定义时，声明的小括号内的参数
* 实参：方法调用时，实际传递给形参的数据
*
* 2.值传递机制：
* 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
* 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
*
*/
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
//交换两个变量的值的操作
// int temp=m;
// m=n;
// n=temp;
// System.out.println("m = " + m + ", n = " + n);//m = 20, n = 10
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20没有换成,输出的是main方法中的，不是swap中的
}
//写成方法
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
}
}
package com.chb.day09;
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 = 10, n = 20
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);//m = 20, n = 10
}
public void swap(Data data) {
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data {
int m;
int n;
}
凡是交换两个数的，如果将其写成了方法，应该用引用数据类型（将其设计在类中）
递归：
package com.chb.day8;
//求n！
public class testdigui {
public static int digui(int n) {
if(n==1||n==0) {
return 1;
}else {
return n*digui(n-1);
}
}
public static void main(String[] args) {
System.out.println(digui(5));
}
}
（3）类的成员之三：构造方法（构造器）
package com.chb.day10;
/*
* 类的结构之三：构造器（或构造方法、constructor）的使用
* 一、构造器的作用：
* 1.创建对象
* 2.初始化对象的信息
*
* 二、说明：
* 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
* 2.定义构造器的格式：权限修饰符 类名(形参列表){}
* 3.一个类中定义的多个构造器，彼此构成重载
* 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
* 5.一个类中，至少会有一个构造器。
*/
public class PersonTet {
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("人可以学习");
}
}
运行结果：
属性赋值的顺序：
package com.chb.day10;
public class UserTest {
public static void main(String[] args) {
User u=new User();
u.setAge(4);//对象.方法初始化
System.out.println(u.getAge());
}
}
class User{
//private int age;//默认初始化
private int age=2;//显示初始化
public User(){
age=3;//构造器初始化
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
运行结果是 4
面向对象的特征之一：封装
封装性的几个体现：
1.私有化属性
2.不对外暴露的私有方法
3.构造器私有化（单例模式）
package com.chb.day10;
public class Animal {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.chb.day10;
/*
* 面向对象的特征一：封装与隐藏 3W:what? why? how?
* 一、问题的引入：
* 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
* 属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
* 加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
* 同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
* -->此时，针对于属性就体现了封装性。
*
* 二、封装性的体现：
* 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
*
* 拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 ...
*
*
* 三、封装性的体现，需要权限修饰符来配合。
* 1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
* 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
* 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
* 修饰类的话，只能使用：缺省、public
*
* 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
*
*/
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.legs = -4;
// a.setLegs(6);
a.setLegs(-6);
// a.legs = -4;//The field Animal.legs is not visible
a.show();
System.out.println(a.name);
}
}
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;
}
}
this关键字
用来指代当前对象或当前正在创建的对象（构造器），用来修饰属性和方法、调用构造器（this（））。一般都会省略掉，当方法形参和属性名相同时，this不能省掉。
package com.chb.day10;
/*
* 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 PersonTest1 {
public static void main(String[] args) {
Person1 p = new Person1();
p.setAge(1);
System.out.println(p.getAge());
}
}
class Person1 {
private String name;
private int age;
public Person1() {
this.eat();
}
public Person1(String name){
this();
this.name = name;
}
public Person1(int age){
this();
this.age = age;
}
public Person1(String name,int age){
this(age);
this.name = name;
}
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 eat() {
System.out.println("人吃饭");
this.study();
}
public void study() {
System.out.println("人学习");
}
}
package com.chb.day10;
public class Boy {
private String name;
private int age;
public Boy() {
}
public Boy(String name) {
this.name = name;
}
public Boy(String name, int age) {
this.name = name;
this.age = 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.chb.day10;
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;
}
}
package com.chb.day10;
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("一样大");
}
}
}
package和import关键字
代码练习
练习一
package com.chb.exe1;
public class Customer {
private String firstName ;
private String lastName ;
private Account account ;
public Customer(String firstName, String lastName) {
super();
this.firstName = firstName;
this.lastName = lastName;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
}
package com.chb.exe1;
public class Account {
private double balance ;
public Account( double balance) {
this.balance = balance;
}
public double getBalance() {
return balance;
}
//取钱
public void withdraw (double amount) {
if(balance<amount) {
System.out.println("余额不足，取款失败 ");
return;
}
balance-=amount;
System.out.println("成功取出"+amount);
}
//存钱
public void deposit (double amount) {
balance+=amount;
System.out.println("成功存入"+amount);
}
}
package com.chb.exe1;
public class Bank {
private Customer[]customers=new Customer[10] ;
private int numberOfCustomer;
public Bank() {
}
//添加客户
public void addCustomer(String f,String l) {
customers[numberOfCustomer++]=new Customer(f, l);
}
//获取客户个数
public int getNumberOfCustomer() {
return numberOfCustomer;
}
//返回指定位置客户
public Customer getCustomer(int index) {
if(index>=0&&index<numberOfCustomer) {
return customers[index];
}
return null;
}
}
package com.chb.exe1;
public class Test {
public static void main(String[] args) {
Bank bank=new Bank();
bank.addCustomer("王", "老");
Account acct=new Account(2000);
bank.getCustomer(0).setAccount(acct);
bank.getCustomer(0).getAccount().withdraw(500);//取500
double balance=bank.getCustomer(0).getAccount().getBalance();//余额
System.out.println(balance);
bank.addCustomer("四", "李");
int sum=bank.getNumberOfCustomer();//客户个数
System.out.println("银行现在有"+sum+"个客户");
}
}
运行结果：
练习二
package com.chb.day10;
public class Account {
private int id;//账号
private double balance;//余额
private double annualInterestRate;//年利率
public Account(int id, double balance, double annualInterestRate) {
super();
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;
}
public void withdraw(double amount) {
if(balance<amount) {
System.out.println("余额不足，不能取钱");
}else{
balance-=amount;
System.out.println("成功取出：" + amount);
}
}
public void deposit (double amount){//存钱
balance+=amount;
System.out.println("成功存入：" + amount);
}
}
package com.chb.day10;
public class Customer1 {
private String firstName;
private String lastName;
private Account account;
public Customer1(String firstName, String lastName) {
super();
this.firstName = firstName;
this.lastName = lastName;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
}
package com.chb.day10;
public class CustomerTest {
public static void main(String[] args) {
Customer1 cust = new Customer1("Jane", "Smith");
Account acct = new Account(1000, 2000, 0.0123);
cust.setAccount(acct);
cust.getAccount().deposit(100);//或者把cust.getAccount()换成acct
cust.getAccount().withdraw(960);//或者把cust.getAccount()换成acct
cust.getAccount().withdraw(2000);//或者把cust.getAccount()换成acct
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());
}
}
运行结果：
