（五）java面向对象编程基础_java面向对象编程基础实验-CSDN博客

本文链接：https://blog.csdn.net/xcl1670/article/details/128309818

文章目录

- - 面向对象编程（基础）

面向对象编程（基础）

类与对象

一个程序就是一个世界，一个人可以看成一个对象，在一只猫也是一个对象。

类就是数据类型，比如Cat，person

对象就是具体的实例，比如咖啡猫，布偶猫，男人，女人。

在这里插入图片描述

注意事项和细节说明：

属性的定义语法同变量名，又四种修饰符，public，proctected，默认，peivate。
属性的定义可以为任意的类型
如果不赋值，则为默认值，规则和数组一致。

class Cat {
	String name;//属性，成员变量，字段
	int age;//
	String color;
	Boolean sass;//属性可以是基本数据类型，也可以是引用类型（对象，数组）

}

public class class02 {
	public static void main(String[] args) {
		Cat cat1 = new Cat();
		cat1.name = "小白";
		cat1.age = 3;
		cat1.color = "blue";

		Cat cat2 = new Cat();
		cat2.name = "小黑";
		cat2.age = 4;
		cat2.color = "red";

		System.out.println("第一只猫的信息:" + cat1.name + " " + cat1.age + " " + cat1.color + " " + cat1.sass);
		System.out.println("第二只猫的信息:" + cat2.name + " " + cat2.age + " " + cat2.color);

	}
}

class Person {
	String name;//属性，成员变量，字段
	int age;
}

public class class03 {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.age = 10;
		p1.name = "小明";
		Person p2 = p1;
		p2.age = 40;
		System.out.println(p1.age);
		p1 = null;
		p1.age = 34;
		System.out.println(p2.age);
		System.out.println(p1.age);
	}
}

方法调用

class Person {

	public void speak() {
		System.out.println("I am a goode man");
	}

	public void cal01() {
		int res = 0;
		for (int i = 0; i <= 1000; i++) {
			res += i;
		}
		System.out.println("计算结果:" + res);
	}

	public void cal02(int n) {
		int res = 0;
		for (int i = 0; i <= n; i++) {
			res += i;
		}
		System.out.println("计算结果:" + res);
	}
	//添加getSum成员方法
	public int getSum(int num1, int num2) {
		int res = num1 + num2;
		return res;
	}
}

public class class04 {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.speak();
		p1.cal01();
		p1.cal02(5);
		p1.cal02(6);
		int returnRes = p1.getSum(10, 23);
		System.out.println("返回的值为：" + returnRes);
	}
}

方法调用小结：

当程序执行到方法时，就会开辟一个独立的空间（栈空间）
当方法执行完毕后，或者执行到return时就会返回
返回到调用方法的地方，之前开辟的方法的栈空间就会释放。
放回后，继续执行方法后面的代码
当main方法执行完毕后，整个程序退出，释放栈空间。

成员方法的好处

提高代码的复用性
可以将实现的细节封装起来，然后供给其他用户来调用即可。

class MyTools {
	public void arr(int[][] map) {
		System.out.println("======================");
		for (int i = 0; i < map.length; i++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + "\t");
			}
			System.out.println();
		}
	}
}

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

		//变量一个数组，输出数组的各个与元素的值。
		int[][] map = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
		MyTools tools = new MyTools();
		tools.arr(map);

		//再次遍历
		tools.arr(map);
	}
}

成员方法的定义

public 返回数据类型 方法名（形参列表...）{
	语句；
	return 返回值
}
//return语句不是必须的
//方法体，实现某一功能的代码块

成员方法的注意事项：

一个方法最多有一个返回值，若要返回多个结果，返回数组即可。
返回类型可以是任意的类型
如果方法要求返回数据类型，方法体中最后的执行语句必须要有返回值，而且要求返回的类型必须和return的值类型一致或兼容。
如果方法是void，则方法体中可以没有return语句，或者只写return；
一个方法有多个参数，也可以没有参数，多个参数中间可以用逗号隔开。
参数类型可以为任意类型，包含基本类型和引用类型。
传入参数的时候类型，顺序，个数必须要一致。
方法不能嵌套定义。
同一个类中的方法可以直接调用。
跨类中调用方法需要先创建对象。

class MyTools {
	public int[] arr(int n1, int n2) {
		int[] arr = new int[2];
		arr[0] = n1 + n2;
		arr[1] = n1 - n2;
		return arr;
	}
}

