第四章、面向对象（2）

最新推荐文章于 2024-05-16 20:42:16 发布
最新推荐文章于 2024-05-16 20:42:16 发布
阅读量888 收藏 3
点赞数 1
分类专栏： java基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43943214/article/details/122744212
版权

目录

前言

一、再谈方法

1、方法的重载

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

     	"两同一不同":同一个类、相同方法名
     参数列表不同：参数个数不同，参数类型不同

  2. 举例：Arrays类中重载的sort() / binarySearch()

  3. 判断是否是重载：
    跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

  4. 在通过对象调用方法时，如何确定某一个指定的方法：
    方法名 —> 参数列表
    代码示例

public class OverLoadTest {
	public static void main(String[] args) {
		
		OverLoadTest test = new OverLoadTest();
		test.getSum(1,2);
		
		
	}
	
	//如下的4个方法构成了重载
	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){
		System.out.println("4");
	}
	
	//如下的3个方法不能与上述4个方法构成重载
//	public int getSum(int i,int j){
//		return 0;
//	}
	
//	public void getSum(int m,int n){
//		
//	}
	
//	private void getSum(int i,int j){
//		
//	}
	
	
}

2、可变个数的形参

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 test = new MethodArgsTest();
		test.show(12);
//		test.show("hello");
//		test.show("hello","world");
//		test.show();
		
		test.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){
//		
//	}
	
	//The variable argument type String of the method 
	//show must be the last parameter
//	public void show(String ...strs,int i){
//		
//	}
	
}

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

提醒：这一款不懂得话看这个https://www.bilibili.com/video/BV1Kb411W75N?p=212
主要是花内存分析图，清晰底层逻辑。

1、关于变量的赋值：

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

在这里插入图片描述
代码示例：

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

class Order{
	
	int orderId;
	
}

2、方法的形参的传递机制：值传递

看好内存机制：

  1. 内存结构：栈（局部变量）、堆(new出来的结构:对象(非static成员变量)、数组)
  2. 变量：成员变量 vs 局部变量（方法内、方法形参、构造器内、构造器形参、代码块内）
 形参：方法定义时，声明的小括号内的参数
 实参：方法调用时，实际传递给形参的数据

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

注意：

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的变量所保存的数据的地址值。
package com.atguigu.java;

public class ValueTransferTest {
	public static void main(String[] args) {
		
		String s1 = "hello";
		
		ValueTransferTest test = new ValueTransferTest();
		test.change(s1);
		
		System.out.println(s1);//打出来的是“hello”。这一点比较特殊。	
	}
	
	public void change(String s){
		s = "hi~~";
	}
}

代码示例：

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);
		
		
	}
	
	
	public void swap(int m,int n){
		int temp = m ;
		m = n;
		n = temp;
	}
}

3、println（char[]）方法

public class ArrayPrintTest {
	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3};
		System.out.println(arr);//打印出来的是地址值
		char[] arr1 = new char[]{'a','b','c'};
		System.out.println(arr1); //打印出来的是：abc
	}
}

4、网红面试题
在这里插入图片描述
方法一：在调用方法中输出，输出之后立即结束程序运行。
方法二：后补。
5、练习题

   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()方法，调用完毕后输出当前半径值。程序运行结果如图所示。

在这里插入图片描述
代码解答：

package shangguigu.javabase.faceobjact;
/*
 * 定义一个Circle类，包含一个double型的radius属性代表圆的半径，
 * 一个findArea()方法返回圆的面积。
 * 
 */
public class Circle4213 {
     double radius;
     public double  findArea() {
    	 return  Math.PI * radius * radius;
     }
     
     
}


package shangguigu.javabase.faceobjact;
/*
 * 考查参数的值传递
 * 
 * 定义一个类PassObject，在类中定义一个方法printAreas()，
 * 该方法的定义如下：public void printAreas(Circle c, int time)
 * 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
 * 例如，time为5，则输出半径1，2，3，4，5，以及对应的圆面积。
 * 
 * 
 * 在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示。
 * 
 * 
 */
public class PassObject4213 {

	
public static void main(String[] args) {
	PassObject4213 pass = new PassObject4213();
	Circle4213 	 cir = new Circle4213();
	pass.printAreas(cir, 5);
	
	System.out.println("当前的半径值"+cir.radius);
}
	
	
	public void printAreas(Circle4213 c, int time) {
		for (int i = 1; i <= time; i++) {
			c.radius=i;
			System.out.println(i+"	"+c.findArea());
		}
		
		
	}
}

