Java类与对象

学习-Java类和对象之包的定义

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中声明一个包，在另一个包中引用该包中的类，具体要求如下：

• 在 Student.java 文件中，声明一个名为 com.pojo 的包；

• 在该文件中，有一个 Student 类，在该类中有一个 info 方法，该方法要求实现返回所有学生的功能，在该方法中定义一个 String 数组，数组中的内容有：“小明、小红、小强、小刚”，最后返回该数组；

• 在 Test.java 文件中，声明一个名为 com.test 的包，并导入 Student 类；

• 在该文件中的主方法中，调用 Student 类的 info 方法，遍历该数组后输出数组的信息。

代码 

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.pojo 的包
package com.pojo;

public class Student {
    public static String[] info(){
        // 实现返回所有学生的功能，在该方法中定义一个 String 数组
        String[] Array = {"小明","小红","小强","小刚"};
        
        // 返回该数组
        return Array;
    }
}
/********** End **********/

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.test 的包
package com.test;
// 导入 Student 类
import com.pojo.Student;

public class Test {
    public static void main(String[] args) {
        System.out.println("学生信息如下：");
        // 调用 Student 类的 info 方法，遍历数组
        for(String Array:Student.info()){
            System.out.println(Array);

        }
    }
}
/********** End **********/

练习-Java类和对象之包的定义 

任务描述

本关任务：定义一个电影类和一个电影测试类，在电影测试类中通过对象完成成员变量和成员方法的使用。

代码

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/

// 声明一个名为 com.model 的包
package com.model;
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
import java.util.Scanner;

// 定义一个 Movie 的公开类
public class Movie {
	// 该类具有电影名称、电影类别、电影时长、地区等属性（都是字符串类型、私有）
	private String movie;
	private String kinds;
	private String length;;
	private String area;

	// 定义获取和设置电影属性的方法

	public String getMovie() {
		return movie;
	}

	public void setMovie(String movie) {
		this.movie = movie;
	}

	public String getKinds() {
		return kinds;
	}

	public void setKinds(String kinds) {
		this.kinds = kinds;
	}

	public String getLength() {
		return length;
	}

	public void setLength(String length) {
		this.length = length;
	}

	public String getArea() {
		return area;
	}

	public void setArea(String area) {
		this.area = area;
	}

	// 定义获取电影信息的方法，无返回值
	public void getmovies() {
		
		System.out.printf("电影名称：%s，电影类别：%s，电影时长：%s，地区：%s。",movie,kinds,length,area);
		
		
	}
}

/********** End **********/

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.test 的包
package com.test;
// 导入 Movie 类
import com.model.Movie;
//导入 java.util.Scanner 类
import java.util.Scanner;

// 定义一个公开的 Test 类
public class Test {

	// 定义主方法
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		// 实例化 Movie 对象
		Movie m = new Movie();
		// 将键盘四次输入的电影信息赋值给 Movie 对象
		//Ctrl + z 上一步
		String movie = input.nextLine();
		String kinds = input.nextLine();
		String length = input.nextLine();
		String area = input.nextLine();

		m.setMovie(movie);
		m.setKinds(kinds);
		m.setLength(length);
		m.setArea(area);
		// 调用获取 Movie 信息的方法
		m.getmovies();
		
	}

}
/********** End **********/

 

 学习-Java类和对象之类的声明之学生类的定义

任务描述

本关任务：定义一个 Student 学生公开类，该类具有学号 id(int)，年龄 age(int)，grade(int) 等属性；它们所具有的行为有学习 study()，考试 examination()，讲话 tell()，它们都无返回值和传入的参数。

study 方法的功能为换行输出：学号为xx的学生正在学习。

examination 方法的功能为换行输出：xx年级正在考试。

tell 方法的功能为不换行输出：正在讲话的是一个xx岁的学生。

代码  

/**
 * 任务：定义一个 Student 学生公开类，该类具有学号 id(int)，年龄 age(int)，grade(int) 等属性；
 * 它们所具有的行为有学习 study()，考试 examination()，讲话 tell()，它们都无返回值和传入的参数。
 * 类名为：Student
 */
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
 