public class class06 {
	public static void main(String[] args) {
		//返回值类型是数组
		MyTools tools = new MyTools();
		int[] arrs = tools.arr(12, -23);
		System.out.println("两数的和为：" + arrs[0]);
		System.out.println("两数的差为：" + arrs[1]);
	}
}

import java.util.Scanner;

class AAA {
	public boolean putt(int n) {
		if (n % 2 == 0) {
			System.out.println(n + "为偶数");
			return true;
		} else {
			System.out.println(n + "为奇数");
			return false;
		}
	}
}

public class class07 {
	public static void main(String[] args) {
		//编写类AA，有一个方法：判断一个数是奇数还是偶数，返回boolean。
		Scanner lll = new Scanner(System.in);
		System.out.println("请输入一个整数");
		int scan = lll.nextInt();
		AAA a = new AAA();
		a.putt(scan);
	}
}

import java.util.Scanner;

class AAA {
	public void putt(int n, int m, char k) {
		System.out.println("打印结果如下：");
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				System.out.print(k);
			}
			System.out.println();
		}
	}
}

public class class08 {
	public static void main(String[] args) {
		//根据行，列，字符打印，对应行数和列数的字符，比如：行：4，列：4，字符#
		Scanner lll = new Scanner(System.in);
		System.out.println("请输入您要打印的行数：");
		int scan1 = lll.nextInt();
		System.out.println("请输入您要打印的列数：");
		int scan2 = lll.nextInt();
		AAA a = new AAA();
		a.putt(scan1, scan2, '%');
	}
}

方法传参机制

//数组是引用传递，地址copy
class AAA {
	public void putt(int[] arr) {
		arr[0] = 100;
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println(" ");
	}
}

public class class09 {
	public static void main(String[] args) {
		AAA a = new AAA();
		int[] arr = {1, 2, 3};
		a.putt(arr);
		System.out.println("===================");
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		System.out.println(" ");
	}
}

//对象类型也是存放在堆中，
class AAA {
	public void puttt(person p) {
		p.age = 100;
	}
}
class person {
	String name;
	int age;
}

public class class10 {
	public static void main(String[] args) {
		person p = new person();
		p.name = "jack";
		p.age = 23;

		AAA a = new AAA();
		a.puttt(p);
		System.out.println("输出的结果为：" + p.age);
	}
}

//输出结果为23，p的指向为空。
class AAA {
	public void puttt(person p) {
		p = null;
	}
}
class person {
	String name;
	int age;
}

public class class11  {
	public static void main(String[] args) {
		person p = new person();
		p.name = "jack";
		p.age = 23;

		AAA a = new AAA();
		a.puttt(p);
		System.out.println("输出的结果为：" + p.age);
	}
}

class AAA {
	public void puttt(person p) {
		p = new person();
		p.age = 11;
	}
}
class person {
	String name;
	int age;
}

public class class12  {
	public static void main(String[] args) {
		person p = new person();
		p.name = "jack";
		p.age = 23;

		AAA a = new AAA();
		a.puttt(p);
		System.out.println("输出的结果为：" + p.age);
	}
}

//编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象
//注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同。
class AAA {
	public person puttt(person p) {
		person p2 = new person();
		p2.name = p.name;
		p2.age = p.age;
		return 	p2;
	}
}
class person {
	String name;
	int age;
}

public class class13  {
	public static void main(String[] args) {
		person p = new person();
		p.name = "jack";
		p.age = 23;

		AAA a = new AAA();
		person p2 = a.puttt(p);
		System.out.println("输出的结果为：" + p.age + " " + p.name);
		System.out.println("输出的结果为：" + p2.age + " " + p2.name);
	}
}

方法的递归调用

//递归方法调用
class AAA {
	public int puttt(int p) {
		if (p == 1) {
			return 1;
		} else {
			return puttt(p - 1) * p;
		}
	}
}

public class recursion01  {
	public static void main(String[] args) {
		AAA a = new AAA();
		int res = a.puttt(5);
		System.out.println("输出结果为：" + res);
	}
}

递归调用的重要规则：

执行一个方法时，就创建一个新的受保护的独立空间（栈空间）。
方法的局部变量是独立的，不会相互影响。
如果方法中使用的是引用类型的变量（数组，对象），就会共享该引用类型的数据。
递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError，死循环。
当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用就返回给谁，同时当方法执行完毕或返回的时，该方法也就hi行完毕。