4、递归方法

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

public class RecursionTest {

	public static void main(String[] args) {

		// 例1：计算1-100之间所有自然数的和
		// 方式一：
		int sum = 0;
		for (int i = 1; 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);

	}

	// 例1：计算1-n之间所有自然数的和
	public int getSum(int n) {// 3

		if (n == 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 f(n + 2) - 2 * f(n + 1);
			return 2*f(n - 1) + f(n - 2);
		}
	}

	//例4：斐波那契数列
	
	//例5：汉诺塔问题
	
	//例6：快排

}

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

1、问题的引入：

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

2、封装性的体现：

我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。 
 拓展：封装性的体现：① 如上  ② 不对外暴露的私有的方法  ③ 单例模式   ...

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

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

//private class Dog{
//	
//}

4、简单案例

package com.atguigu.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;
	}
	
}


public class OrderTest {
	public static void main(String[] args) {
		
		Order order = new Order();
		
		order.orderDefault = 1;
		order.orderPublic = 2;
		//出了Order类之后，私有的结构就不可以调用了
//		order.orderPrivate = 3;//The field Order.orderPrivate is not visible
		
		
		
		order.methodDefault();
		order.methodPublic();
		//出了Order类之后，私有的结构就不可以调用了
//		order.methodPrivate();//The method methodPrivate() from the type Order is not visible
	}
}

import com.atguigu.java.Order;

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

		order.orderPublic = 2;
		// 出了Order类所属的包之后，私有的结构、缺省声明的结构就不可以调用了
//		order.orderDefault = 1;
		// order.orderPrivate = 3;//The field Order.orderPrivate is not visible

		order.methodPublic();
		// 出了Order类所属的包之后，私有的结构、缺省声明的结构就不可以调用了
//		order.methodDefault();
		// order.methodPrivate();//The method methodPrivate() from the type Order is not visible
	}
}

5、简单试题

   1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
 *     用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。
 * 
 * 2.练习2：
 * 2.1. 在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。
 * 2.2. 修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。

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){
//			throw new RuntimeException("传入的数据非法！");
			System.out.println("传入的数据非法！");
			return;
		}

		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.atguigu.exer;
/*
 * 在PersonTest类中实例化Person类的对象b，
 * 调用setAge()和getAge()方法，体会Java的封装性。
 * 
 */
public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
//		p1.age = 1;编译不通过
		
		p1.setAge(12);
		
		System.out.println("年龄为：" + p1.getAge());
		
//		p1.doAge(122);
		
		
		Person p2 = new Person("Tom", 21);
		System.out.println("name = " + p2.getName() + ",age = " + p2.getAge());
		
	}
}

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

类的结构之三：构造器（或构造方法、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("人可以学习");
	}
	
}

构造器的练习

package com.atguigu.exer1;
/*
 * 编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。
 * 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
 */
public class TriAngle { //angle:角    angel:天使
	
	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;
	}
	
}


package com.atguigu.exer1;

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

四、小总结：属性赋值过程

总结：属性赋值的先后顺序

  • ① 默认初始化

  • ② 显式初始化

  • ③ 构造器中初始化

  • ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

  • 以上操作的先后顺序：① - ② - ③ - ④

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);
		u1.setAge(5);
		
		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;
	}
	
}

五、关键字–this

this关键字的使用：

  • 1.this可以用来修饰、调用：属性、方法、构造器
  • 2.this修饰属性和方法：
    this理解为：当前对象 或 当前正在创建的对象
    2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是， 通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
    2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。 但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式 的使用"this.变量"的方式，表明此变量是属性，而非形参。
    1. 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);
		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("人学习");
	}
	
}

练习的代码示例：
在这里插入图片描述

package com.atguigu.exer2;

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.atguigu.exer2;

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.atguigu.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);
		
		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("一样大");
		}
		
	}
}
# 六、实验：银行账户和客户 1、写一个名为 Account 的类模拟账户。该类的属性和方法如下图所示。该类包括的属性： 账号 id，余额 balance，年利率 annualInterestRate；包含的方法：访问器方法（getter 和 setter 方法），取款方法 withdraw()，存款方法 deposit()。 
类图：
Account
private int id
private double balance
private double annualInterestRate

public Account (int id, double balance, double annualInterestRate )
public int getId()
public double getBalance()
public double getAnnualInterestRate() public void setId( int id)
public void setBalance(double balance)
public void setAnnualInterestRate(double annualInterestRate) public void withdraw (double amount)//取钱
public void deposit (double amount)//存钱