// 第一步：创建一个名为 Student 的公开类
public class Student {
// 第二步：定义学生的属性
    int id = 20110624;
    int age = 18;
    int grade = 12;
// 第三步：定义学生的行为方法
    public void study(){
        System.out.printf("学号为%d的学生正在学习。\n",id);
    }
    public void examination(){
        System.out.printf("%d年级正在考试。\n",grade);
    }
    public void tell(){
        System.out.printf("正在讲话的是一个%d岁的学生。",age);
    }
}
/********** End **********/

 练习-Java类和对象之类的声明之复数运算

任务描述

本关任务：求两个复数相加后的结果。

两个复数之间相加的运算法则：实部与实部相加，虚部与虚部相加。

代码 

/**
 * 任务：求两个复数相加后的结果。
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码

/********** Begin **********/

// 定义一个圆类，类名为 Complex
public class Complex {
	// 定义四个变量：real1、image1、real2、image2 分别表示第一个虚数的实部与虚部和第二个虚数的实部与虚部，类型为int
	int real1 = 0;
	int image1 = 0;
	int real2 = 0;
	int image2 = 0;

	// 定义一个成员方法，方法名为add，不带参数，实现两个复数相加，将实部结果与虚部结果用+拼接后返回，返回类型为String，
	public String add() {
		// 相加后结果如果有虚部，将计算结果的虚部后加上i
		// 如果没有虚部，只返回实部即可。
		// 如果没有实部，只返回虚部，将计算结果的虚部后加上i
		// 如果都没有值，返回零。
		int real3, image3;
		real3 = real1 + real2;
		image3 = image1 + image2;
		if (real3 != 0 && image3 != 0) {
			String str = Integer.toString(image3).concat("i");
			String str1 = Integer.toString(real3) +"+" + str;
			return str1;

		} else if (real3 == 0 && image3 != 0) {
			String str2 = Integer.toString(image3).concat("i");
			return str2;

		} else if (real3 != 0 && image3 == 0) {
			String str3 = Integer.toString(real3);
			return str3;

		} else {

			String str4 = Integer.toString(real3);
			return str4;
		}

	}

	public static void main(String[] args) {
		Complex c = new Complex();
        c.real1 = 10;
        c.image1 = 5;
        c.real2 = 18;
        c.image2 = 32;
        Complex c1 = new Complex();
        c1.real1 = 10;
        c1.image1 = 7;
        c1.real2 = -10;
        c1.image2 = 6;
        Complex c2 = new Complex();
        c2.real1 = 125;
        c2.image1 = -8;
        c2.real2 = 1;
        c2.image2 = 8;
        Complex c3 = new Complex();
        c3.real1 = 21;
        c3.image1 = 6;
        c3.real2 = -21;
        c3.image2 = -6;
        System.out.println("10+5i+18+32i的结果为："+c.add());
        System.out.println("10+7i+(-10)+6i的结果为："+c1.add());
        System.out.println("125+(-8i)+1+8i的结果为："+c2.add());
        System.out.print("21+6i+(-21)+(-6i)的结果为："+c3.add());
	}

}

学习-Java类和对象之构造方法与对象创建之求椭圆面积

任务描述

本关任务：已知椭圆的短半轴长为 15.50，长半轴的长为 20.00，计算椭圆面积。

椭圆的面积公式为S=πab，其中a、b分别为椭圆的短半轴长和长半轴长。

代码 

/**
 * 任务：已知椭圆的短半轴长为20.00，长半轴的长为15.50，计算椭圆面积。
 * 类名为：EllipseArea
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/

// 创建一个名为 EllipseArea 的公开类
// 定义椭圆的两个属性 ：短半轴长和长半轴长
public class EllipseArea {

	double Minor_semi_axis;
	double Long_half_shaft;

	public EllipseArea() {

	}

	// 定义一个显示有参构造方法，携带两个参数，分别表示为传来的短半轴的值和长半轴传来的值
	// 该方法实现将短半轴长和长半轴长分别初始化为携带的两个参数的值。
	public EllipseArea(double minor_semi_axis, double long_half_shaft) {
		Minor_semi_axis = minor_semi_axis;
		Long_half_shaft = long_half_shaft;
	}

// 定义一个方法，该方法实现计算椭圆的面积，并将其返回，返回值类型为double
	public double Area() {
		double s = Math.PI * Minor_semi_axis * Long_half_shaft;
		return s;
	}
// 定义主方法
// 在主方法中通过有参构造方法实例化一个对象，将椭圆的短半轴的值和长半轴的值传入其中
	// 调用计算椭圆的面积的方法，计算该椭圆的面积
	// 将计算后的结果四舍五入保留两位小数后输出，输出格式为：椭圆形的面积为xx
	public static void main (String[] args) {
		EllipseArea a = new EllipseArea();
		a.Long_half_shaft = 20.00;
		a.Minor_semi_axis = 15.50;
		a.Area();
		System.out.printf("椭圆形的面积为%.2f",a.Area());
	}
}


/********** End **********/