//用递归的方法求出斐波那契数列，给你一个整数n，求出他的值是多少,斐波那契数列：这个数是前两数之和。
class AAA {
	public int puttt(int n) {
		if (n == 1 || n == 2) {
			return 1;
		} else {
			return puttt(n - 1) + puttt(n - 2);
		}
	}
}

public class recursion02  {
	public static void main(String[] args) {
		AAA a = new AAA();
		int res = a.puttt(6);
		System.out.println("输出结果为：" + res);
	}
}

//猴子吃桃问题：有一堆桃子，猴子第一天吃其中的一半，并再多吃一个，以后每天猴子都吃其中的一半，然后再多吃一个。
//当到第十天时，想再吃时（还没吃），发现只有一个桃子，问题：最初一共有多少个桃子。
class AAA {
	public int puttt(int n) {
		if (n == 10) {
			return 1;
		} else if (n >= 1 && n <= 9) {
			return (puttt(n + 1) + 1) * 2;
		} else {
			System.out.println("结果不对");
			return -1;
		}
	}
}

public class recursion03  {
	public static void main(String[] args) {
		AAA a = new AAA();
		int day = 1;
		int res = a.puttt(day);
		if (res != -1) {
			System.out.println("第" + day + "天有桃子数量：" + res);
		} else {
			System.out.println("数值不在1-9之间！！！");
		}
	}
}

//老鼠出迷宫问题
//0表示可以走，1表示障碍物，2表示可以走，3表示走过
//map[6][5] =2,就说明找到了路，此时就可以结束，否则就继续找
//确定
class T {
	public boolean function(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			return true;
		} else {
			if (map[i][j] == 0) {

				map[i][j] = 2;
				if (function(map, i + 1, j)) {//向下
					return true;
				} else if (function(map, i, j + 1)) {//向右
					return true;
				} else if (function(map, i - 1, j)) {//向上
					return true;
				} else if (function(map, i, j - 1)) {//向左
					return true;
				} else {
					map[i][j] = 3;
					return false;
				}

			} else {
				return false;
			}
		}
	}

}

public class recursion04  {
	public static void main(String[] args) {
		int[][] map = new int[8][7];
		for (int i = 0; i < 7; i++) {
			map[0][i] = 1;
			map[7][i] = 1;
		}

		for (int j = 1; j < 7; j++) {
			map[j][0] = 1;
			map[j][6] = 1;
		}

		map[3][1] = 1;
		map[3][2] = 1;

		System.out.println("======输出的地图如下所示：======");
		for (int i = 0; i < map.length; i ++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println(" ");
		}

		T tt = new T();
		tt.function(map, 1, 1);
		System.out.println("======找路的情况如下：======");
		for (int i = 0; i < map.length; i ++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println(" ");
		}
	}
}

//老鼠出迷宫问题
//0表示可以走，1表示障碍物，2表示可以走，3表示走过
//map[6][5] =2,就说明找到了路，此时就可以结束，否则就继续找
//确定
class T {
	public boolean function(int[][] map, int i, int j) {
		if (map[6][5] == 2) {
			return true;
		} else {
			if (map[i][j] == 0) {

				map[i][j] = 2;
				if (function(map, i + 1, j)) {//向下
					return true;
				} else if (function(map, i, j + 1)) {//向右
					return true;
				} else if (function(map, i - 1, j)) {//向上
					return true;
				} else if (function(map, i, j - 1)) {//向左
					return true;
				} else {
					map[i][j] = 3;
					return false;
				}

			} else {
				return false;
			}
		}
	}
}

