educoder(头歌)实训平台Java实训作业答案

Java语言基础(一) - JAVA初体验

第一关

public class HelloWorld{
	 /********* Begin *********/
     public static void main(String[] args) {
        System.out.println("姓名:张三");
        System.out.println("年龄:25");
        System.out.println("职业:JAVA高级工程师");
        System.out.println("薪资:15K");
     }
     
     
     /********* End *********/
}

第二关
C
C
D
BC

第三关

package key;
/********* Begin *********/
public class HelloWorld {
    public static void main(String[] args){
		System.out.println("hello eduCoder");
	}
}
/********* End *********/

第四关
ABD
A

第五关

package chapter2;
/********* Begin *********/
public class HelloWorld {
	
	String userName = "张三";
    
	public static void main(String[] args){
		System.out.println("hello eduCoder");
	}
}

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

第六关
CD
D

第七关

package chapter2;

public class HelloEduCoder {
	/********* Begin *********/
	public static void main(String[] args) {
		// System.out.println("hello world");
		System.out.println("www.educoder.net");
		// System.out.println("educoder.net");
		// System.out.println("www.educoder");
		// System.out.println(".net");
		// System.out.println("www");
	}
    /********* End *********/
}

第八关
ADE
D

Java语言基础(二) - 变量与数据类型

第一关

package chapter2.step1;

public class HelloWorld{
	public static void main(String[] args){
 		/********* Begin *********/
        String love = "www.educoder.net";
        System.out.print(love);
 		/********* End *********/    
	}
}

第二关

package chapter2;

public class HelloVariable {
	public static void main(String[] args) {
		/********* Begin *********/
		String love = "我喜欢在educoder上学习";	//在这里定义变量 love 并赋初值为 我喜欢在educoder上学习
		/********* End *********/
		System.out.println("变量love的值为" + love);
		String userName = "张无忌";
		/********* Begin *********/
		userName = "李四";			//在这一行将userName的值改成李四
		/********* End *********/			
		System.out.println("重新赋值后变量userName的值为" + userName);
	}
}

第三关
BD
C

第四关

package chapter2;

public class JavaDataType1 {
	public static void main(String[] args) {
		/********* Begin *********/
			//在本行定义字符串变量name
		
		    //在本行定义年龄变量 age
		
         	//在本行定义性别变量 sex	
		
			//在本行定义分数变量  score
		/********* End *********/
		System.out.println("张无忌23岁性别:男这次考了66.6分");
	}
}	
	

第五关

package chapter2;

public class JavaDataType1 {
	public static void main(String[] args) {
		/********* Begin *********/
			//在本行定义字符串变量name
		
		    //在本行定义年龄变量 age
		
         	//在本行定义性别变量 sex	
		
			//在本行定义分数变量  score
		/********* End *********/
		System.out.println("张无忌23岁性别:男这次考了66.6分");
	}
}	
	

第六关
CD
CD
AD

第七关

package chapter2.step7;
/********* Begin *********/
//1.导入Scanner
/********* End *********/
public class HelloWorld{
	public static void main(String[] args){
		/********* Begin *********/

        System.out.println("请录入嫦娥个人信息:");
        System.out.println("请输入姓名:");

        System.out.println("请输入年龄:");

        System.out.println("请输入性别:");

        System.out.println("请输入体重:");

        System.out.println("请输入地址:");

        System.out.println("请输入是否已婚:");
        System.out.println("信息如下:");
        System.out.println("\t姓名:嫦娥");
        System.out.println("\t年龄:3500岁");
        System.out.println("\t性别:女");
        System.out.println("\t体重:45.5kg");
        System.out.println("\t地址:月球广寒宫");
        System.out.println("\t婚否:否");
        


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

Java语言基础(三)- 运算符和表达式

第一关

package step1;
import java.util.Scanner;

public class Cal {
	public static void main(String[] args) {
		/*********start*********/
		Scanner i = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int a = i.nextInt();
        System.out.println("请输入第二个整数");
        int b = i.nextInt();
        System.out.println("两数相加的结果为:" + (a + b));
        System.out.println("两数相减的结果为:"+ (a-b));
        System.out.println("两数相乘的结果为:" + (a*b));
        System.out.println("两数相除的结果为:" + (a/b));
        System.out.print("两数取余数的结果为:" + (a%b));

		
		
		/*********end*********/
	}

}

第二关

package step2;
import java.util.Scanner;

public class Relative {
	public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        int b=sc.nextInt();
        /*********start*********/
		System.out.println("a==b=" + (a==b));
        System.out.println("a!=b=" + (a!=b));
        System.out.println("a>b=" + (a>b));
        System.out.println("a + (a<b));
        System.out.println("b>=a=" + (b>=a));
        System.out.println("b<=a=" + (b<=a));
		
		
		/*********end*********/
	}

}

第三关

package step3;
import java.util.Scanner;



public class testLogic {
	public static void main(String[] args) {
        
		Scanner sc=new Scanner(System.in);
  		boolean a=sc.nextBoolean();
        boolean b=sc.nextBoolean();
        boolean c=sc.nextBoolean();
        
		/*********start  *********/
        
        System.out.println(!a);    
        
        System.out.println("false");  
        
        System.out.println( c || b );	
        
        System.out.println( "true" );        
		/*********end  *********/
	}

}

第四关

package step4;

import java.util.Scanner;

public class TestYear {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
        int year=sc.nextInt();
        boolean result;
        /********start********/
        
        result=    (year%4 == 0)   ;
        
        System.out.println(year + "年是否为闰年:" + result);
        
        /********end********/
	}

}

第五关

package step5;
import java.util.Scanner;

public class TestDemo5 {
	public static void main(String[] args) {
			Scanner sc=new Scanner(System.in);
		System.out.println("输入:");
		int m=sc.nextInt();
		int n=sc.nextInt();
		
		System.out.println("输出:");
        
		/*****start*****/
		
		System.out.println( (m+n)*2 );
        
		System.out.println( (m-n)%3 );
		
		System.out.println(((m-n)/2 + (m+n)*2));
		
		/*****end*****/
	}

}

第六关
D
B
A
C
C
A
A

Java语言基础(四)- 分支结构

第一关

package step2;

import java.util.Scanner;

public class HelloIfStep2 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		/******start******/
		System.out.println("请输入学员成绩:");
		int s = input.nextInt();
        if(s >= 85){
            System.out.println("优,非常棒!");

        }else{
            System.out.println("良,下次加油!");
        }
		
		
		
		
		/******end******/
	}
}