练习- Java类和对象之构造方法与对象创建之计算数学中的分数值

任务描述

本关任务：跟据键盘输入的分子和分母求出该分数的值。其中第一次输入的值为分子的值，第二次输入的值为分母的值，两次的值均为 int 型。

代码

/**
 * 任务：跟据键盘输入的分子和分母求出该分数的值。其中第一次输入的值为分子的值，第二次输入的值为分母的值，两次的值均为 int 型。
 * 类名为：Fraction
 */

import java.util.Scanner;
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/

// 创建一个名为 Fraction 的公开类
// 定义分数的两个属性 ：分子和分母
public class Fraction {
	int numerator;//分子
	int denominator;//分母
	
	/**
     * 定义一个方法，该方法实现计算该分数的值，携带两个参数，分别为传来的分子和分母的值
     * 如果分母为0，不换行输出：分母不能为0
     * 如果分母不为0，将该分数的值四舍五入保留两位小数后输出
     * 输出格式为：该分数的值为xx
     */
	public void value(int numerator,int denominator) {
		if (denominator == 0) {
			System.out.println("分母不能为0");
		}else if (denominator != 0) {
			
			double value = (double)numerator/denominator;
			System.out.printf("该分数的值为%.2f",value);
			
		}
	}
	// 定义主方法
	// 获取键盘传来的分子和分母的值
	// 在主方法中通过 Java 添加的无参构造方法定义一个对象
	// 调用计算分数值的方法，将获取到的分子和分母分别传入该方法中
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		
		int numerator = input.nextInt();
		int denomintar = input.nextInt();
		
		Fraction a = new Fraction();
		a.value(numerator, denomintar);
	}
	//无参构造方法
	public Fraction() {
		
	}
	
	
	
}
/********** End **********/

练习-Java类和对象之构造方法与对象创建之比较大小

任务描述

本关任务：比较键盘输入的两个 double 型的数值的大小，输出较大的值。

代码 

/**
 * 任务：比较键盘输入的两个 double 型的数值的大小，输出较大的值。
 * 类名为：Compare
 */

import java.util.Scanner;

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/

// 创建一个名为 Compare 的公开类
// 分别定义两个数
public class Compare {
	double num1;
	double num2;

	/**
	 * 定义一个方法，该方法实现比较两数大小，携带两个参数，分别为传来的两个数的值 将两个数中较大的那个数返回，返回类型为double
	 */
	public double whobiger(double num1, double num2) {

		if (num1 - num2 > 0) {
			return num1;
		} else if (num1 - num2 == 0) {
			return num1;
		} else {
			return num2;
		}

	}

	// 定义主方法
	// 获取键盘传来的两个数
	// 在主方法中通过无参构造方法定义一个对象
	// 调用比较大小的方法，获得较大的那个数
	// 不换行输出较大的那个数
	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);
		double num1 = input.nextDouble();
		double num2 = input.nextDouble();

		Compare a = new Compare();
		System.out.println(a.whobiger(num1, num2));

	}
//无参构造
	public Compare() {
		
	}
}

/********** End **********/

 学习-Java类和对象之static关键字之求圆环面积和周长

任务描述

本关任务：已知圆环的大圆半径 R 和 小圆半径 r 的长度分别为 32.0 和 10.0，求该圆环的面积和周长。

圆环面积公式为：S=π(R2−r2)； 圆环周长公式为：C=2π(R+r)。

 代码

/**
 * 任务：已知圆环的大圆半径 R 和 小圆半径 r 的长度分别为 32.0 和 10.0，求该圆环的面积和周长。
 * 类名为：RingArea
 */

public class RingArea {
    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
    /********** Begin **********/

    // 定义三个量，两个变量分别为大圆半径和小圆半径，常量表示，它的值可以调用 Math.PI获取，并将其设为静态常量。
	double s,l;
	static double π,R,r;
	