public class recursion05  {
	public static void main(String[] args) {
		int[][] map = new int[8][7];
		for (int i = 0; i < 7; i++) {
			map[0][i] = 1;
			map[7][i] = 1;
		}

		for (int j = 1; j < 7; j++) {
			map[j][0] = 1;
			map[j][6] = 1;
		}

		map[3][1] = 1;
		map[3][2] = 1;
		map[2][2] = 1;

		System.out.println("======输出的地图如下所示：======");
		for (int i = 0; i < map.length; i ++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println(" ");
		}

		T tt = new T();
		tt.function(map, 1, 1);
		System.out.println("======找路的情况如下：======");
		for (int i = 0; i < map.length; i ++) {
			for (int j = 0; j < map[i].length; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println(" ");
		}
	}
}

方法重载

基本介绍

java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致。

重载的好处

减轻了起名的麻烦
减轻了记名的麻烦

class T {
	public int calculate(int i, int j) {
		return i + j;
	}
	public double calculate(int i, double j) {
		return i + j;
	}
	public double calculate(double i, int j) {
		return i + j;
	}
	public double calculate(double i, double j, int k) {
		return i + j + k;
	}
}
public class overload01  {
	public static void main(String[] args) {
		T aaa = new T();
		System.out.println("两数之和的结果为：" + aaa.calculate(1.2, 3.98, 3));
	}
}

方法重载细节

方法名：必须相同
形参类列表：必须不同（形参类型或个数或顺序，至少有一样不同，形参名无要求）
返回类型：无要求（若只修改了返回值类型，这属于是方法的重写）

//编写程序，类Methods中定义三个重载方法并调用，方法名为m
//三个方法分别接收一个int参数，两个int参数，一个字符串参数。
//分别执行平方运算，相乘运算，输出字符串信息，在主类main()方法中分别用参数进行调用三个方法。
class T {
	public int Methdos(int i) {
		return i * i;
	}
	public int Methdos(int i, int j) {
		return i * j;
	}
	public String Methdos(String i) {
		return i ;
	}
}
public class overload02  {
	public static void main(String[] args) {
		T aaa = new T();
		System.out.println("平方的结果为：" + aaa.Methdos(4));
		System.out.println("相乘的结果为：" + aaa.Methdos(4, 10));
		System.out.println("字符串的结果为：" + aaa.Methdos("123123xdfvsdf sdfgw "));
	}
}

//定义三个重载方法max(),第一个方法，返回两个int中的最大值，
//第二个方法，返回两个double中的最大值，
//第三个方法，返回三个double中的最大值；
class T {
	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) {
		return i > j && i > k ? i : (j > i && j > k ? j : k);
	}
}
public class overload03  {
	public static void main(String[] args) {
		T aaa = new T();
		System.out.println("最大值为：" + aaa.max(4, 5));
		System.out.println("最大值为：" + aaa.max(1.2, 1.3));
		System.out.println("最大值为：" + aaa.max(123, 1234, 1.4));
	}
}

可变参数

基本概念

java允许将同一个类中的多个同名同功能但参数个数不同的方法，封装成一个方法。

基本语法

	访问修饰符 返回类型 方法名（数据类型... 参数名）{
}

class T {
	public int sum(int... nums) {
		int res = 0;
		for (int i = 0; i < nums.length ; i++ ) {
			res += nums[i];
		}
		return res;
	}
}
public class overload04  {
	public static void main(String[] args) {
		T aaa = new T();
		int a = aaa.sum(1, 3, 6767, 789);
		System.out.println("sum值为：" + a);
	}
}

注意事项：

可变参数的实参可以是0个或者任意多个
可变参数的实质可以是数组
可变参数的本质就是数组
可变参数可以和普通类型的参数一起放在形参列表，但是必须保证可变参数在最后
一个形参列表中只能出现一个可变参数

class T {
	public int sum(int... nums) {
		int res = 0;
		for (int i = 0; i < nums.length ; i++ ) {
			res += nums[i];
		}
		System.out.println("长度为：" + nums.length);
		return res;
	}

	//一个方法中的可变参数必须放在最后
	public int sum2(String i , int... nums) {

	}

	//一个方法不允许有有两个可变参数
	public int sum3(int... nums1, int... nums1) {

	}
}
public class overload05  {
	public static void main(String[] args) {
		T aaa = new T();
		int[] b = {1, 2, 4};
		int a = aaa.sum(b);
		System.out.println("sum值为：" + a);
	}
}

//有三个方法，分别实现返回姓名和两门课程的成绩（总分）
//返回姓名和三门的成绩，返回姓名和五门课的成绩总分
//封装成一个可变参数的方法
class T {
	public String sum1(String name , double grade1 , double grade2) {
		return name + " " + (grade1 + grade2);
	}

	public String sum2(String name , double grade1 , double grade2, double grade3) {
		return name + " " + (grade1 + grade2 + grade3);
	}

	public String sum3(String name , double... grade) {
		int res = 0;
		for (int i = 0; i < grade.length ; i++ ) {
			res += grade[i];
		}
		return name + " " + res;
	}
}
public class overload06  {
	public static void main(String[] args) {
		T aaa = new T();
		String a = aaa.sum1("狗子1", 12.4, 14.1);
		System.out.println("方法一返回值为：" + a);

		String b = aaa.sum2("狗子2", 12.4, 14.2, 13.4);
		System.out.println("方法二返回值为：" + b);

		String c = aaa.sum3("狗子3", 12.4, 14.3, 13.4, 34.5, 34.8);
		System.out.println("方法三返回值为：" + c);
	}
}

