• 第一关

  package step1;

  public class HelloWorld {
  /********** Begin **********/

  //定义一个方法，用来和老师打招呼
  
  /********** End **********/	
  public static void main(String[] args) {
      helloEducoder();
  }
  public static void helloEducoder() {
  
          System.out.println("hello teacher!");
      }
  
  	/********** Begin **********/	
  	
      //调用方法 
  
  	/********** End **********/
  

  }

• 第二关

  package setp7;
  public class HelloWorld {

  public static void main(String[] args) {
  	/********** Begin **********/
  
      // 调用calcAvg()方法，并将返回值保存在变量avg中
      double avg =calcAvg(); 
  
  	/********** End **********/
  	System.out.println("平均成绩为：" + avg);
  }
  
  // 定义一个返回值为double类型的方法
  /********** Begin **********/
  public static double calcAvg() {
      double java = 92.5;
      double php = 83.0;
      double avg = (java + php) / 2; // 计算平均值
          return avg;
      // 使用return返回值
  
  
  /********** End **********/
  }
  

  }

• 第三关

  package setp9;

  import java.util.Scanner;

  public class HelloWorld {
  public static void main(String[] args) {
  HelloWorld hello = new HelloWorld();
  Scanner sc = new Scanner(System.in);
  int score1 = sc.nextInt(); //第一门成绩
  int score2 = sc.nextInt(); //第二门成绩
  /********** Begin /
  // 调用方法，传入两门课程的成绩
  hello.calcAvg(score1,score2);
  / End **********/
  }

  /*
   * 功能：计算两门课程考试成绩的平均分并输出平均分
   * 定义一个包含两个参数的方法，用来传入两门课程的成绩
   */
  
  /********** Begin **********/
  public static void calcAvg(int score1,int score2){
   int avg=(score1+score2)/2;
   System.out.print("平均分："+avg);
  }
  /********** End **********/
  

  }

• 第四关

  package step3;

  import java.util.Scanner;

  public class HelloWorld {
  public static void main(String[] args) {
  HelloWorld hello=new HelloWorld();
  Scanner sc = new Scanner(System.in);
  int i = sc.nextInt(); //获取第一个输入的整数
  int j = sc.nextInt(); //获取第二个输入的整数
  int max = hello.getMax(i,j);
  /********** Begin **********/
  //在这里调用方法获取返回值

      System.out.println( i+"和"+j+"比较，最大值是："  + max  );
  	/********** End **********/
  }
  
  /*在这里创建getMax方法，以两个整数作为参数，返回两个整数中较大的值*/
  
  /********** Begin **********/
  public static int getMax(int i,int j){
      if(i>j) return i;
      else return j;
         }
  
  
  /********** End **********/
  

  }