	 // 定义一个无参构造方法，将小圆半径设为 10.0，大圆半径设为32.0
	public RingArea() {
		R = 32.0;
		r = 10.0;
		π = Math.PI;
	}
    /**
     * 定义一个静态方法，该方法实现计算圆环的周长，携带两个参数，分别为传来的小圆半径和大圆半径的值。
     * 将圆环周长的计算结果返回，返回类型为double
     */
	public static double circumference(double R,double r) {
		double l =  2 * π * (R + r);
		return l;
		
	}
    
	/**
     * 定义一个静态方法，该方法实现计算圆环的面积，携带两个参数，分别为传来的小圆半径和大圆半径的值。
     * 将圆环面积的计算结果返回，返回类型为double
     */
	public static double square(double R,double r) {
		double s =  π * (Math.pow(R, 2) - Math.pow(r,2));
		return s;
		
	}
    // 定义主方法
    // 在主方法中通过定义的无参构造方法定义一个对象
    // 通过类名.方法名的方式调用计算圆环周长的方法，获取圆环周长，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
    // 通过类名.方法名的方式调用计算圆环面积的方法，获取圆环面积，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
	// 不换行四舍五入保留两位小数后格式化输出求出的值，输出格式：该圆环的周长为xx，面积为xx
	public static void main(String[] args) {
		RingArea a = new RingArea();
		System.out.printf("该圆环的周长为%.2f，面积为%.2f",RingArea.circumference(R, r),RingArea.square(R, r));
		//System.out.printf("该圆环的周长为%.2f，面积为%.2f",a.circumference(R, r),a.square(R, r));直接调用类名
	}
    /********** End **********/
}

练习-Java类和对象之static关键字之检验三边是否构成三角形

任务描述

本关任务：根据键盘输入的三个 double 型的数字判断其是否能构成三角形。

代码

import java.util.Scanner;

public class Triangle {
	// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
	/********** Begin **********/

	/**
	 * 定义一个静态方法，该方法检验三边是否能构成三角形，携带三个参数，分别为传来的三个参数，无返回值 如果能构成，不换行输出：这三条边可以构成三角形
	 * 如果不能，不换行输出：这三条边不能构成三角形
	 */
	public static void pan_duan(double a, double b, double c, boolean T, boolean J) {

		if (T && J) {
			System.out.println("这三条边可以构成三角形");
		} else {
			System.out.println("这三条边不能构成三角形");

		}
	}

	public boolean tiaojian1(double a, double b, double c) {
		if ((a + b) > c && a + c > b && b + c > a) {
			return true;
		} else {
			return false;
		}
	}

	public boolean tiaojian2(double a, double b, double c) {
		if (Math.abs(a - b) < c && Math.abs(a - c) < b && Math.abs(b - c) < a) {
			return true;
		} else {
			return false;
		}
	}

	// 定义主方法
	// 获取键盘输入的三个数
	// 通过类名.方法名的方式调用检验三边是否能构成三角形的方法，分别将键盘输入的三个数传入该方法中
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);

		double a = input.nextDouble();
		double b = input.nextDouble();
		double c = input.nextDouble();

		Triangle object = new Triangle();

		boolean T = object.tiaojian1(a, b, c);
		boolean J = object.tiaojian2(a, b, c);

		//object.pan_duan(a, b, c, T, J);
		Triangle.pan_duan(a, b, c, T, J);//类名调用
	}

	/********** End **********/
}

学习-Java类和对象之参数传值机制之求球面积

任务描述

本关任务：已知一个球的半径为 12.0，求该球的表面积。

球的表面积计算公式：S=4πR2,R为球的半径。

代码

/**
 * 任务：已知一个球的半径为 12.0，求该球的表面积。 类名为：Sphere
 */

public class Sphere {

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码

	/********** Begin **********/

	// 定义圆的半径和π，π为 Math中的π
	static double R = 12.0;
	double π = Math.PI;

	// 无参构造
	public Sphere() {

	}

	// 有参构造
	public Sphere(double r, double π) {
		R = r;
		this.π = π;
	}