作用域

就是局部变量和全局变量（属性和成员方法）

注意细节：

属性和局部变量可以重名，访问时遵循就近原则
在同一个作用域中，比如同一个成员方法中，两个局部变量，不能重名。
作用域：

全局变量：可以被本类使用，或其他类使用（调用）

局部变量：只能在本类对应的方法中使用
修饰符不同：

全局变量可以加修饰符

局部变量不可加修饰符

构造器

构造器是初始化对象，完整对象的初始化，并不是创建对象。

构造器没有返回值
方法名和类名必须一致
参数列表和成员方法一样的规则
构造器的调用由系统完成
构造器的修饰符可以是默认的，也可以是public,protected,private
在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化。
如果没有创建构造器，系统会自动生成一个无参构造器。
一旦定义了自己的构造器，默认的构造器就会被覆盖了，就不能再使用默认的构造器了。
可以利用javap反编译来查看生成的默认构造器。

class Person {
	String name;
	int age;

	public Person(String pNmae, int pAge) {
		System.out.println("构造器1被调用");
		name = pNmae;
		age = pAge;
	}
	public Person(String pNmae) {
		System.out.println("构造器2被调用");
		name = pNmae;
	}

	public Person() {
		age = 18;//age默认属性为18
		System.out.println("默认构造器被调用");
	}
}

public class Constructor01  {
	public static void main(String[] args) {
		Person aaa = new Person("switch" , 12);
		System.out.println(aaa.name);
		System.out.println(aaa.age);

		Person bbb = new Person("Tom");
		System.out.println(bbb.name);
		System.out.println(bbb.age);//默认值为0

		Person ccc = new Person();
		System.out.println(ccc.age);
	}
}

当创建了一个对象后发生了什么

首先在方法去加载类，然后再开辟空间，然后默认初始化对象，再进行赋值，把对象在堆中的地址赋值给对象名。

对象在堆里面，不在栈里面，

java_this

this是当前对象中的属性。

哪个对象调用，this就代表哪个对象。

this的细节

this关键字可以用来访问本类的属性
this用于区分当前类的属性和局部变量
访问成员方法的语句，this.方法名（参数列表）
访问构造器语法：this(参数列表)，只能在构造中使用（只能在构造器中调用另一个构造器，且必须放置在第一条语句。）
this不能载类定义的外部使用，只能在类定义的方法中使用。

class T {
	public T() {
		this("Tom", "Jack");
		System.out.println("1");
	}

	public T(String a , String b) {
		System.out.println("2");
	}
}

public class This01  {
	public static void main(String[] args) {
		T aaa = new T();
	}
}

//定义person类，里面有name，age属性，并提供compare方法，用于判断是否和另一个人相等，
//若是相等则返回true，否则返回false
class Person {
	String name;
	int age;

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

	public boolean compare( Person p) {
		return this.name.equals(p.name) && this.age == p.age;
	}
}

public class This02  {
	public static void main(String[] args) {
		Person aaa = new Person("jack", 12);
		Person bbb = new Person("Tom", 12);

		System.out.println(aaa.compare(bbb));
	}
}

练习

//编写一个A01类,定义方法max，实现球某个double数组的最大值，并返回
class A01 {
	public Double max(double[] arr) {//Double首字母是大写的
		double max = arr[0];
		//先实现正常的业务，再考虑代码的健壮性
		if (arr != null && arr.length > 0) {
			for (int i = 1; i < arr.length ; i++) {
				if (max < arr[i]) {
					max = arr[i];
				}
			}
			return max;
		} else {
			return null;
		}
	}
}

public class Homework01  {
	public static void main(String[] args) {
		A01 aaa = new A01();
		double[] aa = {12.0, 12.4, 345.0};
		double a = aaa.max(aa);
		if (aa != null) {
			System.out.println("这个数组的最大数值为" + a);
		} else {
			System.out.println("数s组有误！！！");
		}
	}
}

//编写类A02，定义方法find，实现查找某个字符串是是否在字符串中，返回索引，若找不到则返回-1
class A02 {
	public int find(String findStr , String[] find) {
		for (int i = 0; i < find.length; i++) {
			if (findStr.equals(find[i])) {
				return i ;
			}
		}
		return -1;
	}
}