第二关
C
C
D

第三关

package step3;

import java.util.Scanner;

public class HelloStep3 {
	public static void main(String[] args) {
		System.out.println("星级成绩评定系统");
		System.out.println("请输入成绩:");
		Scanner sc = new Scanner(System.in);
        int sco = sc.nextInt();
		/******start******/
        if(sco>=90){
            System.out.println("*****五星成绩");
        }else if(sco >= 80){
            System.out.println("****四星成绩");
        }else if(sco>=70){
            System.out.println("***三星成绩");
        }else if(sco >=60){
            System.out.println("**俩星成绩");
        }else{
            System.out.println("无星成绩");
        }
		
		
		
		
		
		
		/******end******/
	}
}

第四关

package step4;

import java.util.Scanner;

public class HelloSwitch {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入月份:");
		
		int input = sc.nextInt();	//获取输入的月份
		
        //通过输入的月份来判断当前季节并输出
		/*****start*****/
		switch(input){
            case 12:
            case 1:
            case 2:
                System.out.println(input + "月是冬天");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println(input + "月是春天");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println(input + "月是夏天");
                break;
            default:
            System.out.println(input + "月是秋天");
            break;
        }
	
		
		/*****end*****/
		
	}
}

第五关
CD

第六关

package step5;

import java.util.Scanner;

public class Practice {
    
    	final static Scanner sc = new Scanner(System.in);	//创建扫描仪

		//第一题
		public void first(){
			System.out.println("请输入人数:");
            int input = sc.nextInt();		//获取输入的数据
            
			/*****start*****/
			if(input<10){
                System.out.println("打半场");
            }else{
                System.out.println("打全场");
            }
			
			
			
			
			/*****end*****/
		}
		
		//第二题
		public void second(){
			System.out.println("请输入今天星期几:");
            int input = sc.nextInt();		//获取输入的数据
            
			/*****start*****/
            if(input == 1){
                System.out.println("今天吃米饭");
            }else if(input == 2){
                System.out.println("今天吃牛排");
            }else if(input == 3){
                System.out.println("今天吃鸡排");
            }else{
                System.out.println("今天吃红烧肉");
            }
			

			
			/*****end*****/
		}	
		
		//第三题
		public void third(){
			System.out.println("请输入今天星期几:");
            int input = sc.nextInt();		//获取输入的数据
            
			/*****start*****/
            switch(input){
                case 1: System.out.println("今天吃米饭");break;
                case 2: System.out.println("今天吃牛排");break;
                case 3:System.out.println("今天吃鸡排");break;
                default:System.out.println("今天吃红烧肉");break;
            }
			
			
			
			/*****end*****/
		}
}

Java语言基础(五)- 循环结构基础

第一关

package step1;

public class HelloWorld {
	public static void main(String[] args) {
		
		/**********Begin**********/
        for(int i=1;i<7;i++){
            System.out.println("做了" + i +"个俯卧撑");
        }
        /**********End**********/	
		
		
		
		
	}
}

第二关

package step2;

public class HelloWorld {
	public static void main(String[] args) {
		/**********Begin**********/
        System.out.print("1到100相加的结果为5050");


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

第三关

package step3;

public class HelloWorld {
	public static void main(String[] args) {
		int count= 0;	//定义变量存储6的倍数出现的次数
		/*****start*****/
		
		

		
		/*****end*****/
		System.out.println("6的倍数出现的次数为:16");
	}
}

第四关
B
C
B

第五关

package step4;

public class HelloWorld {
	public static void main(String[] args) {
		
		int i = 0;
		
		while(i <= 20){
			i++;
			/*****start*****/
			if(   i%2 == 0  ){
                System.out.println( i + "是偶数");
                continue;
            
			}
			System.out.println(i + "是奇数");
			
            if(   i == 13  ) {
                break;
            }
			
			/*****end*****/
		}
		
	}
}

第六关
C

第七关

package step5;

import java.util.Scanner;

public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请给定一个自然数N:");
		int N = sc.nextInt();//获取输入的整数N
		int sum = 1;		
		/*****start*****/
		for(int i=1 ; i<=N ;i++){
            sum=sum*i;
        }
		
		
		
		
		
		/*****end*****/
		
		System.out.println("自然数N的阶乘为" + sum);
	}
}

第八关
B

Java语言基础(六)- 循环结构进阶

第一关

package step1;

public class ForPractice1 {
	public static void test() {
		/*****start*****/
		for(int i=0;i < 10;i++){
            for(int j=0;j < 10;j++){
                System.out.print("*");
            }
            System.out.println();
        }
		
		
		
		/*****end*****/
	}
}

第二关

package step2;