	/**
	 * 定义一个方法，该方法实现计算球的表面积，返回值为double，携带一个参数，为球的半径
	 */
	public double square(double R) {

		return 4 * Math.PI * Math.pow(R, 2);
	}

	
	// 定义主方法
	// 通过无参构造创建球对象
	// 调用计算球面积的方法，将半径 r 的值传入
	// 四舍五入格式化不换行输出球的面积，输出格式：球的表面积为xx
	public static void main(String[] args) {
		Sphere ball  = new Sphere();//调用无参构造
		System.out.printf("球的表面积为%.2f",ball.square(R));

	}

	/********** End **********/

}

练习-Java类和对象之参数传值机制之求球体积

任务描述

本关任务：已知球的半径为 12.0，求球的体积。

球的体积公式：S=34​πR3，其中，R为球的半径。

代码

/**
 * 任务：已知一个球的半径为 12.0，求该球的体积。 类名为：Sphere
 */

public class Sphere {

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码

	/********** Begin **********/

	// 定义圆的半径和π，π为 Math中的π
	double R;
	double π;

	// 无参构造
	public Sphere() {

	}

	// 有参构造
	public Sphere(double r, double π) {
		R = r;
		this.π = π;
	}

	/**
	 * 定义一个方法，该方法实现计算球的体积，返回值为double，携带一个参数，为球的半径
	 * 
	 */
	public double Vball(double R) {
		return (4.0 / 3.0) * Math.PI * Math.pow(R, 3);

	}

	// 定义主方法
	// 通过无参构造创建球对象
	// 调用计算球体积的方法，将半径 r 的值传入
	// 四舍五入格式化不换行输出球的体积，输出格式：球的体积为xx
	public static void main(String[] args) {
		Sphere ball = new Sphere();
		System.out.printf("球的体积为%.2f",ball.Vball(12.0));
		//System.out.printf("球的体积为%.2f",ball.Vball(R));//构造方法，调用的方法为static时阔以用类名调用方法，
		//当调用的方法不为static方法时，只能实例化对象调用。不实例化对象，都不能调用
		//如果传入R那么R得是静态参数，值在构造方法赋值，一般不在构造方法，好像是封装
	}

	/********** End **********/

}

学习-Java类和对象之可变参数

任务描述

本关任务：编写程序输出考试学生的人数及姓名。

相关知识

可变参数：适用于参数个数不确定，类型确定的情况，Java 把可变参数当做数组处理。

可变参数必须位于最后一项。

原因：当可变参数个数多于一个时，必将有一个不是最后一项，所以只支持有一个可变参数。因为参数个数不定，所以当其后边还有相同类型参数时，Java 无法区分传入的参数属于前一个可变参数还是后边的参数，所以只能让可变参数位于最后一项。

代码

/**
 * 定义输出考试学生的人数及姓名的方法，方法名为 print，传参的类型为String，无返回值。
 */
public class Student2 {
 
	// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
	/********** Begin **********/
    public static void main(String[] args){
        Student2 student =new Student2();
        
        student.print("张强","李成","王勇");
        Student2.print("马丽","陈玲");
    } 
    
    public static void print(String ... names){
        int count = names.length;
        System.out.println("本次参加考试的有"+ count +"人，名单如下：");
        for(int i=0;i<names.length;i++){
            System.out.println(names[i]);
        }
    }  
 
	/********** End **********/
}

练习-Java类和对象之可变参数

任务描述

本关任务：定义一个名为 add 的静态方法，返回值为 int，参数数量可变，且为 int，将这些参数相加后返回。

代码

/* 定义一个名为 add 的静态方法，返回值为 int，参数数量可变，且为 int，将这些参数相加后返回。
 */

public class Add {
    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
    /********* Begin *********/
	public static int add(int ...nums ) {
		int sum = 0;
		for (int i = 0;i<nums.length;i++) {
			 
			sum = sum + nums[i];
		
		}
		return sum;
	}
	public static void main(String[] args) {
		//Add object = new Add();
		System.out.println("add(25,36)的值为：" + Add.add(25,36));
		System.out.println("add(58,96,754)的值为：" + Add.add(58,96,754));
	}


    /********** End **********/
}

学习-Java类和对象之对象组合之求圆柱体积

任务描述

本关任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。 圆柱的体积公式：S=πr2h。

代码

/**
 * 任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码

/********** Begin **********/
/*
出现The public type c must be defined in its own file这个问题，是由于定义的JAVA类同文件名不一致；
解决方法：
1、把文件名修改同公共类一样的名字；
2、把类名修改成同文件名；
3.子类继承父类时，不需要再用public修饰
~一个文件中有多个类，只有与文件名一致的类名，才能声明为：public
内部类不能声明为：public
一个文件中只能有一个public类*/

