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…