public class ForPractice2 {
	public static void main(String[] args) {
		/*****start*****/
		
		//在这里打印出正三角形 
		for(int i=0;i < 10;i++){
            for(int j=0;j <= i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
		
		
		
		System.out.println("——————————我是华丽的分界线——————————");
		//在这里打印出倒三角形
		for(int i=9;i >= 0;i--){
            for(int j=0;j <= i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
		
		
		
		
		/*****end*****/
	}
}

第三关

package step3;

public class ForPractice3 {
	public static void main(String[] args) {
		/*****start*****/
            for(int i=1;i < 10;i++){
                for(int j=1;j <= i;j++){
                    System.out.print(j + "*" + i + "=" + (i*j) + "\t");
                }
            System.out.println();
        }
		
		
		
		
		/*****end*****/
	}
}

第四关

package step4;

import java.util.Scanner;

public class ForPractice4 {
	public static void main(String[] args) {
		/*****start*****/
		System.out.println("欢迎使用中国人民银行ATM取款机");
        Scanner i = new Scanner(System.in);
        int sum = 1000;
        int a=2;
        while(a==2){
            System.out.println("输入取款金额:");
            int out = i.nextInt();
            if(out>sum){
                System.out.println("目前余额:" + sum + "无法满足您的取款需求!");
            }else{
                System.out.println("剩余金额:" + (sum-out) + ",是否继续(\'1\':结束,\'2\':继续):");
                a = i.nextInt();
                sum-=out;
            } 
        }
        System.out.print("取款结束!");
		/*****end*****/
	}
}

第五关
D
BC
B

Java面向对象(一) - 类与对象

第一关

package step1;

public class Test {
	public static void main(String[] args) {
		//创建Dog对象
		//设置Dog对象的属性
		Dog dog = new Dog();
        dog.name = "五花肉";
        dog.color = "棕色";
        dog.variety = "阿拉斯加";
		
		//输出小狗的属性
		System.out.println("名字:" +   dog.name  + ",毛色:" +  dog.color  + ",品种:" + dog.variety );
		
		//调用方法
		dog.eat();
        dog.run();
	}
}

//在这里定义Dog类
class Dog{
    String name;
    String color;
    String variety;
    void eat(){
        System.out.println("啃骨头");
    }
    void run(){
        System.out.println("叼着骨头跑");
    }
}

第二关

package step2;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String name = sc.next();
		String sex = sc.next();
		
		//分别使用两种构造器来创建Person对象  
		Person person1 = new Person();
        

        Person person2 = new Person(name,sex);

		
		
	}
}

//创建Person对象,并创建两种构造方法
class Person{
    String name;
    String sex;
    public Person(){
        System.out.println("一个人被创建了");
    }
    public Person(String name,String sex){
        this.name = name;
        this.sex = sex;
        System.out.print("姓名:" + name + ",性别:" + sex + ",被创建了");
    }
}

第三关
C
CD

第四关

package step3;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String name = sc.next();
		int age = sc.nextInt();
		String sex = sc.next();
		Person p = new Person(name,age,sex);
		p.display();
	}
}

class Person{
	String name = "张三";
	int age = 18; 
	String sex = "男";
// 请在此编写代码
/********** Begin **********/	
	public Person(String name,int age,String sex){
		this(age);
		this.name = name;
		this.sex = sex;
	}
	
	public Person(int age){
		this.age = age;
	}
/********** End **********/	
	
	public void display(){
		System.out.println("name:" + name);
		System.out.println("age:" + age);
		System.out.println("sex:" + sex);
	}
}

第五关

package step4;

import java.util.Scanner;

public class Test {
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String theMa = sc.next();
		int quantity = sc.nextInt();
		boolean likeSoup = sc.nextBoolean();

		//使用三个参数的构造方法创建WuMingFen对象  取名 f1
        WuMingFen f1 = new WuMingFen(theMa, quantity, likeSoup);
		//使用两个参数的构造方法创建WuMingFen对象  取名 f2
        WuMingFen f2 = new WuMingFen(theMa, quantity);
		//使用无参构造方法创建WuMingFen对象  取名 f3
		WuMingFen f3 = new WuMingFen();
            f3.theMa = "酸辣";
            f3.quantity = 2;
            f3.likeSoup = true;
        
		//分别调用三个类的 check方法
		f1.check();
        f2.check();
        f3.check();
	}
}

		//在这里添加包名  step4
package step4;
		//创建类 添加属性和方法
public class WuMingFen{
    String theMa;
    int quantity;
    boolean likeSoup;
    public WuMingFen(){
        
    }
    public WuMingFen(String theMa, int quantity, boolean likeSoup){
        this.theMa = theMa;
        this.quantity = quantity;
        this.likeSoup = likeSoup;
    }
    public WuMingFen(String theMa, int quantity){
        this.theMa = theMa;
        this.quantity = quantity;
    }
    public void check(){
        System.out.println("面码:" + theMa + ",粉的份量:" + quantity + "两,是否带汤:" + likeSoup);
    }
}

第六关

package step5;

public class Test {
	
	static String name = "楚留香";
	static
	{
		System.out.println("hello educoder");
	}
	public static void main(String[] args) {
		System.out.println("我叫" + name);
		study();
	}
	
	public static void study(){
		System.out.println("我喜欢在educoder上学习java");
	}
	
}

第七关
D
EG
B

Java面向对象(二) - 封装、继承和多态

第一关

package case1;

public class TestPersonDemo {
	public static void main(String[] args) {
		/********* begin *********/
		// 声明并实例化一Person对象p
		Person p1=new Person();
		// 给p中的属性赋值
		String name=p1.getName();
		name="张三";
		p1.setName(name);
		int age=p1.getAge();
		age=18;
		p1.setAge(age);
		// 调用Person类中的talk()方法
		p1.talk();
		/********* end *********/
	}
}
// 在这里定义Person类
class Person {
	/********* begin *********/
	private String name;
	private int 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 talk(){
		System.out.println("我是:"+name+",今年:"+age+"岁");
	}
	/********* end *********/
}

第二关

package case2;