// 定义一个圆类，类名为 Circle
class Circle {
	// 定义两个量，分别为半径和π值
	double R;
	double π;

	// 有参构造器
	public Circle(double r, double π) {
		R = r;
		this.π = π;
	}

// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
	public double square() {

		double s = Math.PI * Math.pow(R, 2);
		return s;
	}

}

//定义一个公开的圆柱类 Cylinder
 public class Cylinder {

	// 定义圆柱中的高
	double high;

	// 引用圆类
	Circle s;

	// 有参构造
	public Cylinder(double high, Circle s) {
		this.high = high;
		this.s = s;
	}

	/**
	 * 定义一个方法，该方法实现计算圆柱的体积，返回值为double
	 */
	public double Cylindersquare(double high, Circle s) {

		return s.square() * high;
	}

	// 定义主方法
	public static void main(String[] args) {
		// 通过有参构造创建圆对象，将底面半径设置为 20
		double r = 20;
		double π = Math.PI;
		Circle s = new Circle(r, π);// π在定义时设为static，也阔以在main函数赋初值
		// 通过有参构造创建圆柱对象，将圆柱的高设置为 50，将圆对象传入
		double high = 50;
		Cylinder b = new Cylinder(50, s);
		// 调用计算圆柱积的方法
		double v = b.Cylindersquare(high, s);
		//四舍五入格式化不换行输出圆柱的体积，输出格式：圆柱的体积为xx
		System.out.printf("圆柱的体积为%.2f",v);
	}
}
/********** End **********/

练习-Java类和对象之对象组合之求圆锥体表面积

任务描述

本关任务：已知圆锥的母线长为 15，底面半径为 8，求圆锥的表面积。

圆锥的表面积公式为：πr2+πrl。

也就是底面积加上圆锥的侧面积

代码

/**
 * 任务：已知圆锥的母线为 15，底面半径为 8，求圆锥的表面积。
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码

/********** Begin **********/

// 定义一个圆类，类名为 Circle
class Circle {
	// 定义两个量，分别为半径和π值
	double π;
	double R;

	// 有参构造器
	public Circle(double π, double r) {
		this.π = π;
		R = r;
	}

	// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
	public double yuan_square() {

		double s = π * Math.pow(R, 2);
		return s;

	}

}

// 定义一个扇形类，类名为 Sector
class Sector {
	double l;
	double R;

	// 有参构造器,定义的参数都要用到
	public Sector(double l, double r) {
		this.l = l;
		R = r;
	}

	// 定义一个方法，实现求圆锥侧面积，将侧面积返回，返回类型为double，
	public double s_che_mian() {

		double s_che = Math.PI * R * l;
		return s_che;
	}

	
}

// 定义一个公开的圆锥类 Cone
public class Cone {

	// 导入圆类和扇形类，有参构造
	Circle s;
	Sector c;

	public Cone(Circle s, Sector c) {
		this.s = s;
		this.c = c;
	}

	/**
	 * 定义一个方法，该方法实现计算圆锥的表面积，返回值为double
	 */
	public double s_total() {

		double s_total = s.yuan_square() + c.s_che_mian();
		return s_total;
	}

	// 定义主方法
	public static void main(String[] args) {
		// 通过有参构造创建圆对象，将底面半径设置为 8
		double π = Math.PI;
		double r = 8;
		Circle s = new Circle(π, r);
		// 通过有参构造创建扇形对象，将扇形所需的半径和母线传入
		double l = 15;
		Sector c = new Sector(l,r);
		// 通过有参构造创建圆锥对象，将圆对象和矩形对象传入
		Cone cone = new Cone(s, c);
		// 调用计算圆锥表面积的方法
		// 四舍五入格式化不换行输出圆锥表面积，输出格式：圆锥的表面积为xx
		//System.out.println(s.yuan_square());
		//System.out.println( c.s_che_mian());
		System.out.printf("圆锥的表面积为%.2f", cone.s_total());

	}
}

/********** End **********/

学习-Java类和对象之this关键字

任务描述

本关任务：编写一个商品结算的小程序。

this 关键字

大部分时候，普通方法访问其他方法、成员变量时无需使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用 this 前缀。