提示：在提款方法 withdraw 中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。

  1. 创建 Customer 类。
类图：
Customer
private String firstName private String lastName
private Account account
public Customer(String f,String l)
public String getFirstName() public String getLastName() public Account getAccount()
public void setAccount(Account account)

a. 声明三个私有对象属性：firstName、lastName 和 account。
b. 声明一个公有构造器，这个构造器带有两个代表对象属性的参数（f 和 l）
c. 声明两个公有存取器来访问该对象属性，方法 getFirstName 和 getLastName 返回相应的属性。
d. 声明 setAccount 方法来对 account 属性赋值。
e. 声明 getAccount 方法以获取 account 属性。

  1. 写一个测试程序。
    （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

代码实现：

package shangguigu.javabase.faceobjact;

public class Account {

	
	private int id; //账号
	private double balance;//余额
	private double annualInterestRate;//年利率
	
	public Account() {
		
	}
	
	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;
	}
	/**
	 * @Description  //取钱
	 * @author SongWenKai   Email:15639036084@163.com
	 * @date 2022年2月10日下午2:49:57
	 * @param amount
	 */
	public void withdraw (double amount) {
		if(this.balance<amount) {
			System.out.println("您的余额不足！");
		}else {
			this.balance -=amount;
			System.out.println("取款"+amount+"元，余额："+this.balance+"元");
		}
	}
	/**
	 * @Description   存钱
	 * @author SongWenKai   Email:15639036084@163.com
	 * @date 2022年2月10日下午2:50:09
	 * @param amount
	 */
	public void deposit (double amount) {
        this.balance +=amount;  
		System.out.println("您本次存款为"+amount+"元，您的余额为："+this.balance+"元。");
	}

}


package shangguigu.javabase.faceobjact;

public class Customer {

	
	private String firstName;
	private String lastName;
	private Account account;

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

	
	
}