public class extendsTest {
	public static void main(String args[]) {
		// 实例化一个Cat对象,设置属性name和age,调用voice()和eat()方法,再打印出名字和年龄信息
		/********* begin *********/
		Cat c=new Cat("大花猫",6);
		c.voice();
		c.eat();
		c.show();
		/********* end *********/
		// 实例化一个Dog对象,设置属性name和age,调用voice()和eat()方法,再打印出名字和年龄信息
		/********* begin *********/
		Dog d=new Dog("大黑狗",8);
		d.voice();
		d.eat();
		d.show();
		/********* end *********/
	}
}
class Animal {
	/********* begin *********/
	String name;
	int age;
	/********* end *********/
}
class Cat extends Animal {
	// 定义Cat类的voice()和eat()方法
	/********* begin *********/
    Cat(String name,int age){
		this.name=name;
		this.age=age;
	}
	void voice(){
		System.out.println(name+"喵喵叫");
	}
	void eat(){
		System.out.println(name+"吃鱼");
	}
	void show(){
		System.out.println(name+age+"岁");
	}
	/********* end *********/
}
class Dog extends Animal {
	// 定义Dog类的voice()和eat()方法
	/********* begin *********/
    Dog(String name,int age){
		this.name=name;
		this.age=age;
	}
	void voice(){
		System.out.println(name+"汪汪叫");
	}
	void eat(){
		System.out.println(name+"吃骨头");
	}
	void show(){
		System.out.println(name+age+"岁");
	}
	/********* end *********/
}

第三关

package case3;

public class superTest {
	public static void main(String[] args) {
		// 实例化一个Student类的对象s,为Student对象s中的school赋值,打印输出信息
		/********* begin *********/
		Student s=new Student("张三",18);
		s.school="哈佛大学";
		s.print();
		/********* end *********/
	}
}
class Person {
	/********* begin *********/
	String name;
	int age;
	Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	/********* end *********/
}
class Student extends Person {
	/********* begin *********/
	Student(String name,int age){
		super(name,age);
	}
	String school;
	void print(){
		System.out.println("姓名:"+name+",年龄:"+age+",学校:"+school);
	}
	/********* end *********/
}

第四关

package case4;

public class overridingTest {
	public static void main(String[] args) {
		// 实例化子类对象s,调用talk()方法打印信息
		/********* begin *********/
		Student s=new Student("张三",18,"哈佛大学");
		s.talk();
		/********* end *********/
		
	}
}

class Person {
	/********* begin *********/
	public String name;
	public int age;
	void talk(){
		System.out.println("我是:"+name+",今年:"+age+"岁");
	}
	/********* end *********/
}

class Student extends Person {
	/********* begin *********/
	String school;
	Student(String name,int age,String school){
		this.name=name;
		this.age=age;
		this.school=school;
	}
	void talk(){
		System.out.println("我是:"+name+",今年:"+age+"岁,我在"+school+"上学");
	}
	/********* end *********/
}

第五关

package case5;

public class abstractTest {
	public static void main(String[] args) {
		/********* begin *********/
		// 分别实例化Student类与Worker类的对象,并调用各自构造方法初始化类属性。
		Student s=new Student("张三",20,"学生");
		Worker w=new Worker("李四",30,"工人");
		s.talk();
		w.talk();
		// 分别调用各自类中被复写的talk()方法 打印信息。
		/********* end *********/
	}
}

// 声明一个名为Person的抽象类,在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
	/********* begin *********/
	String name;
	int age;
	String occupation;
	abstract void talk();
	/********* end *********/
}

// Student类继承自Person类,添加带三个参数的构造方法,复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
	/********* begin *********/
	Student(String name,int age,String occupation){
		this.name=name;
		this.age=age;
		this.occupation=occupation;
		}
	void talk(){
		System.out.println("学生——>姓名:"+name+",年龄:"+age+",职业:"+occupation+"!");
	}
	/********* end *********/
}

// Worker类继承自Person类,添加带三个参数的构造方法,复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
	/********* begin *********/
	Worker(String name,int age,String occupation){
		this.name=name;
		this.age=age;
		this.occupation=occupation;
	}
	void talk(){
		System.out.println("工人——>姓名:"+name+",年龄:"+age+",职业:"+occupation+"!");
	}
	/********* end *********/
}

第六关

package case6;

public class finalTest {
	public static void main(String args[]) {
		Bike1 obj = new Bike1();
		obj.run();

		Honda honda = new Honda();
		honda.run();

		Yamaha yamaha = new Yamaha();
		yamaha.run();
	}
}
//不可以修改 final 变量的值
// final方法,不可以重写
 不可以扩展 final 类
class Bike1 {
	final int speedlimit = 90;

	void run() {
		// speedlimit = 120; 
		System.out.println("speedlimit=120");
	}

}

// class Bike2 {
// 	final void run() {
// 		System.out.println("running");
// 	}
// }

class Honda /* extends Bike2 */{
	void run() { 
		System.out.println("running safely with 100kmph");
	}

}

// final class Bike3 {
// }

class Yamaha /* extends Bike3 */{ 
	void run() {
		System.out.println("running safely with 100kmph");
	}

}

第七关

package case7;

public class interfaceTest {
	public static void main(String[] args) {
		// 实例化一Student的对象s,并调用talk()方法,打印信息
		/********* begin *********/
        Student s = new Student();
        s.talk();
		/********* end *********/

	}
}

// 声明一个Person接口,并在里面声明三个常量:name、age和occupation,并分别赋值,声明一抽象方法talk()
interface Person {
	/********* begin *********/
    String name = "张三";
    int age = 18;
    String occupation = "学生";
    public abstract void talk();
	/********* end *********/
}

// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
	/********* begin *********/
    public void talk(){
        System.out.println("学生——>姓名:" + name + ",年龄:" + age + ",职业:" + occupation + "!");
    }
	/********* end *********/
}