• 第五关

  package setp10;
  import java.util.Arrays;

  public class HelloWorld {
  public static void main(String[] args) {
  HelloWorld hello=new HelloWorld();

      int[] scores={79,52,98,81};
  	/********** Begin **********/
      //调用方法，传入成绩数组，并获取成绩的个数
      int count=hello.sort(scores);
      
  	/********** End **********/
      System.out.println("共有"+count+"个成绩信息！");
  }
  
  /*
   * 功能：将考试成绩排序并输出，返回成绩的个数
   * 
   */
  /********** Begin **********/	
  public static int sort( int[] data ){
  
     // 数组从小到大排序处理
  

  for(int i=0;i for(int j=i+1;j

  if(data[i]>data[j])
   {
      int temp=data[i];
     data[i]=data[j];
     data[j]=temp;
     }
  }
     // 打印出数组
     System.out.print("[");
  

  for(int i=0;i System.out.print(data[i]+“, “);
  System.out.print(data[3]+”]”);
  System.out.println();
  //返回数组中元素的个数
  return data.length;

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

  }

• 第六关

  package setp15;

  /**

  • @author tangzhiqiang

  • @date 2018-04-25 22:31
    */
    public class HelloWorld {
    public static void main(String[] args) {

     /********** Begin **********/
     // 调用无参的方法
     print();
    
     // 调用带有一个字符串参数的方法	
    print("educoder");
     // 调用带有一个整型参数的方法
    print(666);
     /********** End **********/
    

    }

    /********** Begin **********/
    // 无参print方法的定义
    public static void print(){
    System.out.println(“无参的print方法”);
    }
    // 字符串print方法的定义
    public static void print(String name){
    System.out.println(“带有一个字符串参数的print方法，参数值为：”+name);

  }
  // 整型print方法的定义
  public static void print(int id){
  System.out.println(“带有一个整型参数的print方法，参数值为：”+id);
  }

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

  }

• 第七关

  package setp17;
  import java.util.Arrays;
  import java.util.Scanner;
  public class HelloWorld {
  /********** Begin /
  /
  * 第一题：定义一个方法 接收两个整数类型的参数 a和b，返回两个数的和 返回值类型为int 方法名为：getSum
  /
  public static int getSum(int a ,int b){
  int sum = a + b;
  return sum;
  }
  /
  * 第二题： 定义一个方法 接收三个double类型参数a，b，c， 返回这三个数的平均值 返回值类型为double 方法名为：getAvg
  /
  public static double getAvg(double a ,double b,double c){
  double avg = (a + b + c) / 3;
  return avg;
  }
  /
  * 第三题： 定义一个方法 接收两个参数 a 和b 打印a行 b列的一个矩形 不需要返回值 方法名为：printRect
  /
  public static void printRect(int a , int b){
  for (int i = 1 ; i <= a ;i++) {
  for (int k = 1 ; k <= b;k++){
  System.out.print("");
  }
  System.out.println();
  }
  }
  /
  * 第四题：定以一个方法，接收整形数组 为参数 对这个数组进行升序排序 最后输出该数组 不需要返回值 方法名为 sortArr
  /
  public static void sortArr(int[] arr){
  for(int i = 0; i< arr.length-1;i++){
  for(int j = i+1; j< arr.length;j++){
  if(arr[i] > arr[j]){
  int tmp = arr[i];
  arr[i] = arr[j];
  arr[j] = tmp;
  }
  }
  }
  for(int i = 0; i< arr.length;i++){
  System.out.println(arr[i]);
  }
  }
  /
  * 第五题
  * 你只需要实现for 循环括号的内容就可 ，打印语句系统已经给你完成
  /
  public static void Print99() {
  for (int i = 1 ; i<=9;i++) {
  for (int j = 1;j <= i ;j++) {
  System.out.print(j + " * " + i + " = " + i * j + " ");
  }
  System.out.println();
  }
  }
  /****** End **********/
  }

• 第一关

  package step1;

  public class Test {
  public static void main(String[] args) {
  /********** Begin **********/
  //创建Dog对象
  //设置Dog对象的属性
  //在main方法中创建一个名为wuhuarou的Dog对象，
  //并设置name为五花肉，color为棕色，variety为阿拉斯加。
  Dog wuhuarou = new Dog();
  wuhuarou.name = “五花肉”;
  wuhuarou.color = “棕色”;
  wuhuarou.variety = “阿拉斯加”;
  //输出小狗的属性
  System.out.println(“名字：” +wuhuarou.name+ “，毛色：” +wuhuarou.color+ “，品种：” +wuhuarou.variety);

  	//调用方法
      wuhuarou.eat();
      wuhuarou.run();
  
  	
  	/********** End **********/
  	
  }
  

  }

  //在这里定义Dog类
  /********** Begin **********/
  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();
  /********** Begin **********/
  //分别使用两种构造器来创建Person对象
  Person person1 = new Person();

  	Person person2 = new Person(name,sex);
  
  	/********** End **********/
  	
  }
  

  }

  //创建Person对象，并创建两种构造方法
  /********** Begin **********/
  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.println("姓名："+name+'，'+"性别："+sex+'，'+"被创建了");
  }
  

  }

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

• 第三关

  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;
  }
  
  public void display(){
  	String name = "baby";
  	int age = 45;
  	String sex = "女";
  	System.out.println("name：" + this.name);
  	System.out.println("age：" + this.age);
  	System.out.println("sex：" + this.sex);
  }
  
  
  /********** End **********/
  

  }

• 第四关

文件一

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();
		/********** Begin **********/
		//使用三个参数的构造方法创建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();
 
		
		/********** End **********/	
	}
}

文件二

/********** Begin **********/
//在这里添加包名  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 {
  /********** Begin **********/
  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");
  }
  /********** End **********/
  

  }

• 第一关

  package case1;
  public class TestPersonDemo {
  public static void main(String[] args) {
  /********* begin /
  // 声明并实例化一Person对象p
  Person p = new Person();
  // 给p中的属性赋值
  p.setName(“张三”);
  p.setAge(18);
  // 调用Person类中的talk()方法
  p.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;
  }
  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 cat= new Cat();
  cat.name=“大花猫”;
  cat.age=6;
  cat.voice();
  cat.eat();
  System.out.println(cat.name+cat.age+“岁”);
  / end *********/

      // 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
      /********* begin *********/
       Dog dog= new Dog();
        dog.name="大黑狗";
        dog.age=8;
        dog.voice();
        dog.eat();
        System.out.println(dog.name+dog.age+"岁");
      /********* end *********/
  
  }
  

  }

  class Animal {
  /********* begin *********/
  protected String name;
  protected 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 ;
   }
  /********* end *********/
  

  }

  class Cat extends Animal {
  // 定义Cat类的voice()和eat()方法
  /********* begin /
  public void voice(){
  System.out.println(name+“喵喵叫”);
  }
  public void eat(){
  System.out.println(name+“吃鱼”);
  }
  / end *********/
  }

  class Dog extends Animal {
  // 定义Dog类的voice()和eat()方法
  /********* begin /
  public void voice(){
  System.out.println(name+“汪汪叫”);
  }
  public void eat(){
  System.out.println(name+“吃骨头”);
  }
  / end *********/
  }