public class Homework02  {
	public static void main(String[] args) {
		A02 aaa = new A02();
		String[] strs = {"jack", "Tom", "Tim"};
		int bbb = aaa.find("Tom", strs);
		if (bbb != -1) {
			System.out.println("" + bbb);
		} else {
			System.out.println("没找到");
		}
	}
}

//编写类A03，定义方法UpdatePrice，实现更改基本书的价格，具体：如果价格大于150，则更改150，
class Book {
	String name;
	double price;
	public Book(String name, double price) {
		this.name = name;
		this.price = price;
	}

	public void UpdatePrice() {
		if (price > 150) {
			price = 150;
		} else if (price > 100) {
			price = 100;
		}else if(price < 0){
			System.out.println("价格小于0，价格有误");
		}
	}

	public void info() {
		System.out.println("price为：" + price);
	}
}

public class Homework03  {
	public static void main(String[] args) {
		Book aaa = new Book("Xi", 145.0);
		aaa.info();
		aaa.UpdatePrice();
		aaa.info();
	}
}

//定义一个Circle类，定义属性：半径，提供显示圆周长的方法，提供显示圆面积的方法；
//这里也可以导入math，我懒得导入了。
class Circle {
	double r;
	double PI;
	public Circle(double r) {
		this.r = r;
		PI = 3.14;
	}
	public Double L() {
		double L = 2 * PI * r;
		System.out.println("周长为：" + L);
		return L;
	}
	public Double S() {
		double S = PI * r * r;
		System.out.println("面积为：" + S);
		return S;
	}
}

public class Homework05 {
	public static void main(String[] args) {
		Circle aaa = new Circle(3.0);
		aaa.L();
		aaa.S();
	}
}

//创建一个cale计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和，差，乘，商（要求除数为0，要提示）
class Circle {
	double num1;
	double num2;
	public Circle(double num1, double num2) {
		this.num1 = num1;
		this.num2 = num2;
	}
	public Double sum() {
		return num1 + num2;
	}
	public Double minus() {
		return num1 - num2;
	}
	public Double mul() {
		return num1 * num2;
	}
	public Double div() {
		if (num2 == 0) {
			System.out.println("除数不能为0");
			return null;
		} else {
			return num1 / num2;
		}
	}
}

public class Homework06 {
	public static void main(String[] args) {
		Circle aaa = new Circle(3.0, 0.0);
		Double a = aaa.sum();
		Double b = aaa.minus();
		Double c = aaa.mul();
		Double d = aaa.div();
		System.out.println("两数相加为：" + a);
		System.out.println("两数相减为：" + b);
		System.out.println("两数相乘为：" + c);
		System.out.println("两数相除为：" + d);
	}
}

//设计一个Dog类，有名字，颜色，年龄的属性，定有方法show()显示其信息，并创建对象进行测试
class Dog {
	String name;
	String color;
	int age;
	public Dog(String name , String color, int age) {
		this.name = name;
		this.color = name;
		this.age = age;
	}
	public void show() {
		System.out.println("输出的结果为：" + name + " " + color + " " + age);
	}
}

public class Homework07 {
	public static void main(String[] args) {
		Dog aaa = new Dog("狗子", "bule", 13);
		aaa.show();
	}
}

//定义Music类，里面有音乐名name，音乐时长times属性，并有播放play功能和返回本身属性信息的功能方法getInfo
class Music {
	String name;
	double times;
	public Music(String name, double times) {
		this.name = name;
		this.times = times;
	}
	public void play() {
		System.out.println(name + "正在播放中，时长为" + times);
	}
	public String getInfo() {
		return name + "正在播放中，时长为" + times;
	}
}

public class Homework08 {
	public static void main(String[] args) {
		Music aaa = new Music("Strawberries & Cigarettes", 13.00);
		aaa.play();
		System.out.println(aaa.getInfo()); 
	}
}

//创建一个Employee类，属性有（名字，性别，年龄，职位，薪水），提供3个构造方法，可以初始化
//（1）(名字，性别，年龄，职位，薪水)
//（2）（名字，性别，年龄）
//（3）（职位，薪水），要求充分复用构造器。
class Employee {
	Strign name;
	string sex;
	int age;
	String job;
	double sal;
	public Employee(String job, double sel) {
		this.job = job;
		this.sel = sel;
	}
	public Employee(String name, String sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public Employee(String name, String sex, int age, String job, double sel) {
		this(name,sex,age);
		this(job,sel);
	}
}

public class Homework09 {
	public static void main(String[] args) {
		Employee aaa = new Employee();
	}
}