第八关

package case8;

public class TestPolymorphism {
	public static void main(String[] args) {
		// 以多态方式分别实例化子类对象并调用eat()方法
		/********* begin *********/
        new Dog().eat();
        new Cat().eat();
        new Lion().eat();
		/********* end *********/
	}
}

// Animal类中定义eat()方法
class Animal {
	/********* begin *********/
    public void eat(){}
	/********* end *********/
}

// Dog类继承Animal类 复写eat()方法
class Dog extends Animal {
	/********* begin *********/
    public void eat(){
        System.out.println("eating bread...");
    }
	/********* end *********/
}

// Cat类继承Animal类 复写eat()方法
class Cat extends Animal {
	/********* begin *********/
    public void eat(){
        System.out.println("eating rat...");
    }
	/********* end *********/
}

// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
	/********* begin *********/
    public void eat(){
        System.out.println("eating meat...");
    }
	/********* end *********/
}

思政 -1 :科技 --> 人工智能

第一关
ABD
ABC

第二关
A
ABCD

第三关
ABCD
ABCD

第四关
ABD
ABC

第五关
A
ABCD

第六关
ABCD
ABC

第七关
ABCD
A

第八关
ABCD
AB

第九关
ABCD
ABCD

第十关
ABCD
ABC

综合练习

第一关

package case1;

import java.util.Scanner;

public class Task1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String dogName = sc.next();
		String dogSex = sc.next();
		String dogColor = sc.next();
		String catName = sc.next();
		String catSex = sc.next();
		double catWeight = sc.nextDouble();
		// 通过有参构造函数实例化Dog类对象dog
		// dog调用talk()方法
		// dog调用eat()方法
		/********* begin *********/
		Dog dog = new Dog(dogName, dogSex, dogColor);
        dog.talk();
        dog.eat();
		/********* end *********/
		// 通过有参构造函数实例化Cat类对象cat
		// cat调用talk()方法
		// cat调用eat()方法
		/********* begin *********/
		Cat cat = new Cat(catName, catSex, catWeight);
        cat.talk();
        cat.eat();
		/********* end *********/
	}
}

// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
	/********* begin *********/
    public String name, sex;
    public abstract void talk();
    public abstract void eat();
	/********* end *********/
}

// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,颜色:color,汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
	/********* begin *********/
	public String color;
    public Dog(String name, String sex, String color){
        this.name = name;
        this.sex = sex;
        this.color = color;
    }
    public void talk(){
        System.out.println("名称:" + name + ",性别:" + sex + ",颜色:" + color + ",汪汪叫");
    }
    public void eat(){
        System.out.println(name + "吃骨头!");
    }
	/********* end *********/
}

// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称:name,性别:sex,体重:weight kg,喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
	/********* begin *********/
public double weight;
public Cat(String name, String sex, double weight){
    this.name = name;
    this.sex = sex;
    this.weight = weight;
}
public void talk(){
    System.out.println("名称:" + name + ",性别:" + sex + ",体重:" + weight + "kg" + ",喵喵叫");
}
public void eat(){
    System.out.println(name + "吃鱼!");
}
	/********* end *********/
}

第二关

package case2;

import java.util.Scanner;

public class Task2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String cName = sc.next();
		String cSex = sc.next();
		int cAge = sc.nextInt();
		String eName = sc.next();
		String eSex = sc.next();
		int eAge = sc.nextInt();
		// 创建测试类对象test
		// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
		// 通过showEat()方法调用Chinese的eat()方法
		// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
		// 通过showEat()方法调用English的eat()方法
		/********* begin *********/
            Person person1 = new Chinese(cName, cSex, cAge);
            showEat(person1);
            Person person2 = new English(eName, eSex, eAge);
            showEat(person2);
		/********* end *********/
		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
		/********* begin *********/
        Chinese chinese = (Chinese)person1;
        chinese.shadowBoxing();
        English english = (English)person2;
        english.horseRiding();
		/********* end *********/
	}

	// 定义showEat方法,使用父类作为方法的形参,实现多态,传入的是哪个具体对象就调用哪个对象的eat()方法
	/********* begin *********/
    public static void showEat(Person one){
        one.eat();
    }
	/********* end *********/
}

// 抽象类Person 封装属性name、sex和age
// 构造函数初始化name、sex和age
// 声明抽象方法eat()
abstract class Person {
	/********* begin *********/
    public String name, sex;
    public int age;
    public abstract void eat();
	/********* end *********/
}

// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是中国人,我喜欢吃饭!'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳!'
class Chinese extends Person {
	/********* begin *********/
    public Chinese(String name, String sex, int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    @Override
    public void eat(){
        System.out.println("姓名:" + name + ",性别:" + sex + ",年龄:" + age + ",我是中国人,我喜欢吃饭!");
    }
    public void shadowBoxing(){
        System.out.println(name + "在练习太极拳!");
    }
	/********* end *********/
}

// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是英国人,我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马!'
class English extends Person {
	/********* begin *********/
    public English(String name, String sex,int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    @Override
    public void eat(){
        System.out.println("姓名:" + name + ",性别:" + sex + ",年龄:" + age + ",我是英国人,我喜欢吃三明治!");
    }
    public void horseRiding(){
        System.out.println(name + "在练习骑马!");
    }
	/********* end *********/
}

第三关

package case3;

import java.util.Scanner;

public class Task3 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String pppName = sc.next();
		int pppAge = sc.nextInt();
		String bpName = sc.next();
		int bpAge = sc.nextInt();
		String ppcName = sc.next();
		int ppcAge = sc.nextInt();
		String bcName = sc.next();
		int bcAge = sc.nextInt();
		// 测试运动员(乒乓球运动员和篮球运动员)
		// 乒乓球运动员
		// 通过带参构造函数实例化PingPangPlayer对象ppp
		// 输出'name---age'
		// 分别调用sleep()、eat()、study()、speak()方法
		/********* begin *********/
        PingPangPlayer ppp = new PingPangPlayer(pppName, pppAge);
        print(pppName, pppAge);
        ppp.sleep();
        ppp.eat();
        ppp.study();
        ppp.speak();
		/********* end *********/
		System.out.println("----------------");
		// 篮球运动员
		// 通过带参构造函数实例化BasketballPlayer对象bp
		// 输出'name---age'
		// 分别调用sleep()、eat()、study()方法
		/********* begin *********/
        BasketballPlayer bp = new BasketballPlayer(bpName, bpAge);
        print(bpName, bpAge);
        bp.sleep();
        bp.eat();
        bp.study();