代码 

/**
 * 任务：编写一个商品结算的小程序
 * 类名为：Shop
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/

public class Shop {
    // 定义该商品的两个属性：价格（double）和数量（int）
	double price;
	int tatol;

    // 将形参的值赋值给成员变量
    public Shop(double price, int total) {
    	this.price = price;
    	this.tatol = total;
    }

    // 该方法实现计算价钱的功能，将计算结果返回，价钱 = 价格 * 数量
    public double sum() {
    	double sum = price * tatol;
    	return sum;
    }
}

/********** End **********/

练习-Java类和对象之this关键字 

任务描述

本关任务：定义一个完整的学生类，该类定义了学生的基本信息。

代码

/**
 * 任务：定义一个完整的学生类，该类定义了学生的基本信息。
 * 类名为：Student
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/

// 创建一个名为 Student 的公开类

public class Student {
    // 定义学生的两个属性：姓名（name String）和年龄（age int）
	String name;
	int age;
	// 获取学生年龄
    public int getAge() {
        return age;
    }
    // 设置学生的年龄，将形参的值赋值给成员变量
    public void setAge(int age) {
    	this.age = age;
    }
	// 获取学生姓名
    public String getName() {
        return name;
    }
    // 设置学生姓名，将形参的值赋值给成员变量
    public void setName(String name) {
    	this.name = name;
    }

    // 该方法实现输出学生信息的功能。 输出格式：学生姓名：xx，年龄：xx
    public void info() {
    	System.out.printf("学生姓名：%s，年龄：%d",name,age);
    }
}

/********** End **********/

学习-Java类和对象之访问限制

任务描述

本关任务：实现图书类，该类包含了图书的基本属性和信息。

代码 

/**
 * 任务：实现图书类，该类包含了图书的基本属性和信息。
 * 类名为：Book
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
public class Book {
    // 定义四个私有变量
    // 图书名称（bookName String）
    // 图书单价（price double）
    // 图书库存（total int）
    // 图书id（bookId int）
	private String bookName;
	private double price;
	private int total;
	private int booked;
	private int bookId;


    // 获取图书名称
    public String getBookName() {
    	return bookName;
    }
    // 设置图书名称
    public void setBookName(String bookName) {
    	this.bookName = bookName;
    }
    // 获取图书单价
    public double getPrice() {
    	return price;
    }
    // 设置图书单价
    public void setPrice(double price) {
    	this.price = price;
    }
    // 获取图书库存
    public int getTotal() {
    	return total;
    }
    // 设置图书库存
    public void setTotal(int total) {
    	this.total = total;
    }
    // 获取图书id
    public int getBookId() {
    	return bookId;
    }
    // 设置图书id
    public void setBookId(int bookId) {
    	this.bookId = bookId;
    }
    
}
/********** End **********/

练习-Java类和对象之访问限制 

任务描述

本关任务：实现一个电影类。

代码

/**
 * 任务：实现一个电影类
 * 类名为：Movie
 */

// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/

public class Movie {
	// 定义6个变量
	// 电影id（id int） 电影名称（movieName String） 电影类型（movieType String）
	// 电影评分（double score） 电影时长（totalTime int） 电影简介（content String）
	int id;
	String movieName;
	String movieType;
	double score;
	int totalTime;
	String content;
	