• 第三关

  package case3;

  public class superTest {
  public static void main(String[] args) {
  // 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
  /********* begin *********/
  Person p= new Person();
  p.setName(“张三”);
  p.setAge(18);
  p.talk();
  Student stu= new Student();

     stu.school="哈佛大学";
     
     System.out.println("，学校："+stu.school);
  
      /********* end *********/
  }
  

  }

  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.print("姓名："+name+"，年龄："+age);
   }
  /********* end *********/
  

  }

  class Student extends Person {
  /********* begin *********/
  public String school;
  public String getSchool(){
  return school;
  }

  public void setSchool(String name){
      this.school= school;
  }
  /********* end *********/
  

  }

• 第四关

  package case4;

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

  }
  

  }

  class Person {
  /********* begin /
  String name;
  int age;
  protected void talk(String name, int age){
  this.name=name;
  this.age=age;
  System.out.print(“我是：”+this.name+“，今年：”+this.age);
  }
  / end *********/
  }

  class Student extends Person {
  /********* begin *********/

  String school;
  
  public void talk(String name,int age,String school){
      
          super.talk("张三",18);
          
      this.school=school;
      System.out.println("岁，我在"+this.school+"上学");
  }
  /********* end *********/
  

  }

• 第五关

  package case5;

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

  }
  

  }

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

  // Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
  class Student extends Person {
  /********* begin *********/

     Student(String name,int age,String occupation) { 
       super(name,age,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) { 
       super(name,age,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方法,不可以重写

  class Bike1 {
  int speedlimit = 90;

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

  }

  class Bike2 {
  void run() {
  System.out.println(“running”);
  }
  }

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

  }

  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=“学生”;
  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 *********/
  show(new Dog());
  show(new Cat());
  show(new Lion());

  }
  
  public static void show(Animal a){
      a.eat();
      if(a instanceof Dog){
          
      }else if(a instanceof Cat){
          
      }else{
          
      }
  }
      /********* end *********/
  

  }

  // Animal类中定义eat()方法
  abstract class Animal {
  /********* begin /
  abstract 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 *********/
  }

• 第一关

  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 abstract void talk();
  public abstract void eat();
  private String name;
  private String sex;
  public String getname(){
  return name;
  }
  public void setname(String name){
  this.name=name;
  }
  public String getsex(){
  return sex;
  }
  public void setsex(String sex){
  this.sex=sex;
  }
  public Pet(String name,String sex){
  this.name=name;
  this.sex=sex;
  }
  / end *********/
  }

  // Dog类继承自Pet类 封装属性color
  // 构造函数初始化name、sex和color
  // 实现自己的talk()方法和eat()方法
  // talk()输出’名称：name，性别：sex，颜色：color，汪汪叫’
  // eat()输出’name吃骨头’
  class Dog extends Pet {
  /********* begin *********/
  private String color;
  public String getcolor(){
  return color;
  }
  public void setcolor(String color){
  this.color=color;
  }
  public Dog(String name,String sex,String color){
  super(name,sex);
  sex=super.getname();
  name=super.getname();
  this.color=color;
  }
  public void talk(){
  System.out.println(“名称：”+super.getname()+“，性别：”+super.getsex()+“，颜色：”+color+“，汪汪叫”);
  }
  public void eat(){
  System.out.println(super.getname()+“吃骨头！”);
  }

  /********* end *********/
  

  }

  // Cat类继承自Pet类 封装属性weight
  // 构造函数初始化name、sex和weight
  // 实现自己的talk()方法和eat()方法
  // talk()输出’名称：name，性别：sex，体重：weight kg，喵喵叫’
  // eat()输出’name吃鱼’
  class Cat extends Pet {
  /********* begin /
  / begin *********/
  private double weight;
  public double getweight(){
  return weight;
  }
  public void setweight(double weight){
  this.weight=weight;
  }
  public Cat(String name,String sex,double weight){
  super(name,sex);
  sex=super.getname();
  name=super.getname();
  this.weight=weight;
  }
  public void talk(){
  System.out.println(“名称：”+super.getname()+“，性别：”+super.getsex()+“，体重：”+weight+“kg，喵喵叫”);
  }
  public void eat(){
  System.out.println(super.getname()+“吃鱼！”);
  }

  /********* 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 *********/
  //题目中没有static 这里应该定义一个静态方法，如果不定