		/********* end *********/
		System.out.println("----------------");
		// 测试教练(乒乓球教练和篮球教练)
		// 乒乓球教练
		// 通过带参构造函数实例化PingPangCoach对象ppc
		// 输出'name---age'
		// 分别调用sleep()、eat()、teach()、speak()方法
		/********* begin *********/
        PingPangCoach ppc = new PingPangCoach(ppcName, ppcAge);
        print(ppcName, ppcAge);
        ppc.sleep();
        ppc.eat();
        ppc.teach();
        ppc.speak();

		/********* end *********/
		System.out.println("----------------");
		// 篮球教练
		// 通过带参构造函数实例化BasketballCoach对象bc
		// 输出'name---age'
		// 分别调用sleep()、eat()、teach()方法
		/********* begin *********/
        BasketballCoach bc = new BasketballCoach(bcName, bcAge);
        print(bcName, bcAge);
        bc.sleep();
        bc.eat();
        bc.teach();
		/********* end *********/
		System.out.println("----------------");
	}

    public static void print(String name,int age){
        System.out.println(name + "---" + age);
    }
}

// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
	/********* begin *********/
    abstract void speak();
	/********* end *********/
}

// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()(吃的不一样)
abstract class Person {
	/********* begin *********/
    String name;
    int age;
    public Person(){

    }
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    public static void sleep(){
        System.out.println("人都是要睡觉的");
    }
    public abstract void eat();
	/********* end *********/
}

// 定义运动员Player(抽象类)继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样,抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
	/********* begin *********/
    public Player(){

    }
    public Player(String name, int age){
        super(name, age);
    }
    public abstract void study();
	/********* end *********/
}

// 定义教练Coach(抽象类)继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
	/********* begin *********/
    public Coach(){

    };
    public Coach(String name, int age){
        super(name, age);
    }
    public abstract void teach();
	/********* end *********/
}

// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类(兵乓球运动员需要说英语)
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜,喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
	/********* begin *********/
    public PingPangPlayer(){

    }
    public PingPangPlayer(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println("乒乓球运动员吃大白菜,喝小米粥");
    }
    @Override
    public void study(){
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    @Override
    public void speak(){
        System.out.println("乒乓球运动员说英语");
    }
	/********* end *********/
}

// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口,因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球运动员吃牛肉,喝牛奶'
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
class BasketballPlayer extends Player {
	/********* begin *********/
    public BasketballPlayer(){

    }
    public BasketballPlayer(String name, int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println("篮球运动员吃牛肉,喝牛奶");
    }
    @Override
    public void study(){
        System.out.println("篮球运动员学习如何运球和投篮");
    }
	/********* end *********/
}

// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类(兵乓球教练需要说英语)
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜,喝大米粥'
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球教练说英语'
class PingPangCoach extends Coach implements SpeakEnglish {
	/********* begin *********/
    public PingPangCoach(){

    }
    public PingPangCoach(String name, int age){
        super(name,age);
    }
    @Override
    public void eat(){
        System.out.println("乒乓球教练吃小白菜,喝大米粥");
    }
    @Override
    public void teach(){
        System.out.println("乒乓球教练教如何发球和接球");
    }
    @Override
    public void speak(){
        System.out.println("乒乓球教练说英语");
    }
	/********* end *********/
}

// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口,因为他不需要说英语
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'篮球教练吃羊肉,喝羊奶'
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
class BasketballCoach extends Coach {
	/********* begin *********/
    public BasketballCoach(){

    }
    public BasketballCoach(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println("篮球教练吃羊肉,喝羊奶");
    }
    @Override
    public void teach(){
        System.out.println("篮球教练教如何运球和投篮");
    }
	/********* end *********/
}

实验一–JAVA语言基础

第一关

import java.util.Scanner;

public class HelloWorld {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请给定一个自然数N:");
		int N = sc.nextInt();//获取输入的整数N
		int sum = 1;		
		/*****start*****/
		for(int i = 1;i <= N;i++){
            sum*=i;
        }
		
		
		
		
		
		
		/*****end*****/
		
		System.out.println("自然数N的阶乘为" + sum);
	}
}

第二关

package step2;

public class Test {
	public static void main(String[] args) {
		/*****start*****/
		
		//在这里打印出正三角形 
		for(int i = 0;i < 10;i++){
            for(int j = 0;j <= i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
		
		
		
		System.out.println("——————————我是华丽的分界线——————————");
		//在这里打印出倒三角形
		for(int i = 9;i >= 0;i--){
            for(int j = 0;j <= i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
		
		
		
		
		/*****end*****/
	}
}

第三关

package step3;

import java.util.Arrays;
import java.util.Scanner;

public class HelloWorld {
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//动态创建数组
		int[] arr = new int[sc.nextInt()];
		for(int i = 0 ; i< arr.length ; i++){
			arr[i] = sc.nextInt();
		}
		/********** Begin **********/
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < i;j++){
                if(arr[i] < arr[j]){
                    arr[j] = arr[j] + arr[i];
                    arr[i] = arr[j] - arr[i];
                    arr[j] = arr[j] - arr[i];
                }
            }
        }
		System.out.println(Arrays.toString(arr));
		
		
		
		
		
		
		
		
		/********** End **********/
	}
}	

第四关

package step4;

import java.util.Scanner;

public class NameSearch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        /********** Begin *********/
        String s = scanner.nextLine();
        String name = scanner.nextLine();
        int a = s.indexOf(name);
        while(a != -1){
            System.out.println(a);
            a = s.indexOf(name,a+1);
        }
        /********** End *********/
    }
}