	// 定义设置和获取6个变量值的方法
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getMovieName() {
		return movieName;
	}
	public void setMovieName(String movieName) {
		this.movieName = movieName;
	}
	public String getMovieType() {
		return movieType;
	}
	public void setMovieType(String movieType) {
		this.movieType = movieType;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
	public int getTotalTime() {
		return totalTime;
	}
	public void setTotalTime(int totalTime) {
		this.totalTime = totalTime;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}


}
/********** End **********/

学习-Java类和对象之对象数组 

任务描述

任务描述
本关任务：定义一个 Dog 类，使用对象数组的方式创建 3 个 Dog 对象。

相关知识
所谓的对象数组，就是指包含了一组相关的对象。在使用对象数组的时候，一定要清楚一点：一定要先为数组开辟空间。因为其是引用数据类型，所以数组里面的每一个对象都是 null 值，在使用的时候，数组中的每一个对象必须分别进行实例化操作。

定义对象数组的四个方式：

静态初始化；
类名称 对象数组名[] = new 类名称[] {对象，对象......};

// 创建对象数组的时候直接创建对象
Person person[] = new Person[]{new Person(),new Person(),new Person()}
动态初始化；

// 先引用一个对象数组
Person person[];
// 指定数组对象的大小
person = new Person[3];
// 循环为数组中的每一个对象进行实例化
for(int i=0;i<person.length;i++)
{
person[i] = new Person();
}
数组元素指向所定义的对象；

// 引用一个数组对象
Person person[];
// 为数组开辟一个指定大小的空间
person = new Person[3];
// 对数组的每一个对象进行实例化
person[0] = new Person();
person[1] = new Person();
person[2] = new Person();
创建对象数组，并分配对象空间。

// 创建对象数组时指定空间大小
Person person[] = new Person[3];
// 对数组的每一个对象进行实例化
person[0] = new Person();
person[1] = new Person();
person[2] = new Person();

代码

/**
 * 任务：使用对象数组的方式创建 3 个 Dog 对象
 * 类名为：Dog
 * 该类为 Dog 的基本属性
 */
public class Dog {
    private String name;     // 小狗名称
    private String type;     // 小狗品种
    private int age;     // 小狗年龄
    private String hobby;    //小狗爱好

    public Dog(){

    }
    public Dog(String name, String type, int age, String hobby) {
        this.name = name;
        this.type = type;
        this.age = age;
        this.hobby = hobby;
    }
	
    // 获取Dog姓名
    public String getName() {
        return name;
    }

    // 设置Dog姓名
    public void setName(String name) {
        this.name = name;
    }
	// 获取Dog种类
    public String getType() {
        return type;
    }
	// 设置Dog种类
    public void setType(String type) {
        this.type = type;
    }
	// 获取Dog年龄
    public int getAge() {
        return age;
    }
	// 设置Dog年龄
    public void setAge(int age) {
        this.age = age;
    }
	
    // 获取爱好
    public String getHobby() {
        return hobby;
    }
	// 设置爱好
    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
	// Dog的详细信息
    public void info(){
        System.out.printf("小狗名称：%s\n品种：%s\n小狗年龄：%d\n小狗爱好：%s\n",name,type,age,hobby);
    }



    public static void main(String[] args) {
        Dog d1 = new Dog("Tom", "哈士奇",2,"拆家");
        Dog d2 = new Dog("jerry", "中华田园犬",3,"护家");
        Dog d3 = new Dog("旺财","柯基",2,"吃喝玩");
        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
        /********** Begin **********/
        // 将三个狗的对象放进对象数组中，并依次调用该对象的info方法
        Dog dog[] = new Dog[] {new Dog(),new Dog(),new Dog()};
        d1.info();
        d2.info();
        d3.info();
        
        
        /********** End **********/
    }
}

练习-Java类和对象之对象数组 

任务描述

本关任务：将键盘输入的三个学生的信息存入 Student 对象中，最后将这些学生信息按右侧预期输出格式打印输出。

代码

import java.util.Scanner;

public class Student {
	private String name; // 学生的姓名
	private String num; // 学生的学号信息
	private double grades; // 学生的成绩
	
	// 有参构造方法
	
	public Student(String name, String num, double grades) {
		this.name = name;
		this.num = num;
		this.grades = grades;
	}

	// 获取和设置学生的属性信息
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getNum() {
		return num;
	}

	public void setNum(String num) {
		this.num = num;
	}

	public double getGrades() {
		return grades;
	}

	public void setGrades(double grades) {
		this.grades = grades;
	}
	
	 public void info(){
	        System.out.printf("姓名：%s	学号：%s	成绩：%.1f\n",name,num,grades);
	    }
	 
	public static void main(String[] args) {
		// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
		/********** Begin **********/
		
		// 创建可以存放三个对象的对象数组
		Student stu[] = new Student[3];
		// 获取键盘输入的学生信息，将数组中的对象进行实例化
		//for 循环实例化stu
		Scanner input = new Scanner(System.in);
		for(int i =0;i<stu.length;i++) {
			
			String str = input.nextLine();
			String[] Array = str.split(",");
			stu[i] = new Student(Array[0],Array[1],Double.valueOf(Array[2]));
			
		}
		// 打印输出每个学生的信息
		//增强for 输出遍历
		for (Student i: stu) {
			i.info();
		}
		/********** End **********/
	}
}