package shangguigu.javabase.faceobjact;
/**
3.	写一个测试程序。
（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 cus = new Customer("Jane","Smith");
		
		Account acc = new Account(1000,2000,0.0123);
		cus.setAccount(acc);
		
		cus.getAccount().deposit(100);
		cus.getAccount().withdraw(960);
		cus.getAccount().withdraw(2000);
		System.out.println(cus.getFirstName()+" "+cus.getLastName());
	}
}

七、关键字package、import

1、package

1.为了更好的实现项目中类的管理，提供包的概念

  • 2.使用package声明类或接口所属的包，声明在源文件的首行
  • 3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
  • 4.每"."一次，就代表一层文件目录。
  • 补充：同一个包下，不能命名同名的接口、类。
  • 不同的包下，可以命名同名的接口、类。

2、import

import:导入

    1. 在源文件中显式的使用import结构导入指定包下的类、接口
    1. 声明在包的声明和类的声明之间
    1. 如果需要导入多个结构，则并列写出即可
    1. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
    1. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
    1. 如果使用的类或接口是本包下定义的，则可以省略import结构
    1. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
    1. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
    1. import static:导入指定类或接口中的静态结构:属性或方法。
      代码示例:
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);
	}
}
码起来呗
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c#第4章面向对象的高级编程.ppt
11-13
c#第4章面向对象的高级编程.ppt
java面向对象第四章上机_java面向对象编程——第四章 类和对象
weixin_35970228的博客
02-26 234
OO：面向对象OOP：面向对象编程OOA：面向对象分析OOD：面向对象设计结构化编程：从顶向下，将一个大问题分解成更小的任务，然后为每一个更小的任务编写一个过程。最后程序员会编写一个主过程来启动程序流程，随后根据程序流程走向，调用想要的其它过程。对象是存在的具体实体，具有明确定义的特征和行为。万物皆为对象，对象因我关注而产生。面向对象：一种认识事物的方式，注重对事物整体的认知，最符合人类自然的思维...
第一章 面向对象
Stay Hungry Stay Foolish 求知若饥 虚心若愚
08-23 4609
文章目录（一）面向对象三大特性？（二）重写与重载的区别？（二）对java多态的理解 ？（三）Java中实现多态的机制是什么？ （一）面向对象三大特性？ 面向对象的三大特性包括：封装、继承、多态。 封装是给对象提供了隐藏内部属性和行为的能力。通过public,protected,private修饰符来给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。它可以通过隐藏对象的属性来保护对象内部的...
第二章 面向对象技术
yangzhiwei的专栏
09-17 793
一、面向对象的基础 1、面向对象基础概念 面向对象=对象+类+继承+消息通信 1、对象：在面向对象的系统中，对象是基本运行时的实体，即包括数据（属性），也包括作用于数据的操作（行为）。对象内进行的操作通常称为方法。一个对象一般由对象名（标识）、属性和方法三个部分组成。 2、消息：对象之间进行通信的一种构造称为消息。当一个消息发送给某个对象时，包含要求接收对象去执行某些活动的信息。接收到信息的对象经过解释，然后予以响应。这种通信机制称为消 息传递。发送消息的对象不需要知道接收消息的对象...
JavaSE：第四章：面向对象上
Java程序员廖志伟
10-05 1032
史上最全的知识体系脑图，覆盖所有知识点，所有细节，注意事项。 面向对象上：包含面向对象与面向过程，类和对象，属性，方法，封装和隐藏，构造器(构造方法)，this的使用，值传递，package、import的使用。 ...
第八章：面向对象分析、设计
m0_55901666的博客
12-06 1367
第八章：面向对象分析（OOA) 知识点 1.面向对象分析中，主要由对象模型：静态模型（类图）、动态模型（状态图、先画数据跟踪图）和功能模型（用例图或数据流图）组成。 2.分析工作主要包括3项内容即：理解、表达和验证 3.面向对象分析即（OOA）。 4.三个子模型和5个层次：对象模型、动态模型、功能模型。 ​ 主题层、类与对象层、结构层、属性层、服务层。 5.具体地说，大多数客观事物可分为下述5类：(1) 可感知的物理实体 。 (2) 人或组织的 角色 (3) 应该记忆的事
面向对象编程技术第四章PPT资料.pptx
12-01
面向对象编程技术第四章PPT资料.pptx
软件设计与体系结构第四章面向对象的软件设计方法.pdf
09-14
软件设计与体系结构第四章面向对象的软件设计方法
第五章python面向对象基础详解
12-22
第五章python面向对象基础详解一.理解面向对象二、类和对象三、添加和获取对象属性四、魔法方法五、继承 一.理解面向对象 面向对象就是将编程当成一个事物，对外界来说，事物是直接使用的，不用去管内部情况。编程...
第四章 面向对象（上） .ppt
08-27
第四章 面向对象（上） .ppt,第四章 面向对象（上） .ppt,第四章 面向对象（上） .ppt,第四章 面向对象（上） .ppt
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 445
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
junlaiyan的专栏
05-16 140
借助jdeps分析出jar包的增量文件
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 522
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 205
java导出excel动态加载多sheet多复杂表头
Android Model引入其他aar包 导致无法打包成aar
最新发布
qq_27400335的博客
05-16 237
Android Model引入其他aar包 导致无法打包成aar
java中实现缓存的几种方式
shenxiaomo1688的博客
05-16 682
Redis 是C语言开发的一个开源高性能键值对的内存数据库，可以用来做数据库、缓存、消息中间件等场景，是一种NoSQL(not-only sql,非关系型数据库)的数据库。下面我们介绍在springboot项目中的使用springboot中有redis的starter我们直接引用即可然后在spring配置文件中加入如下设置，这里用的是properties形式的文件，host是部署redis的服务器ip，port是端口号，password是密码，如果没有设置密码不填即可同样我们编写接口测试。
设计模式-责任链模式
weixin_43880576的博客
05-11 995
责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
brupsuite各版本专业破解安装
weixin_51520483的博客
05-11 200
最新brupsuite专业版安装，全套安装软件+环境，附带安装包教程
Spring Cloud 概述及项目创建
qq_66292058的博客
05-13 723
在介绍什么是微服务之前，我们先来了解一下什么集群和分布式的概念。Spring Cloud是微服务架构的一站式解决方案，它对一系列用来实现微服务或解决微服务带来的问题的组件进行了整合，例如实现负载均衡，服务调用和服务发现，分布式版本配置 ，断路器，分布式消息等功能的组件，并将这些组件按照Spring Cloud的规范进行管理。Spring Cloud并不自己实现这些组件，而是对其进行管理，并提供给用户进行使用。
第1章 认识java语言 第2章 java语言基础 第3章 面向对象程序设计之一 第4章 面向对象程序设计之二 第5章 java基础类库 第6章 图形用户界面程序 第7章 输入输出流 第8章 多线程并发编程 第9章 网络编程 第10章 数据库编程
07-15
### 回答1： 第1章《认识java语言》是介绍Java语言的起源、发展以及特点等基本知识。Java是一种跨平台的高级编程语言，被广泛应用于开发Web和移动应用程序等领域。它具有面向对象、可移植、健壮性好等特点。 第2章《Java语言基础》是介绍Java语言的基本语法、数据类型、运算符、控制流程等内容。学习这些基础知识对于理解和编写Java程序至关重要。 第3章《面向对象程序设计之一》是介绍面向对象编程的原理和基本概念。学习面向对象的思想和方法可以提高程序的可扩展性和重用性。本章内容包括类与对象、封装、继承、多态等知识点。 第4章《面向对象程序设计之二》是进一步探讨面向对象编程的高级特性。学习抽象类、接口、内部类等内容可以让我们写出更加灵活和健壮的Java程序。 第5章《Java基础类库》是介绍Java标准库中的常用类和接口。掌握这些类的使用方法可以大大简化程序开发，如字符串处理、集合框架、IO操作等。 第6章《图形用户界面程序》是介绍使用Java编写图形用户界面（GUI）程序的方法。学习Swing和JavaFX等技术可以实现丰富、直观的用户界面。 第7章《输入输出流》是介绍Java中的输入输出操作。学习文件读写、网络通信等知识可以实现数据的持久化和交互。 第8章《多线程并发编程》是介绍Java多线程编程的原理和方法。学习多线程操作可以充分利用多核处理器的优势，提高程序的并发性和响应性。 第9章《网络编程》是介绍使用Java进行网络通信的方法。学习Socket编程、HTTP协议等内容可以开发出基于网络的应用程序。 第10章《数据库编程》是介绍使用Java连接和操作数据库的方法。学习JDBC等技术可以实现与数据库的交互，进行数据持久化和查询。 通过学习这些章节的内容，可以全面掌握Java语言的基础知识和常用技术，为进一步深入学习和应用Java打下良好的基础。 ### 回答2： 第1章：认识Java语言 第1章介绍了Java语言的基本概念和特点。Java是一种跨平台的编程语言，被广泛应用于Web开发、移动应用开发等领域。Java具有简单易学的特点，使用了面向对象的编程思想，具有良好的可扩展性和可维护性。 第2章：Java语言基础 第2章主要介绍了Java语言的基本语法和常用的数据类型。包括变量、常量、运算符、流程控制语句等。同时还介绍了Java中的数组、字符串和输入输出等相关知识。 第3章：面向对象程序设计之一 第3章介绍了面向对象程序设计的基本概念和常用的面向对象的特性。包括类、对象、继承、封装和多态等。同时还介绍了如何定义和使用类，以及如何实现各种面向对象的特性。 第4章：面向对象程序设计之二 第4章进一步深入介绍了面向对象程序设计的相关知识。包括接口、抽象类、继承和多态的高级应用，以及异常处理和内部类等。这些知识对于构建复杂的面向对象程序非常重要。 第5章：Java基础类库 第5章介绍了Java基础类库中常用的类和方法。包括字符串、日期、时间、集合、文件和输入输出等类库的使用。这些类库为我们提供了丰富的功能，在Java编程中非常实用。 第6章：图形用户界面程序 第6章介绍了Java图形用户界面编程的相关知识。包括Swing和AWT等GUI库的使用，以及事件处理和布局管理器等。通过学习这些知识，我们可以编写出漂亮、交互性强的图形界面程序。 第7章：输入输出流 第7章介绍了Java中输入输出流的使用。包括字节流和字符流的概念、File类的使用以及文件读写和网络通信等。这些知识对于实现数据的读写和传输非常重要。 第8章：多线程并发编程 第8章介绍了Java多线程并发编程的相关知识。包括线程、线程同步和线程通信的概念，以及锁和条件的使用。同时还介绍了线程池的概念和使用，以及如何处理并发编程中的常见问题。 第9章：网络编程 第9章介绍了Java网络编程的基本知识。包括Socket编程、TCP和UDP协议，以及HTTP协议的使用。通过学习这些知识，我们可以编写出具有网络功能的Java应用程序。 第10章：数据库编程 第10章介绍了Java数据库编程的相关知识。包括连接数据库、执行SQL语句、事务处理和数据查询等。通过学习这些知识，我们可以使用Java操作各种类型的数据库。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码起来呗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值