Java面向对象(四)-包装类

第一关

package step1;

public class Task {
	public static void main(String[] args) {
		
//请在此添加实现代码
/********** Begin **********/
//定义float对象
		float f = 66.6f;
		
		//手动装箱
		Float f1 = new Float(f) ;
		
		//自动装箱 
		Float f2 =  f  ;
		
		System.out.println("装箱后的结果为:" + f1 + "和" + f2);
		
		
		//定义一个Double包装类值为88.88
		Double d =    88.88   ;
		
		//手动拆箱
		double d1 =   d.doubleValue()   ;
		
		//自动拆箱
		double d2 =   d   ;
		
		System.out.println("拆箱结果为:" + d1 + "和" + d2);
		

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

}

第二关

package step2;

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

//请在此添加实现代码
/********** Begin **********/
// 定义int类型变量,值为67
		int score = 67;

		// 创建Integer包装类对象,表示变量score的值
		Integer score1 = new Integer(score);

		// 将Integer包装类转换为double类型
		double score2 =  score1.doubleValue()   ; 

		// 将Integer包装类转换为float类型
		float score3 =   score1.floatValue()   ;

		// 将Integer包装类转换为int类型
		int score4 =    score1    ;

		System.out.println("Integer包装类:" + score1);
		System.out.println("double类型:" + score2);
		System.out.println("float类型:" + score3);
		System.out.println("int类型:" + score4);


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

第三关

package step3;

public class Task {
	public static void main(String[] args) {
		double a = 78.5;
        
//请在此添加实现代码
/********** Begin **********/
//将基本类型a转换为字符串
		String str =   Double.toString(a)   ;
        
		System.out.println("str + 12  的结果为: "+(str + 12));
		
		String str1 = "180.20";
	    // 将字符串str1转换为基本类型
		Double d =   Double.valueOf(str1)   ;
	
		System.out.println("d + 100 的结果为: "+ (d + 100));

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

	} 
}

Java面向对象(五)-常用类

第一关

package case1;

import java.util.Scanner;

public class ObjectTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int num1 = sc.nextInt();
		int num2 = sc.nextInt();
		// ÔÚ²âÊÔÀàÖд´½¨DemoÀà¶ÔÏód1£¬´«ÈëÊäÈëÖµnum1£¬ d1µ÷ÓÃtoString·½·¨²¢´òÓ¡Êä³ö¸ÃÖµ
		// ´´½¨DemoÀà¶ÔÏód2£¬Í¬Ñù´«ÈëÊäÈëÖµnum1£¬´òÓ¡ÅжÏd1ºÍd2ÊÇ·ñÏàµÈ£¨Êµ¼ÊÊDZȽϵØÖ·£©
		/********* Begin *********/
        Demo d1 = new Demo(num1);
        System.out.println(d1);
		/********* End *********/
		// ´´½¨PersonÀà¶ÔÏóp£¬´«ÈëÊäÈëÖµnum2£¬´òÓ¡ÅжÏd1ºÍpÊÇ·ñÏàµÈ£¨Êµ¼ÊÊDZȽϵØÖ·£©
		/********* Begin *********/
        Demo d2 = new Demo(num1);
        System.out.println(d1.equals(d2));

        Person p = new Person(num2);
        System.out.print(d1.equals(p));
		/********* End *********/
	}
}

class Demo {
	private int num;

	public Demo(int num) {
		this.num = num;
	}

	public boolean equals(Object obj) // Object obj = new Demo()
	{
		if (!(obj instanceof Demo)) // ÅжÏobjÊÇ·ñºÍDemoÊÇͬÀà
			return false;
		Demo d = (Demo) obj; // ½«¸¸ÀàµÄÒýÓÃ(Object)ÏòÏÂת»»Îª×ÓÀà(Demo)
		return this.num == d.num;
	}

	public String toString() {
		return "Demo:" + num; // ·µ»Ø¶ÔÏóµÄÖµ£¨Ã¿Ò»¸ö¶ÔÏó¶¼ÓÐ×Ô¼ºµÄÌض¨µÄ×Ö·û´®£©
	}
}

class Person {
	private int num;

	public Person(int num) {
		this.num = num;
	}
}

第二关

package case2;

import java.util.Scanner;

public class WrapperTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int aa = sc.nextInt();
		String bb = sc.next();
		int c = sc.nextInt();
		String str11 = sc.next();
		String str22 = sc.next();
		// °ü×°ÀàÖС°==¡±ÓëequalsµÄÓ÷¨±È½Ï
		// ÖµµÃ×¢ÒâµÄÊÇ£¬°ü×°ÀàÖеÄequals·½·¨ºÍStringÀàÒ»Ñù£¬¶¼ÊÇÖØдÁËObjectÀàÖеÄequals·½·¨£¬Òò´Ë±È½ÏµÄÊÇÄÚÈݶø²»ÊǵØÖ·£¬
		// ¶ø¡°==¡±±È½ÏµÄÒÀÈ»ÊÇÒýÓñäÁ¿µÄµØÖ·£¬Ö»Êǵ±°ü×°ÀàÐͺÍÓëÖ®Ïà¶ÔÓ¦µÄ»ù±¾ÀàÐͽøÐС°==¡±±È½Ïʱ»áÏÈ×ö×Ô¶¯²ðÏä´¦Àí¡£
		/********* Begin *********/
        Integer a = new Integer(aa);
        Integer b = Integer.parseInt(bb);
        String str1 = new String(str11);
        String str2 = new String(str22);
        System.out.println(a==b);
        System.out.println(a==c);
        System.out.println(b==c);
        System.out.println(a.equals(b));
        System.out.println(str1 == str2);
        System.out.println(str1.equals(str2));
		/********* End *********/
	}
}

