第四章、面向对象（2）

最新推荐文章于 2024-10-30 00:37:39 发布
最新推荐文章于 2024-10-30 00:37:39 发布
阅读量1.1k 收藏 4
点赞数 2
分类专栏： 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);
	}
}
码起来呗
关注
专栏目录
Python常见编程题（四）
baidu_36596628的博客
06-20 3711
面向对象编程、文件操作
Java基础学习day10【谷】
m0_47711130的博客
07-15 1002
默认初始化线性初始化构造器赋值通过“对象.方法”或“对象.属性”进行赋值1–2–3–4JavaBean是一种Java语言写成可重用组件所谓的JavaBean，是指符合如下标准的Java类》类是公共的》有一个无参的公共的构造器》有属性，且有对应的getset方法。...
java基础问题07---定义一个圆Circle类
小远的博客
01-20 1万+
利用面向对象的编程方法，设计类Circle计算圆的面积和圆的周长 import java.util.Scanner; public class CircleText { public static void main(String[] args) { Scanner value = new Scanner(System.in); System.out.println("请输入圆的半径 "); Circle c1 = new Circle(); double radius1 = va
java设计一个圆类_编写一个圆类Circle，该类拥有： ①一个成员变量 Radius（私有，浮点型）； // 存放圆的半径； ②两个构造方法...
weixin_33169898的博客
02-27 1万+
package Circle;import java.util.Scanner;public class Circle {private double Radius;public double getRadius(){return Radius;}public void setRadius(double r){this.Radius=r;}public Circle()//无参构造方法{this....
java基础~面向对象之方法
weixin_48035827的博客
01-02 477
java基础~面向对象之方法
Java 输出圆半径与面积
m0_71917549的博客
07-11 2540
圆半径与面积
c#第4章面向对象的高级编程.ppt
11-13
C# 第4章面向对象高级编程 本章教学目的：介绍C# 高级编程的相关知识，使学生对C# 高级编程有一个感性认识。 一、封装、继承与多态 * 封装：隐藏调用者不需要了解的信息。例如，模块信息通过类封装，类的成员通过...
软件设计与体系结构第四章面向对象的软件设计方法.pdf
09-14
软件设计与体系结构第四章面向对象的软件设计方法
第八章 面向对象.docx
03-19
### 第八章 面向对象 #### 一、面向对象的基本概念 面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计软件。面向对象的核心思想是将数据和处理这些数据的方法封装成一个...
√第八章 面向对象.docx
03-19
### 第八章：面向对象 #### 1. 数据流图 (DFD) 和实体关系图 (ERD) - **外部实体**：在数据流图 (DFD) 中，外部实体指的是系统外部的对象，它们与系统交互但不属于系统的一部分。例如，患者在这个场景中被视为外部...
第五章python面向对象基础详解
12-22
第五章python面向对象基础详解一.理解面向对象二、类和对象三、添加和获取对象属性四、魔法方法五、继承 一.理解面向对象 面向对象就是将编程当成一个事物，对外界来说，事物是直接使用的，不用去管内部情况。编程...
CircleCI 博客中文翻译（三）
最新发布
龙哥盟
10-30 747
orb 是一个指令列表，它允许您遵循成熟的逻辑，跨多个项目自动化一个特定的任务。它们帮助您最大限度地降低配置复杂性，同时充当软件包管理器，快速高效地集成您的软件和服务堆栈。orb 是可定制的，并且配备了利用作业、命令和执行者来满足你对项目的独特需求的能力。有公共和私有 orb，用户可以在具有相似用例的项目中采用。公共 orb 集成了流行的工具，可供使用 CircleCI 的广大开发人员使用。此外，我们提供私人 orb，仅限于同一组织内的用户。自 2021 年初以来，我们的规模计划客户可以使用私人球体。
面向对象练习题笔记（1）
周小末天天开心的博客
10-08 1426
面向对象练习题笔记
java基础~面向对象之封装
weixin_48035827的博客
01-04 1898
java基础~面向对象之封装
定义一个圆类Circle,其中有成员属性半径（r)、面积(s)和周长(p)，其中成员方法area()和per()分别实现求圆的面积和周长。
weixin_47377116的博客
04-27 6116
定义一个圆类Circle,其中有成员属性半径（r)、面积(s)和周长§，其中成员方法area()和per()分别实现求圆的面积和周长。创建类CircleTest，在该类的main()方法中创建Circle为的对象cir，分别调用半径（r）通过键盘赋值，求出圆的面积和周长并输出。将成员属性半径（r)、面积(s)和周长§前均添加上private，修改程序实现求面积周长。 有会的帮忙看一下啊 package work4zhang; import java.util.Scanner; public class wo
2021.8.31，内容：练习
change__12的博客
08-31 115
public class ArrayExer { public static void main(String[] args) { int[] arr = new int[] { 12, 3, 4, 5, 45, 46, 53, 224 }; for (int i = arr.length - 1; i >= 0; i--) { arr[i] = arr[i] / arr[0]; } System.out.print("新数组是:"); for (int i = 0;.
Java三大特性（例题及代码）
lovejojo222的博客
12-19 740
** 1、封装，将对象作为参数传递给方法。 ** 题目要求： （1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。 （2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下： public void printAreas(Circle c, int time) 在printAreas...
定义一个circle类，有数据成员radius（半径），成员函数getarea（）， 计算圆的面积，构造一个Circle的对象进行测试
热门推荐
qq_48474606的博客
11-26 2万+
具体代码如下： #include <iostream> using namespace std; class circle{ //定义一个circle类； public: circle(double radius){ r=radius; } ~circle(){}; //析构函数； double getarea(){return 3.14*r*r;} //此处Π取3.14； private: double r; }; void main(){ //主函数； cou
java构造可接收半径的circle,JAVA编程题，构造一个Circle类实现圆。急！！
weixin_34449886的博客
03-15 2243
用户提问构造一个Circle类，该类有一个私有double变量radius存放半径，可以通过get/set方法进行访问。该类具有getArea和getLength两个方法，能够利用半径和Math.PI计算高精度的面积和周长。输入要求任意多个双精度半径，每行一个输出要求第一行具有该半径的圆的面积和周长，保留两位小数第二行具有2倍于该半径的圆的面积和周长，保留两位小数假如输入123应当输出3.14 6...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

码起来呗

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

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

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

打赏作者

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

抵扣说明：

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

余额充值