第三关

package case3;

import java.util.Scanner;

public class StringTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String str = sc.next();
		// String substring(int start,int end)
		// ½ØÈ¡×Ö·û´®£¬´«ÈëµÄÁ½¸ö²ÎÊý·Ö±ðΪҪ½ØÈ¡±ß½çµÄϱê
		// ÔÚjava api ÖÐ,ͨ³£Ê¹ÓÃÁ½¸öÊý×Ö±íʾ·¶Î§Ê±,¶¼ÊǺ¬Í·²»º¬Î²,¼´°üº¬Æðʼϱê¶ÔÓ¦µÄÄÚÈÝ,µ«²»°üº¬½áÊøϱêµÄ´¦¶ÔÓ¦µÄÄÚÈÝ
		// String toUpperCase() ½«µ±Ç°×Ö·û´®ÖеÄÓ¢ÎIJ¿·Öת»»ÎªÈ«´óд
		/********* Begin *********/
        String str1 = str.substring(12, str.lastIndexOf('.'));
        if(str1.indexOf('.') > 0){
            str1 = str1.substring(0, str1.indexOf('.'));
        }
        System.out.println(str1);
        str1 = str1.toUpperCase();
        System.out.println(str1);
		/********* End *********/
	}
}

第四关

package case4;

//ÃÜÂëµÄ×Ô¶¯Éú³ÉÆ÷£ºÃÜÂëÓÉ´óд×Öĸ/Сд×Öĸ/Êý×Ö×é³É£¬Éú³ÉÁùλËæ»úÃÜÂë
import java.util.Random;
import java.util.Scanner;

public class RandomTest {
	public static void main(String[] args) {
		// ¶¨ÒåÒ»¸ö×Ö·ûÐÍÊý×é
		char[] pardStore = new char[62];
		// °ÑËùÓеĴóд×Öĸ·Å½øÈ¥ °ÑËùÓеÄСд×Öĸ·Å½øÈ¥ °Ñ0µ½9·Å½øÈ¥
		/********* Begin *********/
            for(int i = 0;i < 26;i++){
                pardStore[i] = (char)('A' + i);
            }
            for(int i = 26;i < 52;i++){
                pardStore[i] = (char)('a' + (i-26));
            }
            for(int i = 52;i < 62;i++){
                pardStore[i] = (char)('0' + (i - 52));
            }
		/********* End *********/
		// ·Ö±ðÒÔ1¡¢2¡¢3×÷ΪÖÖ×ÓÊý Éú³É6λËæ»úÃÜÂë
		Scanner sc = new Scanner(System.in);
		int seed = sc.nextInt();
		/********* Begin *********/
        Random r = new Random(seed);
        char[] passWord = new char[6];
        for(int i = 0;i < 6;i++){
            passWord[i] = pardStore[r.nextInt(62)];            
        }
        System.out.println(passWord);
		/********* End *********/
	}
}

第五关

package case5;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class DateTest {
	public static void main(String[] args) throws ParseException {
		// ¼üÅ̼ÈëÄãµÄ³öÉúÄêÔÂÈÕ ¸ñʽΪyyyy-MM-dd
		// °Ñ¸Ã×Ö·û´®×ª»»ÎªÒ»¸öÈÕÆÚ
		// ͨ¹ý¸ÃÈÕÆڵõ½Ò»¸öºÁÃëÖµ
		// »ñÈ¡2020Äê10ÔÂ1ÈյĺÁÃëÖµ
		// Á½ÕßÏë¼õµÃµ½Ò»¸öºÁÃëÖµ
		// °Ñ¸ÃºÁÃëֵת»»ÎªÌì ´òÓ¡Êä³ö
		Scanner sc = new Scanner(System.in);
		String line = sc.nextLine();
		/********* Begin *********/
        SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = ft.parse(line);
        long b = d1.getTime();
        Date d2 = ft.parse("2020-10-01");
        long e = d2.getTime();
        long d = e - b;
        d = d/86400000;
        System.out.println("你的出生日期距离2020年10月1日:" + d + "天");
		/********* End *********/
	}
}

第六关

package case6;

import java.util.Scanner;
import java.lang.Math;

public class MathTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a1 = sc.nextInt();
		int a2 = sc.nextInt();
		int a3 = sc.nextInt();
		int a4 = sc.nextInt();
		double a5 = sc.nextDouble();
		double a6 = sc.nextDouble();
		double a7 = sc.nextDouble();
		double a8 = sc.nextDouble();
		double a9 = sc.nextDouble();
		double a10 = sc.nextDouble();
		double a11 = sc.nextDouble();
		/********* Begin *********/
        System.out.println(Math.sqrt(a1));
        System.out.println(Math.cbrt(a2));
        System.out.println(Math.pow(a3, a4));
        System.out.println(Math.max(a5, a6));
        System.out.println(Math.min(a5, a6));
        System.out.println(Math.abs(a7));
        System.out.println(Math.ceil(a8));
        System.out.println(Math.floor(a9));
        System.out.println(Math.rint(a10));
        System.out.println(Math.round(a11));
		/********* End *********/
	}
}

欢迎关注
持续更新ing…

你可能感兴趣的:(Java,java)