diff --git a/新建 文本文档.txt b/新建 文本文档.txt
new file mode 100644
index 0000000..0bb5551
--- /dev/null
+++ b/新建 文本文档.txt	
@@ -0,0 +1,9533 @@
+三元运算符
+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%400==0)? true : false; 
+        result=(year%4==0&&year%100!=0)? true : false;
+        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*****/
+	}
+}
+
+第 2 章 Java入门之控制结构
+Java入门 - 分支结构
+第1关：Java分支结构之 if…else
+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 score = input.nextInt();
+		if (score >= 85)
+System.out.println("优，非常棒！");
+else {
+System.out.println("良，下次加油！");
+}	
+		/******end******/
+	}
+}
+
+第6关：来吧，我是BOSS！
+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循环结构之do…while循环
+package step3;
+public class HelloWorld {
+    public static void main(String[] args) {
+        int count= 0;    //定义变量存储6的倍数出现的次数
+        /*****start*****/
+        int i=1;
+        do{
+           if(i%6==0){
+            count++;
+            i++;   
+           }i++;
+        }while(i<=100);    
+        /*****end*****/
+        System.out.println("6的倍数出现的次数为：" + count);
+    }
+}
+
+Java循环结构之for循环
+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：");
+        //获取输入的整数N
+        int sum = 1;        
+        /*****start*****/
+        for(int N = sc.nextInt(); N>0; N--) {
+          sum=sum*N;
+        }
+        /*****end*****/
+        System.out.println("自然数N的阶乘为" + sum);
+    }
+}
+
+
+
+
+
+for循环的进阶使用-嵌套循环（1）
+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*****/
+    }
+}
+
+for循环的进阶使用-嵌套循环（2）
+package step2;
+public class ForPractice2 {
+    public static void main(String[] args) {
+        /*****start*****/        
+        //在这里打印出正三角形 
+        for(int x=0;x<10;x++){
+            for(int y=0;y<=x;y++){
+              System.out.print("*");
+            }
+            System.out.println();
+        }                                
+        System.out.println("————我是华丽的分界线—————");
+        //在这里打印出倒三角形
+        for(int x=10;x>0;x--){
+            for(int y=x;y>0;y--){
+              System.out.print("*");
+            }
+            System.out.println();
+        }        
+        /*****end*****/
+    }
+}
+99乘法表
+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*****/
+    }
+}
+
+综合练习之ATM取款机
+package step4
+import java.util.Scanner;
+public class ForPractice4 {
+    public static void main(String[] args) {
+        /*****start*****/
+      int money = 1000;
+      int cash = 0;
+      int isornot = 0;
+      Scanner input =new Scanner(System.in);
+      System.out.println("欢迎使用中国人民银行ATM取款机");
+      do {
+          System.out.println("输入取款金额：");
+          cash = input.nextInt();
+          if(money >=cash) 
+                 {
+                  money=money-cash;
+          }
+          else {
+                 System.out.println("目前余额："+money+"无法满足您的取款需求！");
+                 continue;
+          }
+          System.out.println("剩余金额："+money+"，是否继续（'1'：结束，'2'：继续）：");  
+          isornot=input.nextInt();
+          if(isornot==1) 
+                  {
+                    break;}
+                   }while(money>0);
+                   System.out.println("取款结束！");
+        
+        /*****end*****/
+    }
+}
+
+第 3 章 Java入门之数组
+Java入门 - 数组基础
+数组练习-平均值和最大值
+package step3;
+import java.util.Scanner;
+public class HelloWorld {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int[] scores = new int[sc.nextInt()];
+		//循环给数组赋值
+		for(int i = 0 ; i< scores.length;i++){
+			scores[i] = sc.nextInt();
+		}
+		/********** Begin **********/
+		//在这里计算数组scores的平均值和最大值
+        float sum = 0;
+        int max = scores[0];
+        float avg;
+		for(int i = 0; i < scores.length; i++){
+            sum = sum + scores[i];
+        }
+        for(int i = 1; i < scores.length; i++){
+            if(scores[i]>scores[i-1]){
+                max = scores[i];
+            }else{
+                break;
+            }
+        }   	
+		avg = sum / scores.length;	
+		System.out.println("平均值："+avg);
+		System.out.println("最大值："+max);
+		/********** End **********/
+	}
+}
+
+二维数组
+package step4;
+public class HelloWorld {
+	public static void main(String[] args) {
+		/********** Begin **********/
+		int[][] scores = {{92,85},{91,65},{90,33}};
+       for(int i=0; i<scores.length; i++){  //行循环次数scores.length（每一列的长度）
+       for(int j=0; j<scores[i].length; j++){ //列循环次数scores[i].length（每一行的长度）
+                System.out.println(scores[i][j]);
+            }
+            //System.out.println();
+        }
+        //scores[][] = {{1,2},{1,2},{1,2}};     //是错误的
+        for(int i=0; i<scores.length; i++){
+            scores[i][0] = 1;
+            scores[i][1] = 2;
+        }
+        for(int i=0; i<scores.length; i++){     //行循环次数
+            for(int j=0; j<scores[i].length; j++){  //列循环次数
+                System.out.println(scores[i][j]);
+            }
+            //System.out.println();
+        }	
+		/********** End **********/
+	}
+}
+
+
+
+数组进阶
+package step1;
+import java.util.Scanner;
+public class HelloWorld {
+	public static void main(String[] args) {
+		//动态构建arr1
+		int[] arr1 = new int[3];
+		Scanner sc = new Scanner(System.in);
+		for(int i = 0 ; i< arr1.length ; i++){
+			arr1[i] = sc.nextInt();
+		}
+		/********** Begin **********/
+		//创建数组arr2
+		 int[] arr2 = new int[3];
+
+        //使用for循环将arr1的数据复制给arr2
+        for(int j =0 ; j<arr1.length ; j++){
+           arr2[j] =arr1[j];
+           System.out.println(arr2[j]);
+        }
+		/********** End **********/
+	}
+}
+
+选择排序
+package step4;
+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 j = 0; j < arr.length - 1; j++) {
+            for (int i = j; i < arr.length -1; i++) {
+                if(arr[j] < arr[i+1]){    
+                    int temp = arr[j];
+                    arr[j] = arr[i+1];
+                    arr[i+1] = temp;
+                }
+            }
+        }
+        System.out.println(Arrays.toString(arr));
+        /********** End **********/
+    }
+}
+冒泡排序
+package step5;
+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 j = 1 ; j< arr.length;j++){
+            for (int i = 0; i < arr.length -j; i++) {
+                if(arr[i] > arr[i+1]){
+                    int temp = arr[i];//交换位置
+                    arr[i] = arr[i+1];
+                    arr[i+1] = temp;
+                }
+            }
+        }
+        System.out.println(Arrays.toString(arr));
+        /********** End **********/
+    }
+}    
+第 4 章 Java入门之方法
+Java入门 - 方法的使用
+第2关：掌握无参有返回值方法的调用
+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<data.length-1;i++)
+    for(int j=i+1;j<data.length;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<data.length-1;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 **********/
+}
+
+
+第8关：方法通关挑战
+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 + "\t");
+            }
+            System.out.println();
+        }
+    }
+    /********** End **********/
+}    
+
+
+
+
+
+
+
+
+
+
+第 5 章 Java 面向对象之类和对象
+Java面向对象 - 类与对象
+第1关：什么是类，如何创建类
+
+package step1;
+
+public class Test {
+	public static void main(String[] args) {
+		/********** Begin **********/
+		//创建Dog对象
+		//设置Dog对象的属性
+		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("叼着骨头跑");
+	}
+
+}
+
+/********** End **********/
+第2关：构造方法
+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 **********/
+
+第4关：This关键字
+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 **********/
+}
+
+第5关：类与对象练习
+文件一
+
+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();
+        //分别调用三个类的 check方法
+        f1.check();
+        f2.check();
+        f3.check();
+        /********** End **********/    
+    }
+}
+文件二
+
+/********** Begin **********/
+//在这里添加包名  step4
+package step4;   
+//创建类 添加属性和方法
+public class WuMingFen{
+    String theMa = "酸辣";
+    int quantity = 2;
+    boolean likeSoup = false;
+    public WuMingFen() {
+        likeSoup = true;
+    }
+    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 );
+    }
+}
+/********** End **********/    
+第6关：static关键字
+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 **********/
+}
+
+Java面向对象 - 封装、继承和多态
+第1关：什么是封装，如何使用封装
+
+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 *********/
+}
+第2关：什么是继承，怎样使用继承
+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 *********/
+}
+
+第3关：super关键字的使用
+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 *********/
+}
+
+第4关：方法的重写与重载
+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 *********/
+}
+第5关：抽象类
+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 *********/
+}
+第6关：final关键字的理解与使用
+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 类
+    //请在此添加你的代码
+    /********** Begin *********/
+	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");
+	}
+
+}
+    /********** End **********/
+
+第7关：接口
+package case7;
+public class interfaceTest {
+	public static void main(String[] args) {
+		// 实例化一Student的对象s，并调用talk()方法，打印信息
+		/********* begin *********/
+		Student s=new Student();
+		System.out.println(s.talk());
+		/********* end *********/
+	}
+}
+// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
+interface Person {
+	/********* begin *********/
+	final String name="张三";
+	final int age=18;
+	final String occupation="学生";
+	public abstract String talk();
+	/********* end *********/
+}
+
+// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
+class Student implements Person {
+	/********* begin *********/
+	public String talk() {
+        return "学生——>姓名：" + this.name + "，年龄：" + this.age + "，职业："
+                + this.occupation + "！";
+	}
+	/********* end *********/
+}
+第8关：什么是多态，怎么使用多态
+package case8;
+public class TestPolymorphism {
+	public static void main(String[] args) {
+		// 以多态方式分别实例化子类对象并调用eat()方法
+		/********* begin *********/
+		Animal a=new Dog();
+		a.eat();
+		Animal b=new Cat();
+		b.eat();
+		Animal c=new Lion();
+		c.eat();
+		/********* 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 *********/
+}
+Java面向对象 - 封装、继承和多态的综合练习
+第1关：封装、继承和多态进阶（一）
+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 *********/
+    String name;
+    String 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 *********/
+    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 *********/
+    double weight;
+	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 *********/
+}
+第2关：封装、继承和多态进阶（二）
+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 test;
+		// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
+		Person person1=new Chinese(cName,cSex,cAge);
+		// 通过showEat()方法调用Chinese的eat()方法
+		showEat(person1);
+		// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
+		Person person2=new English(eName,eSex,eAge);
+		// 通过showEat()方法调用English的eat()方法
+		showEat(person2);
+		/********* begin *********/
+		/********* end *********/
+		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
+		Chinese d=(Chinese)person1;
+		d.shadowBoxing();
+		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
+		English e=(English)person2;
+		e.horseRiding();
+		/********* begin *********/
+
+		/********* end *********/
+	}
+
+	// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
+	/********* begin *********/
+	
+	public static void showEat(Person p){
+        p.eat();
+    }
+	/********* end *********/
+}
+// 抽象类Person 封装属性name、sex和age
+// 构造函数初始化name、sex和age
+// 声明抽象方法eat()
+abstract class Person {
+	/********* begin *********/
+	public String name;
+	public String sex;
+	public int age;
+	abstract void eat();
+	/********* end *********/
+}
+// Chinese类继承自Person类
+// 构造函数初始化name、sex和age
+// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
+// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
+class Chinese extends Person {
+	/********* begin *********/
+	public String name;
+	public String sex;
+	public int age;
+	Chinese(String name,String sex,int age){
+		this.name=name;
+		this.sex=sex;
+		this.age=age;
+	}
+	void eat(){
+		System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是中国人，我喜欢吃饭！");
+	}
+	void shadowBoxing(){
+		System.out.println(name+"在练习太极拳！");
+	}
+	/********* end *********/
+}
+// English类继承自Person类
+// 构造函数初始化name、sex和age
+// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
+// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
+class English extends Person {
+	/********* begin *********/
+	public String name;
+	public String sex;
+	public int age;
+	English(String name,String sex,int age){
+		this.name=name;
+		this.sex=sex;
+		this.age=age;
+	}
+	void eat(){
+		System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");
+	}
+	void horseRiding(){
+		System.out.println(name+"在练习骑马！");
+
+	}
+	/********* end *********/
+}
+第3关：封装、继承和多态进阶（三）
+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);
+		System.out.println(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);
+		System.out.println(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);
+		System.out.println(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);
+		System.out.println(bcName+"---"+bcAge);
+		bc.sleep();
+		bc.eat();
+		bc.teach();
+		/********* end *********/
+		System.out.println("----------------");
+	}
+}
+
+// 说英语接口 声明抽象方法speak()
+interface SpeakEnglish {
+	/********* begin *********/
+	abstract void speak();
+	/********* end *********/
+}
+
+// 定义人的抽象类Person 封装name和age
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 定义具体方法sleep() 输出'人都是要睡觉的'
+// 抽象方法eat()（吃的不一样）
+abstract class Person {
+	/********* begin *********/
+	String name;
+	int age;
+	Person(String name,int age){
+		this.name=name;
+		this.age=age;
+	}
+	void sleep(){
+		System.out.println("人都是要睡觉的");
+	}
+	abstract void eat();
+	/********* end *********/
+}
+
+// 定义运动员Player（抽象类）继承自Person类
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
+abstract class Player extends Person {
+	/********* begin *********/
+	Player(String name,int age){
+		super(name,age);
+	}
+	abstract void study();
+	/********* end *********/
+}
+
+// 定义教练Coach（抽象类）继承自Person类
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 教练教的不一样 定义抽象方法teach()
+abstract class Coach extends Person {
+	/********* begin *********/
+	Coach(String name,int age){
+		super(name,age);
+	}
+	abstract void teach();
+	/********* end *********/
+}
+
+// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
+// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
+// 实现自己的speak()方法 输出'乒乓球运动员说英语'
+class PingPangPlayer extends Player implements SpeakEnglish {
+	/********* begin *********/
+	PingPangPlayer(String name,int age){
+		super(name,age);
+	}
+	void eat(){
+		System.out.println("乒乓球运动员吃大白菜，喝小米粥");
+	}
+	void study(){
+		System.out.println("乒乓球运动员学习如何发球和接球");
+	}
+	public void speak(){
+		System.out.println("乒乓球运动员说英语");
+	}
+	/********* end *********/
+}
+
+// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
+// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
+class BasketballPlayer extends Player {
+	/********* begin *********/
+	BasketballPlayer(String name,int age){
+		super(name,age);
+	}
+	void eat(){
+		System.out.println("篮球运动员吃牛肉，喝牛奶");
+	}
+	void study(){
+		System.out.println("篮球运动员学习如何运球和投篮");
+	}
+	/********* end *********/
+}
+
+// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
+// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
+// 实现自己的speak()方法 输出'乒乓球教练说英语'
+class PingPangCoach extends Coach implements SpeakEnglish {
+	/********* begin *********/
+	PingPangCoach(String name,int age){
+		super(name,age);
+	}
+	void eat(){
+		System.out.println("乒乓球教练吃小白菜，喝大米粥");
+	}
+	void teach(){
+		System.out.println("乒乓球教练教如何发球和接球");
+	}
+	public void speak(){
+		System.out.println("乒乓球教练说英语");
+	}
+	/********* end *********/
+}
+
+// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
+// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
+class BasketballCoach extends Coach {
+	/********* begin *********/
+	BasketballCoach(String name,int age){
+		super(name,age);
+	}
+	void eat(){
+		System.out.println("篮球教练吃羊肉，喝羊奶");
+	}
+	void teach(){
+		System.out.println("篮球教练教如何运球和投篮");
+	}
+	/********* end *********/
+}
+第 6 章 Java面向对象之常用类
+Java面向对象 - String类
+第1关：length()方法与compareTo()方法的使用 - 花名册
+package step1;
+import java.util.Scanner;
+
+public class Roster {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        /********** Begin *********/
+		String str1 = scanner.next();
+		String str2 = scanner.next();
+		String str3 = scanner.next();
+		String str7 = scanner.next();
+		String str4 = scanner.next();
+		String str5 = scanner.next();
+		String str6 = scanner.next();
+		String str8 = scanner.next();
+		String roster1 = str1+" "+str2+" "+str3+" "+str7;
+		String roster2 = str4+" "+str5+" "+str6+" "+str8;
+		System.out.println(roster1.length());
+		System.out.println(roster1.length());
+		if(roster1.compareTo(roster2) == 0){
+			System.out.println("相同");
+		}else{
+			System.out.println("不相同");
+		}
+
+        /********** End *********/
+    }
+}
+
+第2关：substring()方法与indexOf()方法的使用 - 姓名查找
+
+package step2;
+
+import java.util.Scanner;
+
+public class NameSearch {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        /********** Begin *********/
+		String data = scanner.next();
+		String name = scanner.next();
+		
+		int j,k = 0;
+    	for(int i = 0;i<data.length();){
+
+			j = data.indexOf(name,i);
+
+			if(j != -1){
+				if(j != k) {
+					System.out.println(j);
+				}
+        	}else {
+            	break;
+        	}
+        	k=j;
+        	i  = i+name.length();
+		}	
+        /********** End *********/
+    }
+}
+
+第3关：String串类操作 - 文件名与邮箱验证
+
+package step3;
+
+public class HelloWorld {
+
+	public void judge(String fileName,String email){
+		//请在此添加实现代码
+/********** Begin **********/
+		String str1 = ".java";
+        if(fileName.indexOf(str1) > 0) {
+			String str2 = fileName.substring(fileName.length()-str1.length());
+            if (str1.equals(str2) && str1.length() < fileName.length()) {
+                System.out.println("Java文件名正确");
+            }else {
+            System.out.println("Java文件名无效");
+        	}
+        }else {
+            System.out.println("Java文件名无效");
+        }
+        int a = email.lastIndexOf("@");
+        int b= email.lastIndexOf(".");
+         if(a > 0 && b > 0) {
+             if (a > 0 && a < b) {
+                 System.out.println("邮箱名正确");
+             }else {
+            	System.out.println("邮箱名无效");
+			 }
+        }else {
+            System.out.println("邮箱名无效");
+        }
+
+/********** End **********/
+	}
+	
+	
+}
+
+第4关：StringBuffer类的定义和使用 - 字母反转
+
+package step4;
+
+public class Reverse {
+    public static StringBuffer start(String data) {
+        StringBuffer ans = new StringBuffer();
+        /********** Begin *********/
+		String[] str2  = data.split(" ");
+        String str3 = null;
+        for(int i = 0;i < str2.length;i++){
+            StringBuffer stringBuffer = new StringBuffer(str2[i]);
+            str2[i] = stringBuffer.reverse().toString();
+            if(i == 0){
+                str3 = str2[0];
+            }
+            if(i > 0) {
+                str3 = str3 + " " + str2[i];
+            }
+        }
+		ans = new StringBuffer(str3);
+        /********** End *********/
+        return ans;
+    }
+}
+
+Java面向对象 - 包装类
+第1关：基本数据类型和包装类之间的转换
+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 = new Double(88.88);	
+		//手动拆箱
+		double d1 = d.doubleValue();	
+		//自动拆箱
+		double d2 = d;	
+		System.out.println("拆箱结果为：" + d1 + "和" + d2);
+/********** End **********/
+	}
+}
+
+第2关：包装类转换成其他数据类型
+	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.intValue()       ;
+		System.out.println("Integer包装类：" + score1);
+		System.out.println("double类型：" + score2);
+		System.out.println("float类型：" + score3);
+		System.out.println("int类型：" + score4);
+/********** End **********/	
+	}
+}
+
+第3关：包装类与字符串之间的转换
+
+package step3;
+public class Task {
+public static void main(String[] args) {
+double a = 78.5; 
+//请在此添加实现代码
+/********** Begin **********/
+//将基本类型a转换为字符串
+		String str =String.valueOf(a)      ; 
+		System.out.println("str + 12  的结果为： "+(str + 12));	
+		String str1 = "180.20";
+	    // 将字符串str1转换为基本类型
+		Double d = Double.parseDouble(str1)     ;
+		System.out.println("d + 100 的结果为： "+ (d + 100));
+/********** End **********/
+	} 
+}
+
+Java面向对象 - 常用类
+第1关：Object类
+
+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是否相等（实际是比较地址）
+		/********* Begin *********/
+        Demo d1=new Demo(num1);
+		System.out.println(d1.toString());
+		Demo d2=new Demo(num1);
+		if (d1.equals(d2)) {
+            System.out.println("true");
+        } else {
+            System.out.println("false");
+        }
+		/********* End *********/
+		// 创建Person类对象p，传入输入值num2，打印判断d1和p是否相等（实际是比较地址）
+		/********* Begin *********/
+         	Person p=new Person(num2);
+		if (d1.equals(p)) {
+            System.out.println("true");
+        } else {
+            System.out.println("false");
+        }
+		/********* 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;
+	}
+}
+
+第2关：JAVA基础类型包装类-练习
+
+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 *********/
+	}
+}
+
+第3关：String&StringBuilder&StringBuffer类-练习
+
+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() 将当前字符串中的英文部分转换为全大写
+		/********* 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 *********/
+	}
+}
+
+第4关：Random类
+
+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);
+			pardStore[26+i]=(char)('a'+i);
+		}
+		for(int i=0;i<10;i++)
+		{
+			pardStore[52+i]= (char)('0' + i);
+		}
+		/********* End *********/
+		// 分别以1、2、3作为种子数 生成6位随机密码
+		Scanner sc = new Scanner(System.in);
+		int seed = sc.nextInt();
+		/********* Begin *********/
+         Random r=new Random(seed);
+		String str="";
+		int[] arr=r.ints(6,0,62).toArray();
+		for(int i=0;i<6;i++)
+		{
+			str+=pardStore[arr[i]];
+		}
+		System.out.print(str);
+		/********* End *********/
+	}
+}
+
+第5关：Date类和SimpleDateFormat类的用法
+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 sdf=new SimpleDateFormat("yyyy-MM-dd");
+		Date d1=sdf.parse(line);
+		Date d2=sdf.parse("2020-10-01");
+		long diff=d2.getTime()-d1.getTime();
+		diff=diff/86400000;
+		System.out.println("你的出生日期距离2020年10月1日:"+diff+"天");
+		/********* End *********/
+	}
+}
+
+第6关：Math类
+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 *********/
+	}
+}
+
+第 7 章 Java面向对象之异常类与文件类
+Java面向对象 - Java中的异常
+第2关：捕获异常
+package step2;
+import java.util.Scanner;
+public class Task {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int num1 = sc.nextInt();
+		int num2 = sc.nextInt();
+		/********* Begin *********/
+		try{
+			System.out.println(num1/num2);
+		}catch(ArithmeticException e){
+			System.out.print("除数不能为0");
+		}
+		
+		
+		/********* End *********/
+	}
+
+}
+
+第3关：抛出异常
+
+package step3;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+public class Task {
+	/********* Begin *********/
+	//请在合适的部位添加代码
+	public static void main(String[] args)throws FileNotFoundException      {	
+		test();
+	}
+	public static void test() throws FileNotFoundException           {
+		File file = new File("abc");
+		if(!file.exists()){		//判断文件是否存在
+			//文件不存在，则 抛出 文件不存在异常
+			throw new FileNotFoundException("该文件不存在");
+		}else{
+			FileInputStream fs = new FileInputStream(file);
+		}
+	}
+	/********* End *********/
+}
+
+第4关：自定义异常
+package step4;
+import java.util.Scanner;
+public class Task {
+	/********* Begin *********/
+	public static void main(String[] args)throws MyException {
+		Scanner sc = new Scanner(System.in);
+		String username = sc.next();
+		//判断用户名
+		if(username.length()<3){
+			throw new MyException("用户名小于三位Exception");
+		}
+		else{
+			System.out.println("用户名格式正确");
+		}
+	}
+}
+class MyException extends Exception{
+	public MyException(){}
+	public MyException(String msg){
+		super(msg);
+	}
+}
+/********* End *********/
+
+第 8 章 集合框架
+Java高级特性 - 集合框架（1）
+第1关：集合的基本使用
+
+package step1;
+// 导包
+/********** Begin **********/
+import java.util.ArrayList;						
+/********** End **********/					
+public class HelloWorld {
+	@SuppressWarnings("unchecked") 
+	public ArrayList getList() {
+		/********** Begin **********/
+		ArrayList list = new ArrayList();
+		list.add("https:www.educoder.net");
+		list.add(2018.423);
+		return list;
+		/********** End **********/
+	}
+}
+
+
+
+第2关：ArrayList集合的增删改查
+
+package step2;
+import java.util.ArrayList;
+import java.util.Scanner;
+public class HelloWorld {
+    @SuppressWarnings("unchecked")
+	public static void main(String[] args) {
+		//获取输入的数据并添加至集合
+		Scanner sc = new Scanner(System.in);
+		ArrayList list = new ArrayList<>();
+        int length = sc.nextInt();
+		for(int i =0 ; i< length; i++){
+			list.add(sc.next());
+		}
+		/********** Begin *********/
+		list.remove(0);
+		list.remove(length-2);
+		list.add("hello");
+		list.add("educoder");
+		list.set(2,"list");
+		for(int i=0;i<list.size();i++){
+		System.out.println(list.get(i));
+		}	
+		/********** End **********/
+	}
+}
+
+第3关：集合的体系结构
+
+package step3;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+public class HelloWorld {
+	public HashSet getHashSet(){
+		/********** Begin **********/
+		HashSet set=new HashSet();
+		set.add("www.educoder.net");
+		return set;
+		/********** End **********/
+	}
+	public ArrayList getArrayList(){
+		/********** Begin **********/
+		ArrayList list=new ArrayList();
+		list.add("www.educoder.net");
+		return list;
+		/********** End **********/
+	}
+	public LinkedList getLinkedList(){
+		/********** Begin **********/
+		LinkedList list=new LinkedList();
+		list.add("www.educoder.net");
+		return list;
+		/********** End **********/
+	}
+	public Map getHashMap(){
+		/********** Begin **********/
+		Map map = new HashMap();
+		map.put("address","www.educoder.net");
+		return map;
+		/********** End **********/
+	}	
+}
+
+
+第4关：泛型
+
+package step4;
+import java.util.*;
+public class HelloWorld {
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		//程序会输入三次数据
+		/********** Begin **********/
+		List<String> list = new ArrayList<String>();
+				while(sc.hasNext()){
+			list.add(sc.next());
+		}
+		for(int i=0;i<list.size();i++){
+			System.out.println("集合的第"+(i+1)+"个数据为："+list.get(i));
+		}
+		/********** End **********/
+	}
+}
+
+第5关：Map集合的增删改查
+
+package step5;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+public class HelloWorld {
+	public static void main(String[] args) {
+		Map<String, Integer> menuDict = new HashMap<>();
+		Scanner sc = new Scanner(System.in);
+		for (int i = 0; i < 5; i++) {
+			menuDict.put(sc.next(),sc.nextInt());
+		}
+		/********** Begin **********/
+		menuDict.put("lamb",50);
+		System.out.println(menuDict.get("fish"));
+		menuDict.put("fish",100);
+		menuDict.remove("noodles");
+		System.out.println(menuDict.toString());
+		/********** End **********/
+	}	
+}
+
+第 11 章 Java IO
+学习-Java输入输出之字节缓冲IO流之复制文件
+第1关：学习-Java输入输出之字节缓冲IO流之复制文件
+
+import java.io.*;
+import java.util.Scanner;
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        Scanner scanner = new Scanner(System.in);     // 获取给定字符串
+        String s = scanner.nextLine();
+         // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 切割给定字符串，获取源文件路径和目标文件路径
+        String[] split = s.split("，");       
+        String  folder= split[0];     // 源文件路径
+        String fileName = split[1];     // 目标文件路径
+        // 创建缓冲流对象，实现文件复制
+         File file = new File(split[1]);
+        try(               
+            BufferedOutputStream bfout= new BufferedOutputStream(new FileOutputStream(file,true));
+            BufferedInputStream bfin= new BufferedInputStream(new FileInputStream(split[0]))) {
+            int read;
+            while((read=bfin.read())!=-1){
+                bfout.write(read);
+            }
+        }
+        // 输出目标文件长度
+        System.out.println("文件长度："+file.length());
+        /********** End **********/
+    }
+}
+
+学习-Java输入输出之文件字符IO流之文件加密
+第1关
+
+import java.io.*;
+
+import static java.lang.Character.isLetterOrDigit;
+
+import java.util.Scanner;
+
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+
+        // 接收给定字符串，获取相关路径
+
+        Scanner sc = new Scanner(System.in);
+
+        String strs = sc.next();  
+
+        String [] str = strs.split("，");
+
+        // 读取源文件
+
+        File file1 = new File(str[0]);
+
+        FileReader fis = new FileReader(file1);
+
+        char[] buffs = new char[(int)file1.length()];
+
+        fis.read(buffs);
+
+        // 加密
+
+        jiami(buffs);
+
+        // 把加密后的内容保存到目标文件
+
+        File file2 = new File(str[1]);
+
+        FileWriter fos = new FileWriter(file2);
+
+            if(str[1].equals("/test/b.txt")){
+                fos.write(buffs,0,(int)file1.length());  
+
+                fis.close();
+
+                fos.close();
+
+                System.exit(0);
+
+        }
+
+        fos.write(buffs,0,(int)file1.length());
+
+        fos.flush();
+
+        fis.close();
+
+        fos.close();
+
+}
+
+        // 定义加密方法
+
+        public static void jiami(char[] ch){
+            for(int i=0;i<ch.length;i++){
+                if(ch[i]>='0'&&ch[i]<'9'){
+                    ch[i]++;
+
+                }
+
+                else if(ch[i]=='9'){
+                    ch[i]='0';
+
+                }
+
+                else if((ch[i]>='a'&&ch[i]<'z')||(ch[i]>='A'&&ch[i]<'Z')){
+                    ch[i]++;
+
+                }
+
+                else if(ch[i]=='z'){
+                    ch[i]='a';
+
+                }
+
+                else if(ch[i]=='Z'){
+                    ch[i]='A';
+
+                }
+
+            }        
+
+        }
+
+        /********** End **********/
+
+}
+学习-Java输入输出之对象IO流之序列化一个对象
+第1关
+myproject/src/step 1/File Testjava
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException, ClassNotFoundException {
+        // 接收给定的数据
+        Scanner scanner = new Scanner(System.in);
+        String filedir = scanner.next();
+        String name = scanner.next();
+        int age = scanner.nextInt();
+ 
+        // 请在此编写代码
+        /********** Begin **********/
+        // 创建Student对象
+        Student stu = new Student(name,age);
+        // 给对象属性赋值
+        File file = new File(filedir);
+        // 序列化对象到文件中，并通过反序列化读取文件内容，最后打印对象的所有属性
+        ObjectOutputStream oos = new ObjectOutputStream(new  FileOutputStream(file));
+        
+        oos.writeObject(stu);
+ 
+        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
+ 
+        System.out.print(ois.readObject());
+        /********** End **********/
+ 
+    }
+}
+
+myproject/src/step 1/Student.java
+
+import java.io.Serializable;
+public class Student implements Serializable {
+    public String name;
+    public int age;
+    public Student(String name,int age){
+        this.name=name;
+        this.age=age;
+    }
+    public String toString (){
+       return this.name+"\n"+this.age;
+    }
+}
+ 
+学习-Java输入输出之随机IO流之向文件中追加内容
+第1关
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定的字符串
+        Scanner scanner = new Scanner(System.in);
+        String str = scanner.nextLine();
+        // 切割字符串
+        String[] split = str.split("，");
+        // 通过文件对象创建RandomAccessFile对象
+        File file = new File(split[0]);
+        try(
+                RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw");
+        ){
+        // 移动指针位置
+        randomAccessFile.seek(randomAccessFile.length());
+        // 追加给定内容
+        randomAccessFile.write(split[1].getBytes());
+        // 打印追加内容后的文件指针位置
+        System.out.print(randomAccessFile.getFilePointer());
+        }
+        /********** End **********/
+    }
+}
+学习-Java输入输出之数组IO流之将给定整数转换为字符串
+第1关
+
+import java.io.*;
+import java.util.Scanner;
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在此编写代码
+        /********** Begin **********/
+        // 创建ByteArrayOutputStream对象
+        try (
+            ByteArrayOutputStream bOutput = new ByteArrayOutputStream();) {
+            // 获取给定数据并写入ByteArrayOutputStream流中
+            Scanner scanner = new Scanner(System.in);
+            while(!scanner.hasNext("%")){
+            bOutput.write(scanner.nextInt());
+            }
+            // 从流中取出数据
+            byte b[] = bOutput.toByteArray();
+            // 将数据转换为字符串，并输出结果
+            System.out.println(new String(b));
+        }
+            /********** End **********/
+    }
+}
+学习-Java输入输出之数据IO流之向文件中写入数字并读取
+第1关
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 接收给定的数据
+        Scanner scanner = new Scanner(System.in);
+        String filedir = scanner.next();
+        int num1 = scanner.nextInt();
+        int num2 = scanner.nextInt();
+        int num3 = scanner.nextInt();
+        // 请在此编写代码
+        /********** Begin **********/
+        // 将数字写入文件中
+        try (
+                // 通过文件字节输出流创建DataOutputStream对象
+                DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(filedir));
+                // 通过文件字节输入流创建DataInputStream对象
+                DataInputStream dataInputStream = new DataInputStream(new FileInputStream(filedir));) {
+                dataOutputStream.writeInt(num1);
+                dataOutputStream.writeInt(num2);
+                dataOutputStream.writeInt(num3);
+         // 从文件中读取数字，并输出结果
+                for(int n=0;n<3;n++){
+                    int num = dataInputStream.readInt();
+                    System.out.println("读取的数字为："+num);
+                }
+        }
+        /********** End **********/
+    }
+}
+
+
+Java高级特性 - IO流
+第2关
+
+package step2;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+public class Task {
+    public void task() throws IOException{
+        /********* Begin *********/
+        FileInputStream fs = new FileInputStream("src/step2/input/task.txt");
+        byte[] b = new byte[8];
+        fs.read(b);
+        String str = new String(b);
+        System.out.println(str);
+        File dir = new File("src/step2/output/");
+        if(!dir.exists()){
+            dir.mkdir();
+        }
+        FileOutputStream fos = new FileOutputStream("src/step2/output/output.txt");
+        String out = "learning practice";
+        byte[] outByte = out.getBytes();    //将字符串转换成字节
+        fos.write(outByte);                    //写数据
+        //释放资源
+        fs.close();
+        fos.close();
+        /********* End *********/
+    }
+}
+第3关
+package step3;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class Task {
+	
+	public void task() throws IOException{
+		/********* Begin *********/
+		String file1 = "src/step3/input/input.txt";   //创建文件
+		FileReader fr = new FileReader(file1);   //实例化
+		char[] ch = new char[8];  //创建数组
+		fr.read(ch);              //将文件的数据读入到数组中（从前到后）
+
+		String file2="src/step3/output/output.txt";//创建文件
+        FileWriter fw = new FileWriter(file2); // 实例化
+        fw.write(ch); // 读入数组中的数据到文件中（从后到前）
+
+        fr.close();   //关闭流
+        fw.flush();   //刷新流
+        fw.close();   //关闭流
+		/********* End *********/		
+	}
+}
+第4关
+
+package step4;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class Task {
+	
+	public void task() throws IOException{
+		/********* Begin *********/
+		FileReader fr = new FileReader("src/step4/input/input.txt");
+		FileWriter fw = new FileWriter("src/step4/output/output.txt");
+		int len = 0;
+		char[] cha = new char[1024];
+		while ( (len = fr.read(cha) ) != -1) 
+		{
+			fw.write(cha , 0 , len);
+		}
+		fr.close();
+		fw.flush();
+		fw.close();
+		
+		FileInputStream fs = new FileInputStream("src/step4/input/input.jpg");
+		FileOutputStream fo = new FileOutputStream("src/step4/output/output.jpg");
+		int le = 0;
+		byte[] bt = new byte[1024];
+		while ( (le = fs.read(bt) ) != -1)
+		{
+			fo.write (bt , 0 , le);
+		}
+		fs.close();
+		fo.flush();
+		fo.close();		
+		/********* End *********/		
+	}
+}
+
+abl,1=
+ 
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 定义员工抽象类 Employee，其中包含 2 个受保护的变量和两个抽象方法
+abstract class Employee{
+// 两个受保护的变量：姓名 name（String），和工资 salary（double）；
+    protected String name;
+    protected double salary;
+//抽象方法 work，无返回值，表示工作内容
+    public abstract void work();
+//抽象方法 info，无返回值，表示员工信息
+    public abstract void info();
+}
+// 定义一个公开的经理类 Manager，该类继承员工类，除了有员工类的基本属性外，还有岗位级别 gender（String）私有属性。
+public class Manager extends Employee{
+    private String gender;
+    // 定义一个有参构造方法
+    public Manager(String name,double salary,String gender){
+        super();
+        this.name=name;
+        this.salary=salary;
+        this.gender=gender;
+    }
+// 重写 work() 方法，输出：“我负责对施工项目实施全过程、全面管理。”；
+@Override
+public void work(){
+    System.out.println("我负责对施工项目实施全过程、全面管理。");
+}
+// 重写 info() 方法，输出：“姓名：xx，工资：xx，岗位级别：xx”。
+public void info(){
+    System.out.println("姓名：" + name + "，工资：" + salary + "，岗位级别：" + gender);
+}
+}
+    
+ 
+    
+    
+ 
+ 
+/********** End **********/学习-Java继承和多态之abstract类
+abstract,1=
+/**
+ * 通过图形类的计算面积的方法，计算矩形和三角形的面积。
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 将 Shape 类改为抽象类
+abstract public class Shape {
+ 
+    public int width; // 几何图形的宽
+    public int height; // 几何图形的高
+ 
+    public Shape(int width, int height) {
+        this.width = width;
+        this.height = height;
+    }
+  abstract  public double area();
+    // 定义一个抽象方法 area()，返回值类型为 double，计算图形的面积
+ 
+}
+// Rectangle 为矩形类，该类继承 Shape 类，并拥有 Shape 类的属性
+class Rectangle extends Shape {
+ public Rectangle(int width,int height)
+ {
+     super(width,height);
+ }
+    // 定义一个有参构造器
+  
+public double area()
+{
+    return width*height;
+}
+    // 重写抽象方法 area，计算矩形的面积（高*宽），并将计算结果返回
+   
+}
+// Triangle 为矩形类，该类继承 Shape 类，并拥有 Shape 类的属性
+class Triangle extends Shape{
+    public Triangle(int width,int height)
+ {
+     super(width,height);
+ }
+    // 定义一个有参构造器
+    
+public double area()
+{
+    return width*height/2;
+}
+    // 重写抽象方法 area，计算三角形的面积（高\*宽/2），并将计算结果返回
+    
+}
+/********** End **********/练习-Java继承和多态之abstract类
+addcs,1=
+/**
+ * 定义一个名为 add 的静态方法，返回值为 int，参数数量可变，且为 int，将这些参数相加后返回。
+ */
+ 
+public class Add {
+    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+    /********* Begin *********/
+ 
+static int add(int...args)
+{
+    int sum=0;
+    for(int i=0;i<args.length;i++)
+{
+sum=sum+args[i];
+}
+return sum;
+}
+public static void main(int[]args)
+{
+    System.out.print("add(25,36)的值为："+  Add.add(25,36));
+    System.out.print("add(58,96,754)的值为："+Add.add(58,96,754));
+  
+}
+ 
+    /********** End **********/
+}练习-Java类和对象之可变参数
+ascll,1=
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定的字符串（单词）
+        Scanner input = new Scanner(System.in);
+        String str = input.next();
+		// 定义变量
+        int sum = 0;
+        // 将字符串转为字节数组
+        byte[] array = str.getBytes();
+        // 累加单词中各字母的ASCII码值
+        for (byte i : array){
+            sum += i;
+        }
+        // 输出累加值
+        System.out.println(sum);
+        /********** End **********/
+ 
+    }
+}
+练习-Java字符串之字符串、字符数组与字节数组间的使用之统计单词中各字母的ASCII码值的和
+bcdq,1=
+package step1;
+ 
+ 
+import java.io.*;
+import java.util.*;
+ 
+public class SortArray {
+ 
+    public static void main(String[] args) {
+        /********** Begin **********/
+        // 创建保存整型数据的数组(数组大小10)
+        int[] data = new int[10];
+ 
+        // 给数组赋随
+        Scanner sc = new Scanner(System.in);
+        for (int i = 0; i < data.length; i++) {
+            data[i] = sc.nextInt();
+        }
+        // 将数组元素按有小到大顺序排列
+        Arrays.sort(data);
+ 
+        try {
+            // 创建数据保存文件，如果文件不存在，重新创建
+            File file = new File("data.txt");
+            if (!file.exists()) {
+                file.createNewFile();
+            }
+            // 创建FileOutputStream和DataOutputStream 输出流
+            FileOutputStream fileOutputStream = new FileOutputStream(file);
+            DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
+ 
+            // 利用输出流向文件中写入数组数据
+            for (int datum : data) {
+                dataOutputStream.writeInt(datum);
+            }
+ 
+            // 关闭输出流
+            dataOutputStream.close();
+ 
+            // 创建FileInputStream和DataInputStream 输入流
+            FileInputStream fileInputStream = new FileInputStream(file);
+            DataInputStream dataInputStream = new DataInputStream(fileInputStream);
+ 
+            // 利用输入流从文件读取数据并输出
+            for (int i = 0; i < data.length; i++) {
+                System.out.print(dataInputStream.readInt());
+                if (i != data.length - 1) {
+                    System.out.print("<");
+                }
+            }
+            System.out.println();
+            // 关闭输入流
+            dataInputStream.close();
+ 
+        } catch (IOException e) {
+            // 异常处理
+            System.out.println("读写发生异常");
+        }
+        /********** End **********/
+    }
+}
+字节输入/输出流实现数据的保存和读取
+bddy,1=
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 声明一个名为 com.pojo 的包
+package com.pojo;
+ 
+public class Student {
+    public static String[] info(){
+        // 实现返回所有学生的功能，在该方法中定义一个 String 数组
+        String arry[]={"小明","小红","小强","小刚"};
+        return arry;
+        // 返回该数组
+        
+    }
+}
+/********** End **********/
+学习-Java类和对象之包的定义
+bhcx,1=
+ public class GeTest {
+    // 判断整数是否是素数
+    public static boolean isPrime(int x){
+       for(int y=2;y<x;y++){
+           if(x%y==0){
+               return false;
+           }
+       }
+       return true;
+    }
+    public static void main(String[] args) {
+        // 验证 7-100 之间的数符合哥德巴赫猜想
+         // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+      for(int i=7;i<100;i++){
+            for(int j=2;j<=i/2;j++){
+                if(isPrime(j)&&isPrime(i-j))
+                    System.out.printf("%d可分解为素数%d和素数%d\n",i,j,i-j);
+            }
+           
+        }
+        /********** End **********/
+    }
+}练习-Java循环综合练习二之哥德巴赫猜想
+bjdx,1=
+import java.util.Scanner;
+
+// 创建一个名为 Compare 的公开类
+public class Compare{
+    public double a;
+    public double b;
+    
+    double compare(double a,double b){		//因为返回值为double类型
+        double max = a;		
+        if(a < b)				
+            max = b;
+
+        return max;
+    }
+
+    void Compare(){					//无参构造方法为new做准备
+
+    }
+
+    public static void main(String[] args){
+        Scanner sc = new Scanner(System.in);
+        double a = sc.nextDouble();
+        double b = sc.nextDouble();
+        Compare com = new Compare();		//通过Compare类创建com对象
+        System.out.print(com.compare(a,b));		//通过对象调用类中方法，我看着怎么好像有点多此一举，实际上可以直接调用吧……
+        
+    }
+}
+练习-Java类和对象之构造方法与对象创建之比较大小
+bjjk,1=
+    /**
+     * 编写程序，实现两个数的求和运算和比较
+     */
+    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+    /********** Begin **********/
+    // 定义一个接口类 Compute
+    interface Compute {
+        // 第一个为 sum()，实现两个数的相加，返回值为 int
+        public int sum();
+        // 第二个为 max()，比较两个数的大小，携带两个参数，类型为int，返回值为int
+        public int max(int a,int b);
+    }
+    // 定义一个公开的 ComputeClass 类并实现 Compute 接口
+    public class ComputeClass implements Compute {
+        // 有两个属性，分别表示两个数，类型为 int
+        private int num1;
+        private int num2;
+        // 有参构造方法
+        public ComputeClass(int num1,int num2) {
+            this.num1 = num1;
+            this.num2 = num2;
+        }
+        // 实现接口中的求和方法
+        @Override
+        public int sum() {
+            return num1 + num2;
+        }
+        // 实现接口中的获取较大数的方法
+        @Override
+        public int max(int a,int b) {
+            if(a >= b) {
+                return a;
+            } else {
+                return b;
+            }
+        }
+    }
+    /********** End **********/
+学习-Java继承和多态之接口
+blyc,1=
+/**
+ * 任务：定义一个 NewWeight 的公开类，并继承 OldWeight 类，在该类中实现计算身高的标准体重。
+ */
+class OldWeight {
+    double height = 175;
+    public double getWeight(){
+        return height - 105;
+    }
+}
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 定义一个NewWeight的公开类，并继承OldWeight类
+public class NewWeight extends OldWeight
+{
+    double height;
+    public NewWeight(double height)
+    {
+        this.height=height;
+    }
+    public double weight()
+    {
+        return height-105;
+    }
+ 
+}
+ 
+    // 定义一个变量height，类型为double
+ 
+    // 定义一个有参构造方法，携带身高参数
+ 
+    // 定义一个方法名为weight的方法，返回类型为double，计算现在的标准体重并返回
+ 
+/********** End **********/练习-Java继承和多态之成员变量隐藏
+cjpd,1=
+import java.util.Scanner;
+/**
+ * 任务：判断学生的成绩是否合格（成绩分数不低于 60 ）
+ */
+public class ApplicationTest {
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明 double 类型变量 score  获取控制台输入的学生成绩
+        double score = scanner.nextDouble();
+		// 声明 int 类型变量 temp 用来保存学生成绩是否合格的结果（1 或者 0）
+		int temp;
+        /********** Begin **********/
+        // 使用三元表达式，判断变量 score 是否小于 60 ，如果小于 60 ，则将数值 0 赋值给变量 temp；反之，则将数值 1 赋值给变量 temp
+        temp = score >= 60 ? 1:0; 
+        /********** End **********/
+		String result = temp == 1 ? "合格":"不合格";
+        System.out.println("该学生成绩判定为：" +result );
+    }
+}学习-Java双路分支之条件表达式之成绩判断
+cjtj,1=
+/*
+* 任务：统计每人的总分。
+* 输出样式：x号学生的总分：y
+*
+* */
+public class PassWord {
+    public static void main(String[] args) {
+        // 创建二维数组存储所有人的成绩
+        int[][] arr = new int[][]{{90,88,87},{89,90,77},{66,78,60},{77,90,90},{89,78,67},{78,87,88}};
+       
+       int[] sum = new int[6];
+
+       for (int i = 0 ; i < 6; i++){
+           for (int j = 0; j < 3; j++){
+               sum[i] = arr[i][j] + sum[i];
+           }
+
+           System.out.println( (i+1) + "号学生的总分："+ sum[i]);
+       }
+
+    }
+}学习-Java数组之二维数值数组之多科成绩统计
+cjzfc,1=
+/*
+任务：
+1.获取输入值，第一个为整数，代表数组长度，最后一个为%，代表终止输入，中间的值为一组字符
+2.把输入值中的第二个到倒数第二个字符赋值给一维数组
+3.对数组排序
+4.通过字符数组创建字符串
+5.输出字符串
+*/
+import java.util.Arrays;
+import java.util.Scanner;
+public class StrTest {
+    public static void main(String[] args) {
+// 请在Begin-End间编写代码
+/********** Begin **********/
+// 第一步：获取输入值，第一个为整数，代表数组长度，最后一个为%，代表终止输入，中间的值为一组字符
+        Scanner scanner = new Scanner(System.in);
+        int m= scanner.nextInt();
+        char [] arr=new char[m];     // 定义原一维数组
+        int n=0;
+        while(!scanner.hasNext("%")){
+            arr[n] = scanner.next().charAt(0);
+            n++;
+        }
+// 第二步：对字符数组排序
+        Arrays.sort(arr);
+// 第三步：通过字符数组的方式创建字符串
+        String s = new String(arr);
+// 第四步：输出字符串内容
+        System.out.print(s);
+/********** End **********/        
+    }
+}练习- Java字符串之String类创建字符串之字符数组创建字符串
+continue,1=
+/*
+任务：使用Scanner对象接收给定的一个整数，统计小于该整数的正奇数个数。
+输出格式：5前面共有2个奇数。
+*/
+import java.util.Scanner;
+
+public class ContinueTest {
+    public static void main(String[] args) {
+        
+        // 定义变量count，用于统计奇数个数，并赋初值为0。
+        int count = 0;
+        // 创建Scanner对象
+        Scanner sc = new Scanner(System.in);
+        // 获取输入值
+        int n = sc.nextInt();
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 第一步：编写for循环从1到n之间循环取数
+        for (int i = 0;i<n;i++){
+            if (i%2==0){
+                continue;
+            }
+               count++;
+        }
+        // 第二步：判断是否为偶数，如果是，跳出本次循环，如果不是，对奇数个数变量值加1
+          System.out.println(n+"前面共有"+count+"个奇数。");
+        // 第三步：循环结束，输出总的奇数个数
+        
+        /********** End **********/
+
+    }}
+学习-Java循环之continue
+cxff,1=
+/**
+ * 任务：重写 Cat 类中的 toString 方法，返回 Cat 类的基本信息。
+ */
+class Animal{
+    private String name; // 动物名称
+    private int age; // 动物年龄
+	
+	// 返回动物类的基本信息
+    public String toString() {
+        return "Anaimal{" +
+                "name='" + name + '\'' +
+                ", age=" + age +
+                '}';
+    }
+}
+public class Cat extends Animal{
+    private String name; // 小猫的名称
+    private int age; // 小猫年龄
+ 
+    public Cat(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+    /********* Begin *********/
+    // 重写 Anaimal 中的 toString 方法，返回类型为 String，格式：我是一只名为xx的小猫，今年xx岁了
+    @Override
+public String toString(){
+    return "我是一只名为" + name + "的小猫，今年" + age + "岁了";
+ 
+}
+ 
+    /********** End **********/
+}学习-Java继承和多态之方法重写
+czff,1=
+/**
+ * 任务：使用重载方法为 Student 类创建三个构造方法。
+ * 类名为：Student
+ */
+public class Student {
+    private String name;  // 学生的姓名
+    private String num;  // 学生的学号信息
+    private double grades;  // 学生的成绩
+    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+    /********** Begin **********/
+    // 创建一个有参构造函数，携带一个学生姓名的参数
+public Student (String name){
+    this.name=name;
+}
+    // 创建一个有参构造函数，携带学生姓名和学生学号信息的参数
+public Student(String name,String num){
+    this.name=name;
+    this.num=num;
+}
+    // 创建一个有参构造函数，携带学生姓名、学生学号和学生成绩信息的参数
+public Student(String name,String num,double grades){
+    this.name=name;
+    this.num=num;
+    this.grades=grades;
+}
+    /********** End **********/
+    public String getName() {
+        return name;
+    }
+ 
+    public void setName(String name) {
+        this.name = name;
+    }
+ 
+    public String getNum() {
+        return num;
+    }
+ 
+    public void setNum(String num) {
+        this.num = num;
+    }
+ 
+    public double getGrades() {
+        return grades;
+    }
+ 
+    public void setGrades(double grades) {
+        this.grades = grades;
+    }
+    
+    @Override
+    public String toString() {
+        return "Student{" +
+                "name='" + name + '\'' +
+                ", num='" + num + '\'' +
+                ", grades=" + grades +
+                '}';
+    }
+    
+}学习-Java继承和多态之方法重载
+dbxmj,1=
+/**
+ * 任务：计算一个由正方形和等腰三角形组成的多边形的面积，其中正方形边长4厘米，等腰三角形底边为正方形的一条边，其到对角顶点的高为2.6厘米。
+ * 类名为：PolygonalArea
+ */
+public class PolygonalArea {
+    public static void main(String[] args) {
+    	 
+         
+         int square_length = 4;  // 声明int型变量square_length用于表示正方形边长，并赋值 4
+         double triangle_h = 2.6;  // 声明double型变量triangle_h用于表示三角形底边上的高，并赋值 2.6
+         // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+         /********** Begin **********/
+         // 第1步：计算正方形面积，赋值给变量area_square
+         double area_square = square_length*square_length;
+         // 第2步：计算等腰三角形面积，赋值给变量area_triangle
+         double area_triangle = square_length*triangle_h/2;
+         // 第3步：计算多边形面积，即正方形面积和等腰三角形面积，赋值给变量area_total
+          double area_total = area_square +area_triangle;
+         // 第4步：打印输出多边形面积，即使用不换行输出语句输出变量area_total的值 输出格式：该多边形的面积为 xxx      其中xxx 为多边形的面积
+         System.out.print("该多边形的面积为 "+area_total);
+
+
+        /********** End **********/
+
+    }
+} 
+学习-Java顺序结构之无输入求多边形的面积
+dcif,1=
+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);
+ /******start******/
+ int score = sc.nextInt();
+ if(score>90){
+ System.out.println("*****五星成绩");
+ }
+ else if(score>80){
+ System.out.println("****四星成绩");
+ }
+ else if(score>70){
+ System.out.println("***三星成绩");
+ }
+ else if(score>60){
+ System.out.println("**俩星成绩");
+ }
+ else{
+ System.out.println("无星成绩");
+ }
+ /******end******/
+ }
+}
+Java 分支结构之多重 if 
+dcpx,1=
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定的单词
+        Scanner input = new Scanner(System.in);
+        String str = input.next();
+        // 对单词重新排序（按照单词中的字母升序排序）
+        char[] array = str.toCharArray();
+        Arrays.sort(array);
+        // 输出新单词
+        System.out.println(array);
+        /********** End **********/
+ 
+    }
+}学习-Java字符串之字符串、字符数组与字节数组间的使用之单词重新排序
+dcsl,1=
+/*
+任务：接收输入值（整数数列），统计出等差数列的均值，每组输入以%结束，比如1 3 5 %。
+其中百分号的作用是：在while循环中判断输入为%时，终止循环。
+ 
+*/
+ 
+import java.util.Scanner;
+ 
+public class WhileTest {
+	
+    public static void main(String[] args) {
+        // 定义变量sum，用于求等差数列的和
+        int sum=0;
+        // 定义变量z，记录等差数个数
+        int z=0;
+        // 创建Scanner对象
+        Scanner input = new Scanner(System.in);
+        // 请在 Begin-End 间编写代码
+        /********** Begin **********/
+        // 第一步：使用while循环接收Scanner对象接收的值，当下一个值等于%时，终止循环
+        char x = '0';
+        while(!input.hasNext("%")){
+        // 第二步：获取输入值
+            double n = input.nextDouble();
+        // 第三步：对输入的数列值求和
+            sum+=n;
+        // 第四步：统计数列个数
+            z++;
+        }
+        // 第五步：数列中值的总和，除以数列个数求出均值（保留两位小数）
+        double s=(double)sum/z;
+       System.out.print(String.format("%.2f",s));
+        /********** End **********/
+ 
+        }
+}练习-Java循环while之等差数列均值
+dxsz,1=
+/**
+ * 任务：使用对象数组的方式创建 3 个 Dog 对象
+ * 类名为：Dog
+ * 该类为 Dog 的基本属性
+ */
+public class Dog {
+    private String name;     // 小狗名称
+    private String type;     // 小狗品种
+    private int age;     // 小狗年龄
+    private String hobby;    //小狗爱好
+ 
+    public Dog(){
+ 
+    }
+    public Dog(String name, String type, int age, String hobby) {
+        this.name = name;
+        this.type = type;
+        this.age = age;
+        this.hobby = hobby;
+    }
+	
+    // 获取Dog姓名
+    public String getName() {
+        return name;
+    }
+ 
+    // 设置Dog姓名
+    public void setName(String name) {
+        this.name = name;
+    }
+	// 获取Dog种类
+    public String getType() {
+        return type;
+    }
+	// 设置Dog种类
+    public void setType(String type) {
+        this.type = type;
+    }
+	// 获取Dog年龄
+    public int getAge() {
+        return age;
+    }
+	// 设置Dog年龄
+    public void setAge(int age) {
+        this.age = age;
+    }
+	
+    // 获取爱好
+    public String getHobby() {
+        return hobby;
+    }
+	// 设置爱好
+    public void setHobby(String hobby) {
+        this.hobby = hobby;
+    }
+	// Dog的详细信息
+    public void info(){
+        System.out.printf("小狗名称：%s\n品种：%s\n小狗年龄：%d\n小狗爱好：%s\n",name,type,age,hobby);
+    }
+ 
+ 
+ 
+    public static void main(String[] args) {
+        Dog d1 = new Dog("Tom", "哈士奇",2,"拆家");
+        Dog d2 = new Dog("jerry", "中华田园犬",3,"护家");
+        Dog d3 = new Dog("旺财","柯基",2,"吃喝玩");
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+        // 将三个狗的对象放进对象数组中，并依次调用该对象的info方法
+Dog dog[]=new Dog[3]; 
+dog[0]=d1;
+dog[0].info();
+dog[1]=d2;
+dog[1].info();
+dog[2]=d3;
+dog[2].info();
+        
+        
+        /********** End **********/
+    }
+}学习-Java类和对象之对象数组
+dxtd,1=
+/**
+ * 任务：使用 instanceof 运算符判断所给对象是否为特定类的一个实例，并输出判断结果。
+ */
+ 
+public class Demo {
+    public static void main(String[] args){
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+        Object hello = "Hello";
+        // 判断hello是否是Object类的实例
+if(hello instanceof Object)
+System.out.println("true");
+else
+System.out.println("false");
+if(hello instanceof String)
+System.out.println("true");
+else
+System.out.println("false");
+if(hello instanceof Math)
+System.out.println("true");
+else
+System.out.println("false");
+ 
+        // 判断hello是否是String类的实例
+ 
+        // 判断hello是否是Math类的实例
+ 
+        // 判断a是否是Object类的实例
+        String a = "hello";
+if(a  instanceof Object)
+System.out.println("true");
+else
+System.out.println("false");
+    }
+}练习-Java继承和多态之子类对象特点
+dxxzh,1=
+/*
+任务：创建一维字符数组并赋值（a，B，A，Z，v，b），并转化该数组中的大小写。
+提示：a-z的ASCII码分别对应：97-122，A-Z的ASCII码分别对应：65-90。
+输出样式：转化后的数组：[x,y,z]
+*/
+import java.util.Arrays;
+ 
+public class MaxTest {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 第一步：创建数组并赋值，值为a，B，A，Z，v，b共6个字符。
+        char[] arr = {'a','B','A','Z','v','b'};
+        // 第二步：遍历数组元素，如果为小写，请转化为大写，如果为大写，请转化为小写。
+        //大小写的ASCII码相差32。
+       for(int i=0;i<arr.length;i++){
+        if(arr[i]>='a'&&arr[i]<='z'){
+            arr[i]-=32;
+        }
+        else if(arr[i]>='A'&&arr[i]<='Z'){
+            arr[i]+=32;
+        }
+       }
+        // 第三步：输出数组元素
+       System.out.println("转化后的数组："+Arrays.toString(arr));
+        /********** End **********/
+    }
+}学习-Java数组之一维字符数组之大小写转换
+fcqj,1=
+import java.util.Scanner;
+
+/**
+ * 任务：求解该方程的值。
+ * 类名为：Equation
+ */
+
+public class Equation {
+    public static void main(String[] args) {
+    	
+    	Scanner reader = new Scanner(System.in);        
+    	double a = reader.nextDouble();
+    	double b = reader.nextDouble();
+    	double c = reader.nextDouble();
+
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+    	
+        // 第一步：判断方程有几个根
+        double x1, x2, x3 = 0;
+        double san = b*b-4*a*c;
+        if (san > 0){
+            x1 = ((-b)+Math.sqrt(san))/(2*a);
+            x2 = ((-b)-Math.sqrt(san))/(2*a);
+            System.out.println("该方程有两个根");
+            System.out.printf("x1 = %.2f，x2 = %.2f",x1,x2);
+        }else if(san == 0 ){
+            x3 = (-b)/(2*a);
+            System.out.println("该方程只有一个根");
+            System.out.printf("x = %.2f",x3);
+        }else{
+            System.out.print("该方程无解");
+        }
+    	// 第二步：如果方程有两个根，计算这两个值，将其按照题目所给的格式输出
+    	
+    	// 第三步：如果方程只有一个跟，计算出该值，将其按照题目所给的格式输出	
+
+		// 第四步：若方程无解，将其按照题目所给的格式输出
+
+
+        /********** End **********/
+    	
+    	
+   	
+    
+    }
+}
+练习-Java分支结构综合练习一之一元二次方程求解
+ffcx,1=
+/**
+ * 重写 Shape 中的 area 方法，计算球的表面积。
+ */
+class Shape {
+    private double r; //球的半径
+    // 球的体积
+    public double area(){
+        double s = (double)3/4*Math.PI*Math.pow(r,3);
+        return s;
+    }
+}
+ 
+public class Sphere extends Shape{
+ 
+    private double r; //球的半径
+    
+    public Sphere(double r) {
+        this.r = r;
+    }
+    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+    /********* Begin *********/
+    // 重写 Shape 中的 area 方法，计算球的表面积，将计算结果返回
+    public double area(){
+        double s = (double)4*Math.PI*Math.pow(r,2);
+        return s;
+    }
+    
+    /********** End **********/
+}
+ 
+    
+ 练习-Java继承和多态之方法重写
+ffcz,1=
+/**
+ * 任务：定义名为 print 的静态方法，携带一个参数，
+ * 无论该参数是 int 型、double 型还是字符串型，都可以将该参数进行打印。
+ */
+public class Print {
+    // 请在下面的Begin-End之间编写正确的代码
+    /********** Begin **********/
+    public static void print(int a){
+        System.out.println(a);
+    }
+    public static void print(double a){
+        System.out.println(a);
+    }
+    public static void print(String a){
+        System.out.println(a);
+    }
+    public static void main(String[] args){
+        int a=10;
+        print(a);
+        double b=30.0;
+        print(b);
+        String c="zhangsan";
+        print(c);
+    }
+    /********** End **********/
+}练习-Java继承和多态之方法重载
+ffszh,1=
+
+/*
+ 任务：使用while循环结合自增运算符获取控制台的一组输入（每组输入包含4个整数，其中有正有负，比如：22 33 -22 32），请求出每组输入的非负数之和
+*/
+
+import java.util.Scanner;
+
+public class MyWhile {
+
+    public static void main(String[] args) {
+	    // 定义变量sum，用于求非负数的和，并赋初值0。
+        int sum=0;
+        // 定义变量i，用于控制循环，并赋初值1。
+        int i=1;
+        // 定义Scanner对象
+        Scanner input = new Scanner(System.in);
+        // 请在 Begin-End 间编写代码
+        
+        /********** Begin **********/
+        // 第一步：定义while循环，循环4次
+       int a =0;
+       while (i<5){
+           a = input.nextInt();
+           if (a>0){
+               sum = sum + a;
+           }
+           i++;
+       }
+        System.out.print(sum);    
+        // 第二步：获取输入值
+            
+        // 第三步：判断输入值是否大于0，对大于0的值累加
+             
+        // 第四步：while循环中的变量加1
+                 
+        // 第五步：打印sum值
+       
+        /********** End **********/
+
+    }
+}
+学习-Java循环while之求非负数之和
+final,1=
+/**
+ * 按照代码文件中提供的注释完成 Demo 类的编写，使得程序正常输出。
+ */
+class DemoTest{
+    int i = 10;
+}
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********* Begin *********/
+ 
+// 将Demo类改为 final形式
+final  class Demo{
+    // 定义一个final、static常量，名为PI，值为3.14
+    final static float PI = 3.14f;
+    // 声明一个final类型的DemoTest对象，命名为demoTest
+    final DemoTest demoTest = new DemoTest();
+    // 声明一个不为final类型的DemoTest对象，命名为demoTest2
+    DemoTest demoTest2 = new DemoTest();
+    // 声明一个final型的数组，类型为int，值为 1,2,3，命名为a
+    final int[] a ={1,2,3}; 
+ 
+    // 删除主函数中错误的代码，使得程序能够正确输出
+    public static void main(String[] args) {
+        Demo demo = new Demo();
+        System.out.println(demo.PI);
+        System.out.println(demo.demoTest2.i);
+        for (int i = 0; i < demo.a.length; i++){
+            demo.a[i] = 9;
+            System.out.println(demo.a[i]);
+        }
+    }
+}
+/********** End **********/练习-Java继承和多态之final关键字
+final,1=
+/**
+ *  调试代码，对代码进行增添、删除和修改等操作，使得程序能够正常运行，输出结果请参照预期输出结果。
+ */
+ 
+// 请在下面的Begin-End之间编写正确的代码
+/********* Begin *********/
+public class Demo {
+    public static void main(String args[]) {
+        Bike1 obj = new Bike1();
+        obj.run();
+        Honda honda = new Honda();
+        honda.run();
+        Yamaha yamaha = new Yamaha();
+        yamaha.run();
+    }
+}
+ 
+ 
+class Bike1 {
+ 
+     int speedlimit = 90; // 定义速度限制
+ 
+    void run() {
+    	// 修改速度限制为 120，并输出
+        speedlimit = 120;
+        System.out.println("speedlimit=120");
+    }
+}
+ 
+class Bike2 {
+	// 输出 running
+     void run() {
+        System.out.println("running");
+    }
+}
+// 继承 Bike2 类
+class Honda extends Bike2 {
+	// 重写 run 方法
+    void run() {
+        System.out.println("running safely with 100kmph");
+    }
+ 
+}
+ 
+ class Bike3 {
+}
+// 继承 Bike3 类
+class Yamaha extends Bike3 {
+    void run() {
+        System.out.println("running safely with 10kmph");
+    }
+}
+/********** End **********/学习-Java继承和多态之final关键字
+fsdb,1=
+package step2;
+ 
+import java.io.*;
+import java.util.Scanner;
+ 
+public class Encrypt {
+  public static void main(String[] args) throws IOException {
+ 
+    // 创建要发送的电报
+    Scanner sc = new Scanner(System.in);
+    String data = sc.next();
+ 
+    // 将电报分割成字符数组
+    /********** Begin **********/
+    char[] a = data.toCharArray();
+    /********** End **********/
+ 
+    // 打开指定存放电报的文件，如果文件不存在，则创建
+    File file = new File("data.txt");
+    if (!file.exists()) {
+      file.createNewFile();
+    }
+ 
+    // 循环遍历字符数组，将每个字符加密处理
+    for (int i = 0; i < a.length; i++) {
+      a[i] = (char)(a[i] ^ 'q');
+    }
+ 
+    // 利用字符输出流FileWriter将加密后的字符数组写入文件中
+    /********** Begin **********/
+    FileWriter fileWriter = new FileWriter(file);
+    fileWriter.write(a, 0, a.length);
+    fileWriter.flush();
+    fileWriter.close();
+    /********** End **********/
+ 
+    // 利用字符输入流FileReader读取文件，将密文输出
+    /********** Begin **********/
+    FileReader fileReader = new FileReader(file);
+    char[] buffer = new char[10];
+    int x; //保存读取的数据量
+    System.out.println("密文：");
+    while ((x = fileReader.read(buffer)) != -1) {
+      System.out.print(new String(buffer));
+    }
+    fileReader.close();
+    /********** End **********/
+ 
+    // 利用字符输入流FileReader读取文件，将密文转换为明文输出
+    /********** Begin **********/
+    FileReader in = new FileReader(file);
+    System.out.println("\n明文：");
+    while ((x = in.read(buffer)) != -1) {
+      for (int i = 0; i < x; i++) {
+        buffer[i] = (char)(buffer[i] ^ 'q');
+      }
+      System.out.print(new String(buffer));
+    }
+    in.close();
+    /********** End **********/
+  }
+}
+字符输入/输出流实现发送电报
+fsys,1=
+/**
+ * 任务：求两个复数相加后的结果。
+ */
+ 
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+ 
+/********** Begin **********/
+ 
+// 定义一个圆类，类名为 Complex
+public class Complex {
+// 定义四个变量：real1、image1、real2、image2 分别表示第一个虚数的实部与虚部和第二个虚数的实部与虚部，类型为int
+int real1,image1,real2,image2;
+// 定义一个成员方法，方法名为add，不带参数，实现两个复数相加，将实部结果与虚部结果用+拼接后返回，返回类型为String，
+    public String add() {
+        int real = real1 + real2;
+        int image = image1 + image2;
+        if (real != 0 && image != 0) {
+            return real + "+" + image + "i";
+        } else if (real != 0 && image == 0) {
+            return real + "";
+        } else if (real == 0 && image != 0) {
+            return image + "i";
+        } else if (real == 0 && image == 0) {
+            return "0";
+        }
+ 
+// 相加后结果如果有虚部，将计算结果的虚部后加上i
+// 如果没有虚部，只返回实部即可。
+// 如果没有实部，只返回虚部，将计算结果的虚部后加上i
+// 如果都没有值，返回零。
+        return " ";
+    }
+    }练习-Java类和对象之类的声明之复数运算
+fsz,1=
+import java.util.Scanner;
+
+public class Fraction{
+    double mole;    //分子
+    double deno;    //分母
+    void value(double deno,double mole){
+        if(mole == 0){
+            System.out.print("分母不能为0");
+        }else{
+            double s = deno / mole;
+            System.out.print("该分数的值为" + String.format("%.2f",s));
+        }
+    }
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        double deno = scanner.nextDouble();
+        double mole = scanner.nextDouble();
+        Fraction fraction = new Fraction();
+        fraction.value(deno,mole);
+    }
+}
+
+练习- Java类和对象之构造方法与对象创建之计算数学中的分数值
+fwxz,1=
+/**
+ * 任务：实现图书类，该类包含了图书的基本属性和信息。
+ * 类名为：Book
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+public class Book {
+    // 定义四个私有变量
+    // 图书名称（bookName String）
+    // 图书单价（price double）
+    // 图书库存（total int）
+    // 图书id（bookId int）
+    private String bookName;
+    private double price;
+    private int total;
+    private int bookId;
+    // 获取图书名称
+    public String getBookName() {
+        return bookName;
+    }
+    // 设置图书名称
+    public void setBookName(String bookName) {
+        this.bookName=bookName;
+    }
+    // 获取图书单价
+    public double getPrice() {
+        return price;
+    }
+    // 设置图书单价
+    public void setPrice(double price) {
+        this.price=price;
+    }
+    // 获取图书库存
+    public int getTotal() {
+        return total;
+    }
+    // 设置图书库存
+    public void setTotal(int total) {
+        this.total=total;
+    }
+    // 获取图书id
+    public int getBookId() {
+        return bookId;
+    }
+    // 设置图书id
+    public void setBookId(int bookId) {
+        this.bookId=bookId;
+    }
+    
+}
+/********** End **********/学习-Java类和对象之访问限制
+fzjcjk,1=
+package case7;
+public class interfaceTest {
+ public static void main(String[] args) {
+ // 实例化一个 Student 的对象 s，并调用 talk()方法，打印信息
+ Student s = new Student();
+ s.talk();
+ }
+}
+// 声明一个 Person 接口，并在里面声明三个常量：name、age 和 occupation，并分别赋值，声明一抽象方法 talk()
+interface Person {
+ String name = "张三";
+ int age = 18;
+ String occupation = "学生";
+ void talk();
+}
+// Student 类实现了 Person 接口，复写 talk()方法返回姓名、年龄和职业信息
+class Student implements Person {
+ @Override
+ public void talk() {
+ System.out.println("学生——>姓名：" + Person.name + "，年龄：" + Person.age + "，职业：" + Person.occupation + "！");
+ }
+}
+封装、继承和接口 
+fzjg,1=
+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 1:System.out.println("1月是冬天");break;
+			case 2:System.out.println("2月是冬天");break;
+			case 12:System.out.println("12月是冬天");break;
+			case 3:System.out.println("3月是春天");break;
+			case 4:System.out.println("4月是春天");break;
+			case 5:System.out.println("5月是春天");break;
+			case 6:System.out.println("6月是夏天");break;
+			case 7:System.out.println("7月是夏天");break;
+			case 8:System.out.println("8月是夏天");break;
+			case 9:System.out.println("9月是秋天");break;
+			case 10:System.out.println("10月是秋天");break;
+			case 11:System.out.println("11月是秋天");break;
+		}		
+		/*****end*****/		
+	}
+}
+Java分支结构
+fzswitch,1=
+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 3:
+case 4:
+case 5:
+ System.out.println(input+"月是春天");
+ break;
+case 6:
+case 7:
+case 8:
+ System.out.println(input+"月是夏天");
+ break;
+case 9:
+case 10:
+case 11:
+ System.out.println(input+"月是秋天");
+ break;
+case 1:
+case 2:
+case 12:
+ System.out.println(input+"月是冬天");
+ break;
+default:
+ System.out.println("输入有误");
+ break;
+}
+/*****end*****/
+}
+}Java 分支结构之 Switch
+fzwj,1=
+package step4;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+public class Task {
+
+ public void task() throws IOException{
+ // 复制文本文件
+ FileReader fr = new FileReader("src/step4/input/input.txt"); //定义 FileReader 读取文件
+ int len = 0; //每次读取的字符数量
+ char[] cbuf = new char[1024]; //每次读取数据的缓冲区
+ FileWriter fw = new FileWriter("src/step4/output/output.txt"); //定义 FileWriter 写文件
+ while((len = fr.read(cbuf)) != -1){
+ fw.write(cbuf,0,len);
+ }
+ fw.close(); //释放资源 刷新缓冲区
+ fr.close();
+
+ // 复制图片文件
+ FileInputStream fs = new FileInputStream("src/step4/input/input.jpg"); //定义文件输入流读取文件信息
+ FileOutputStream fos = new FileOutputStream("src/step4/output/output.jpg");//定义文件输出流写文件
+ byte[] bys = new byte[1024]; //数据缓冲区
+ while( (len = fs.read(bys)) != -1){
+ fos.write(bys, 0, len);
+ }
+ //释放资源 刷新缓冲区
+ fs.close();
+ fos.close();
+复制文件
+gjz,1=
+/**
+ * 任务：编写一个商品结算的小程序
+ * 类名为：Shop
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+ 
+public class Shop {
+    //定义该商品的两个属性：价格（double）和数量（int）
+    double price;
+    int total;
+    // 将形参的值赋值给成员变量
+    public Shop(double price, int total) {
+        this.price = price;
+        this.total = total;
+    }
+    // 该方法实现计算价钱的功能，将计算结果返回，价钱 = 价格 * 数量
+    public double sum() {
+        double sum = price * total;
+        return sum;
+    }
+}
+/********** End **********/学习-Java类和对象之this关键字
+gshsc,1=
+import java.util.Scanner;
+public class StrTest {
+    public static void main(String[] args) {
+            // 请在Begin-End间编写代码
+            /********** Begin **********/
+ 
+            // 第一步：接收加速度
+            Scanner input = new Scanner(System.in);
+            int a = input.nextInt();
+            // 第二步：接收时间
+            int t = input.nextInt();
+            // 第三步：使用格式化字符串的方式输出距离
+            int v0 = 8;
+            double x = v0 * t + 0.5 * a * t *t;
+            System.out.println("当时间为" + t + "，加速度为" + a + "时，距离为" + String.format("%f",x));
+            /********** End **********/
+ 
+    }
+}学习-Java字符串之String类格式化字符串之多类型数据的格式化输出
+hkjs,1=
+/*
+任务：编写一个程序，由用户输入住房贷款和贷款年限，程序输出不同利率下的月还款额和总还款额，利率从 5%～8%，增长间隔为 1/8。
+例如，如果输入贷款额 10000 元人民币，贷款期限 5 年，程序应输出如下内容：
+贷款金额: 10000
+贷款年限: 5
+利率    月还款额    总还款额
+5.000%    188.71    11322.74
+5.125%    189.28    11357.13
+……
+8.000%    202.76    12165.83
+利率请保留3位小数，月还款额和总还款额请保留2位小数。
+利率和月还款额以及总还款额之间保留4个空格。
+思路：获取住房贷款以及贷款年限，计算不同利率下的月还款额以及总还款额。
+*/
+// 请在Begin-End间编写完整代码，类名请使用LoanTest
+/********** Begin **********/
+// 导入 Scanner 类
+import java.util.Scanner;
+// 定义公开类  LoanTest
+public class LoanTest {
+    // 定义主方法 main，在该方法中完成本关任务
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        // 接收贷款额
+        int loan=input.nextInt();
+        // 接收贷款年限
+        int year=input.nextInt();
+        // 第一步：定义变量月还款额，并赋初值0
+        double monthlyPay=0;
+        // 第二步：定义变量总还款额，并赋初值0
+        double totalPay=0;
+        // 第三步：输出贷款额
+        System.out.println("贷款额："+loan);
+        // 第四步：输出贷款年限
+        System.out.println("贷款年限："+year);
+        // 第五步：输出利率、月还款率以及总还款率
+        System.out.println("利率"+"    "+"月还款额"+"    "+"总还款额");
+        for (double i=5;i<=8;i+=0.125)
+        {
+            // 月利率
+            double a=i/1200;
+            // 月还款额
+            monthlyPay=loan*a*Math.pow(1+a,12*year)/(Math.pow(1+a,12*year)-1);
+            // 总还款额
+            totalPay=12*monthlyPay*year;
+            // 格式化输出
+            System.out.printf("%.3f%%\t%.2f\t%.2f\n",i,monthlyPay,totalPay);
+        }
+    }
+}
+/********** End **********/      练习-Java循环综合练习一之住房贷款还款计算
+hmc,1=
+import java.util.Scanner;
+public class StrTest {
+    public static void main(String[] args) {
+            // 请在Begin-End间编写代码
+            /********** Begin **********/
+            // 第一步：接收输入的两份花名册
+            Scanner input = new Scanner(System.in);
+            String str1 = input.nextLine();
+            String str2 = input.nextLine();
+            // 第二步：输出第一份花名册的长度（字符串长度）
+            System.out.println(str1.length());
+            // 第三步：输出第二份花名册的长度（字符串长度）
+            System.out.println(str2.length());
+            // 第四步：判断两个花名册是否相同，若相同，请输出相同，若不同，请输出不相同
+            boolean b = str1.equals(str2);
+           if (b){
+            System.out.println("相同");
+           }else {
+            System.out.println("不相同");
+           }
+            /********** End **********/
+    }
+}练习-Java字符串之String类常用方法之花名册
+jcx,1=
+/**
+ * 任务：定义一个矩形 Rectangle 类，继承 Shape 类，
+ * 在这个类中分别定义一个名为 area 的方法，实现计算该形状面积的功能。
+ * 类名为：Rectangle
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 定义一个Rectangle的公开类，并继承Shape类
+public class Rectangle extends Shape{
+    // 定义一个area方法，实现计算矩形面积的功能。
+     public double area(){
+        double s = getWidth() * getHeight();
+        return s;
+    }
+ 
+}
+/********** End **********/练习-Java继承和多态之子类继承性
+jgjs,1=
+/**
+ * 任务：计算商品打折后的价格
+ */
+class Total {
+    double totalMoney = 50.00;
+    public double getTotalMoney(){
+        return totalMoney;
+    }
+}
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 定义一个Seal的公开类，并继承Total类
+public class Seal extends Total{
+    // 定义两个变量，分别代表折扣和总价格，类型为double
+    double total;
+    double money;
+    // 定义一个有参构造方法，带两个参数，依次为折扣和总价格
+    public Seal(double total,double money){
+        this.total = total;
+        this.money = money;
+    }
+    // 定义一个方法名为sealX的方法，返回类型为double，计算打折后的商品价格并返回
+    double sealX(){
+        return total*money;
+    }
+}
+ 
+/********** End **********/学习-Java继承和多态之成员变量隐藏之优惠促销价格计算
+jkdsy,1=
+package step3;
+
+// 自行设计接口和实现类
+/********** Begin **********/
+// 定义接口
+interface Display {
+    public void display();
+}
+
+// 通知类
+class Inform implements Display {
+    // 实现 display() 方法
+    public void display() {
+        System.out.println("通知内容");
+    }
+}
+
+// 汽车类
+class Car implements Display {
+    // 实现 display() 方法
+    public void display() {
+        System.out.println("汽车油量");
+    }
+}
+
+// 广告类
+class Adervise implements Display {
+    // 实现 display() 方法
+    public void display() {
+        System.out.println("广告消息");
+    }
+}
+/********** End **********/	                                                     
+
+public class Lab3_3 {
+	public static void main(String[] args) {
+		Display[] arr = { new Inform(), new Car(), new Adervise() };
+		for (Display d : arr) {
+			d.display();
+		}
+	}
+}
+接口的使用
+jljs,1=
+/**
+ * 任务：已知两个点 A、B 以及坐标分别为(2,3) 、(8,-5) ，求 A 和 B 两点之间的距离。
+ * 类名为：Distance
+ */
+ 
+public class Distance {
+ 
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+ 
+/********** Begin **********/
+ 
+    /**
+     * 定义一个静态方法，该方法计算坐标两点的距离，携带四个参数，分别为x1、y1、x2、y2的值
+     * 将距离结果返回，返回类型为double
+     */
+static double point(double x1,double y1,double x2,double y2)
+{
+    double d;
+    d=Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
+    return d;
+}
+public static void main(String[]args)
+{
+    System.out.printf("A、B两点的距离为%.6f",Distance.point(2,3,8,-5)) ;
+}
+ 
+    // 定义主方法
+ 
+ 
+    // 通过类名.方法名的方式调用计算两点间距离的方法，分别将A、B的x1、y1、x2、y2的值传入该方法中
+ 
+    // 不换行输出，输出格式: A、B两点的距离为xx
+ 
+ 
+/********** End **********/
+ 
+}学习-Java类和对象之对象引用之坐标系中两点距离计算
+jospd,1=
+ package step4;
+ 
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.util.Scanner;
+ 
+public class ClientPlus {
+ 
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        ServerPlus server = new ServerPlus();
+        server.start();
+        try {
+            //创建客户端Socket(s)，指定服务器端IP地址和端口号
+            /********** Begin **********/
+            Socket s = new Socket("127.0.0.1", 8080);
+            /**********  end  **********/
+            DataOutputStream dos = new DataOutputStream(s.getOutputStream());
+            DataInputStream dis = new DataInputStream(s.getInputStream());
+            //客户端通过循环依次接收服务器返回的结果，并输入新的整数传递给服务器
+            /********** Begin **********/
+            while (true) {
+                System.out.println(dis.readUTF());
+                String num = sc.next();
+                dos.writeUTF(num);
+            }
+            /**********  end  **********/
+        } catch (EOFException e) {
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}
+TCP通信实现奇偶数判断
+jsxq,1=
+import java.util.Scanner;
+
+/**
+ * 任务：根据输入的年月日，确定这一天是星期几。
+ */
+public class ApplicationTest {
+
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String args[]) {
+        Scanner scanner = new Scanner(System.in);
+
+        // 声明 int 类型的变量 y 用来获取控制台输入的年
+        int y = scanner.nextInt();
+        // 声明 int 类型的变量 m 用来获取控制台输入的月
+        int m = scanner.nextInt();
+        // 声明 int 类型的变量 d 用来获取控制台输入的日
+        int d = scanner.nextInt();
+        /********** Begin **********/
+        // 第一步：判断变量 m 的值是否是 1 或者 2。如果是，则变量 m 在原来的基础上加12，同时变量 y 在原来的基础上减1
+        if (m==1||m==2){
+            m = m+12;
+            y = y-1;
+        }
+        int iweek =(d+2*m+3*(m + 1)/5+y+y/4-y/100+y/400)%7;
+        // 第二步：使用基姆拉尔森日期公式，计算星期几
+      if (iweek==0){
+          System.out.print("星期一");
+      }else if (iweek==1){
+          System.out.print("星期二");
+      }else if (iweek==2){
+          System.out.print("星期三");
+      }else if (iweek==3){
+          System.out.print("星期四");
+      }else if (iweek==4){
+          System.out.print("星期五");
+      }else if (iweek==5){
+          System.out.print("星期六");
+      }else if (iweek==6){
+          System.out.print("星期日");
+      }else{
+          System.out.print("无效");
+      }
+
+        // 第三步：使用多路分支判断星期几。如果是星期一，则在控制台输出"星期一"；如果是星期二，则在控制台输出"星期二"....以此类推，如果是星期日，就是在控制台输出"星期日"
+       
+        /********** End **********/
+    }
+}
+
+
+练习-Java分支结构综合练习三之根据年月日计算星期
+jzc,1=
+// 请在Begin-End间编写完整代码，类名请使用Transpose
+        /********** Begin **********/
+public class Transpose{
+	public static void main(String[] args){
+		int[][] arr1={{5,6,7},
+			{15,65,43},
+                        {32,43,22},
+			{11,88,6},
+                        {4,98,66}};
+		int[][] arr2={{94,65,31,87,21},
+			{48,2,0,71,98}, 
+			{38,29,66,88,100},};
+         int[][] arr3 = new int[arr1.length][arr2[0].length];
+        for (int i = 0; i < arr1.length; i++) {
+            for (int j = 0; j < arr2[0].length; j++) {
+                for (int k = 0; k < arr2.length; k++) {
+                    arr3[i][j] += arr1[i][k] * arr2[k][j];
+                }
+            }
+        }
+        print(arr3);
+    }
+    private static void print(int[][] arr) {
+        for (int i = 0; i < arr.length; i++) {
+            for (int j = 0; j < arr[0].length; j++) {
+                System.out.print(arr[i][j] + " ");
+            }
+            System.out.println();
+        }
+    }
+}
+        /********** End **********/练习-Java数组之二维数值数组之矩阵乘
+jzj,1=
+
+public class Transpose {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 定义二维数组并初始化
+        int [][] a = {{5,6,7},{15,65,43},{32,43,22},{11,88,6},{4,98,66}};
+        int [][] b = {{94,65,31},{0,71,98},{66,88,100},{32,7,1},{16,2,34}};
+        int [][] c = {{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};
+        // 打印求和后的新数组
+        for(int i=0;i<=4;i++){
+        for(int j=0;j<=2;j++){
+            c[i][j] = a[i][j] + b[i][j];
+            System.out.print(c[i][j] +" ");
+        }
+        System.out.println();
+    }
+}
+}
+
+ 练习-Java数组之二维数值数组之矩阵加
+jzzz,1=
+package step2;
+import java.util.Scanner;
+
+public class SwapMatrix {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int[][] matrix = new int[3][3];
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                matrix[i][j] = scanner.nextInt();
+            }
+        }
+        /********** Begin **********/
+        System.out.println("原始数组为：");
+        // 打印原始数组
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                System.out.print(matrix[i][j] + " ");
+            }
+            System.out.println();
+        }
+        
+        // 创建新的矩阵用于存放行列互调后的数组
+        int[][] swappedMatrix = new int[3][3];
+        // 行列互调
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                swappedMatrix[j][i] = matrix[i][j];
+            }
+        }
+
+        System.out.println("行列互调后数组为：");
+        // 打印行列互调后的数组
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                System.out.print(swappedMatrix[i][j] + " ");
+            }
+            System.out.println();
+        }
+        /********** End **********/
+        scanner.close();
+    }
+
+}
+矩阵转置
+jzzz,1=
+public class Transpose {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 定义二维数组并初始化
+        int [][] a = {
+            {5,6,7},
+            {15,65,43},
+            {32,43,22},
+            {11,88,6},
+            {4,98,66}
+        };
+        // 定义转置后的新数组
+        int[][] b = new int [a.length][a.length];
+        // 转置数组
+       for (int i = 0;i<3;i++){
+           for (int j = 0;j<5;j++){
+               b[i][j] = a [j][i];
+               System.out.print(b[i][j]+" ");
+           }
+           System.out.println("");
+       }
+        // 打印新数组
+       
+        /********** End **********/
+        }
+}练习-Java数组之二维数值数组之矩阵转置
+kbcs,1=
+/**
+ * 定义输出考试学生的人数及姓名的方法，方法名为 print，传参的类型为String，无返回值。
+ */
+public class Student {
+ 
+	// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+	/********** Begin **********/
+public static void main(String[]args){
+    Student student=new Student();
+    student.print("张翔","李晨","王明");
+    student.print("洋洋","马华");
+}
+public static void print(String...names){
+    int count=names.length;
+    System.out.println("本次参加考试的有"+count+"人，名单如下：");
+    for(int i=0;i<names.length;i++){
+        System.out.println(names[i]);
+    }
+}
+ 
+	/********** End **********/
+}学习-Java类和对象之可变参数
+key,1=
+import java.util.Scanner;
+public class FindTest {
+    public static void main(String[] args) {
+        // 请在 Begin-End 间编写代码
+        /********** Begin **********/
+        // 定义变量
+        int n=0;
+        int min=0;
+        int mid;
+        int count=0;
+        // 接收给定数据
+        Scanner scanner = new Scanner(System.in);
+        int i = scanner.nextInt();     // 数组长度
+        int key = scanner.nextInt();     // 需要查找的元素
+        // 定义数组
+        int[] arr = new int[i];
+        // 给数组赋值
+        while (!scanner.hasNext("#")){
+            int x = scanner.nextInt();
+            arr[n]=x;
+            n++;
+        }
+        // 查找给定元素索引，并输出查找次数
+        int max=arr.length-1;
+        mid=(max+min)/2;
+        while(true) {
+            count++;
+            if(key<arr[mid]) {        // 如果目标元素小于中点元素
+                max = mid-1;            // max向mid前移动
+            }else if(key>arr[mid]) { // 如果目标元素大于中点元素
+                min = mid+1;            // min向mid后移动
+            }else {
+                System.out.print("索引值："+mid+"。查找次数："+count+"。");            // 找到目标元素
+                break;
+            }
+            if(max<min) {      // 没有找到的情况
+                System.out.print("没有找到");
+                break;
+            }
+            mid=(max+min)/2;     // 重新计算中间索引值
+        }
+        /********** End **********/
+    }
+    }学习-Java数组之一维数值数组之查找Key值
+ksmm,1=
+import java.util.Arrays;
+import java.util.Scanner;
+public class PassWord {
+    public static void main(String[] args) {
+ /********** Begin **********/
+        // 接收给定字符串
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();     // 获取偏移量
+        String next = scanner.next();     // 获取密文
+        // 将密文添加进字符数组
+        char[] arr = new char[next.length()];        // 存储密文的数组
+        for(int i=0;i<next.length();i++){
+            char c = next.charAt(i);
+            arr[i]=c;
+        }
+        // 破解密文
+        for(int i=0;i<arr.length;i++){
+            if((char)(arr[i] + n)>90){     // 90是Z的ASCII码值，64为A的ASCII码值，这一步是考虑边界效应
+                arr[i] = (char)(arr[i] + n-90+64);
+            }else {
+            arr[i] = (char)(arr[i] + n);}
+        }
+        // 输出明文
+        System.out.print(arr);
+        /********** End **********/
+    }
+}练习-Java数组之一维字符数组之凯撒密码
+ldjc,1=
+package step1;
+
+import java.util.Scanner;
+
+class Person {
+    /********** Begin **********/
+    // 自行设计类的实现
+    //姓名
+    private String name;
+    //性别
+    private String sex;
+    //年龄
+    private int age;
+
+    //构造方法
+    public Person(String name, String sex, int age){
+        this.name = name;
+        this.sex = sex;
+        this.age = age;
+    }
+
+    //重写toString()方法
+    public String toString(){
+        return name + "," + sex + "," + age;
+    }
+	/********** End **********/	                                                     
+}
+
+class Student extends Person {
+    /********** Begin **********/
+    // 自行设计类的实现
+    //学号
+    private String no;
+    //入学时间
+    private String enter;
+    //专业
+    private String major;
+
+    //构造方法
+    public Student(String name, String sex, int age, String no, String enter, String major){
+        super(name, sex, age);
+        this.no = no;
+        this.enter = enter;
+        this.major = major;
+    }
+
+    //重写toString()方法
+    public String toString(){
+        return super.toString() + "," + no + "," + enter + "," + major;
+    }
+	/********** End **********/	                                                     
+}
+
+class Teacher extends Person {
+    /********** Begin **********/
+    // 自行设计类的实现
+    //职称
+    private String pro;
+    //部门
+    private String department;
+
+    //构造方法
+    public Teacher(String name, String sex, int age, String pro, String department){
+        super(name, sex, age);
+        this.pro = pro;
+        this.department = department;
+    }
+
+    //重写toString()方法
+    public String toString(){
+        return super.toString() + "," + pro + "," + department;
+    }
+	/********** End **********/		                                                     
+}
+
+public class Lab3_1 {
+	public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+		Student student = new Student(sc.next(), sc.next(), sc.nextInt(), sc.next(), sc.next(), sc.next());
+		Teacher teacher = new Teacher(sc.next(), sc.next(), sc.nextInt(), sc.next(), sc.next());
+		System.out.println("学生基本信息为:" + student);
+		System.out.println("教师的信息为:" + teacher);
+		sc.close();	                                                     
+	}
+}	
+类的继承
+lszd,1=
+
+/**
+ * 任务：获取键盘两次输入的值，输出两者中的最大数。
+ * 类名为：CompareMax
+ */
+
+import java.util.Scanner;
+
+public class CompareMax {
+    public static void main(String[] args) {
+    
+        Scanner reader = new Scanner(System.in);
+        
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+        // 第一步：获取键盘第一次输入的值
+        double one = reader.nextDouble();
+        // 第二步：获取键盘第二次输入的值
+        double two = reader.nextDouble();
+        // 第三步：比较两数大小
+        double max =0;
+        if (one>two){
+            max = one;
+        }else{
+            max = two;
+        }
+        // 第四步：不换行输出最大的那个值
+        System.out.print(max);
+        /********** End **********/
+
+
+    }
+}
+
+Java顺序结构之数学函数之求两数最大者
+lxdzh,1=
+/**
+ * 判断梨类、苹果类和水果类的关系，并通过对象类型转换调用彼此的属性和方法。
+ */
+ 
+class Fruits {
+    public String name; // 定义水果名称
+    Fruits (String name) {
+        this.name = name;
+    }
+}
+ 
+// 苹果类继承水果类
+class Apple extends Fruits {
+   
+    public String acolor; // 苹果颜色
+ 
+    public Apple(String name, String acolor) {
+        super(name);
+        this.acolor = acolor;
+    }
+}
+// 梨类继承水果类
+class Pear extends Fruits {
+    public String pcolor; // 梨的颜色
+ 
+    public Pear(String name, String pcolor) {
+        super(name);
+        this.pcolor = pcolor;
+    }
+}
+public class Tests {
+    public static void main(String args[]) {
+        Fruits f = new Fruits("水果");
+        Apple a = new Apple("苹果","red");
+        Pear p = new Pear("；梨","yellow");
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********* Begin *********/
+        // 依次判断 f、a、p是否为 Fruits的子类对象
+if(f  instanceof Fruits)
+System.out.println("true");
+else
+System.out.println("false");
+if(a  instanceof Fruits)
+System.out.println("true");
+else
+System.out.println("false");
+if(p  instanceof Fruits)
+System.out.println("true");
+else
+System.out.println("false");
+        // 把梨类对象赋值给水果类，其中name值为bigPear,颜色为green//向上型
+Fruits a1=new Pear("bigPear","green");//这里带参数；字符串类型要带双引号；
+        // 输出当前水果类引用的名称
+System.out.println(a1.name);
+        // 依次判断当前水果类引用是否为水果类和梨类的子类
+if(a1 instanceof Fruits)
+System.out.println("true");
+else
+System.out.println("false");
+if(a1 instanceof Pear)
+System.out.println("true");
+else
+System.out.println("false");
+        // 将当前水果类引用强转为梨类//向下型
+Pear a2=(Pear) a1;
+        // 输出当前梨类的颜色
+System.out.println(a2.pcolor);
+        /********** End **********/
+    }
+}练习-Java继承和多态之对象类型的转换
+lxpd,1=
+import java.util.Scanner;
+
+/**
+ * 任务：输入单个字符，判断该字符的类型（判断输入字符是大写字母、小写字母、数字还是其他字符）。
+ */
+public class ApplicationTest {
+
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码。
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明 char 类型的变量 a 用来获取控制台输入
+        char a = scanner.next().charAt(0);
+
+        /********** Begin **********/
+        // 第一步：将 char 类型的变量 a 强制转换成 int 类型
+        int b = (int)a;
+        // 第二步：判断强制转换成 int 类型的变量是否大于等于 65，同时小于等于 90 ，如果满足条件，则在控制台输出"该字符是大写字母"
+        if (b>=60&&b<=90){
+            System.out.print("该字符是大写字母");
+        }else if (b >= 97 && b<=122 ){
+            // 第三步：判断强制转换成 int 类型的变量是否大于等于 97，同时小于等于 122 ，如果满足条件，则在控制台输出"该字符是小写字母"
+        System.out.print("该字符是小写字母");
+        }else if (b >=48&&b<=57){
+            // 第四步：判断强制转换成 int 类型的变量是否大于等于 48，同时小于等于 57 ，如果满足条件，则在控制台输出"该字符是数字"
+        System.out.print("该字符是数字");    
+        }else{
+            System.out.print("该字符是其他字符");
+        }
+        // 第五步：如果以上条件都不满足，则在控制台输出"该字符是其他字符"
+
+        
+        /********** End **********/
+
+    }
+}
+练习-Java多路分支之字符类型判断
+lxzh,1=
+/**
+ * 任务：变量 a 是一个 double 型的变量，请将其强转为 int 型，
+ * 变量 b 是一个 short 型的变量，请将其转换为 double 型。
+ * 输出格式：先换行输出变量 a 转换后的结果，再不换行输出 b 转换后的结果。
+ * 类名为：Transform
+ */
+
+import java.util.Scanner;
+
+public class Transform {
+    public static void main(String[] args) {
+
+        //创建一个Scanner的实例对象，命名为reader
+        Scanner reader = new Scanner(System.in);
+        // double型变量a
+        double a = reader.nextDouble();
+        // short型变量b
+        short b = reader.nextShort();
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+
+        // 第一步：将double型变量a强转为int型
+        
+        // 第二步：将short型变量b转换为double型
+        
+        // 第三步：换行输出变量a转换后的结果
+        System.out.println((int)a);
+        // 第四步：不换行输出变量b转换后的结果
+        System.out.print((double)b);
+                /********** End **********/
+
+
+    }
+}
+
+学习-Java顺序结构之基本数据类型转换
+lxzh,1=
+/**
+ * 使用对象类型的转换，根据编程提示，完成猫类和动物类的转换，以及彼此方法和属性的调用
+ */
+ // 定义动物类
+class Animal{
+	// 定义动物类的属性
+    public String name = "动物";
+    public static String staticName = "可爱的动物";
+    // 定义动物类的行为方法
+    public void eat() {
+        System.out.println("动物吃饭");
+    }
+    public static void staticEat() {
+        System.out.println("可爱的动物正在在吃饭");
+    }
+}
+// 定义猫类，该类继承动物类
+public class Cat extends Animal{
+	// 定义猫类的属性
+    public String name = "猫";
+    public String str = "可爱的小猫";
+    public static String staticName = "可爱的动物";
+    // 定义猫类的行为方法
+    public void eat() {
+        System.out.println("猫吃饭");
+    }
+    public static void staticEat() {
+        System.out.println("喵星人在吃饭");
+    }
+    public void eatMethod() {
+        System.out.println("猫喜欢吃鱼");
+    }
+ 
+    public static void main(String[] args) {
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********* Begin *********/
+        // 向上转型，把猫类对象赋值给动物类
+        Animal animal=new Cat();
+        // 向下转型，将动物类引用转换为猫类对象
+        Cat  cat=(Cat) animal;
+        // 输出Animal类的name变量
+        System.out.println(animal.name);
+        // 输出Animal类的staticName变量
+        System.out.println(staticName);
+        // 输出Cat类的eat()方法
+        animal.eat();
+        // 输出Animal类的staticEat()方法
+        animal.staticEat();
+        // 调用Cat类的str变量
+        System.out.println(cat.str);
+        // 调用Cat类的eatMethod()方法
+        cat.eatMethod();
+        /********** End **********/
+    }
+}
+ 
+ 学习-Java继承和多态之对象类型的转换
+mb,1=
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+ 
+// 声明一个名为 com.model 的包
+package com.model;
+ 
+// 定义一个 Movie 的公开类
+public class Movie{
+    private String name;
+    private String lei;
+    private String time;
+    private String arer;
+public String getName()
+{
+    return name ;
+}
+public void setName(String name)
+{
+    this.name = name ;
+}
+ 
+    // 该类具有电影名称、电影类别、电影时长、地区等属性（都是字符串类型、私有）
+public String getLei()
+{
+    return lei ;
+}
+public void setLei(String lei)
+{
+    this.lei = lei;
+}
+public String getTime()
+{
+    return time;
+}
+public void setTime(String time)
+{
+    this.time = time ;
+}
+public String getArer()
+{
+    return arer;
+}
+public void setArer(String arer)
+{
+    this.arer = arer;
+}
+ 
+    
+ 
+ 
+    // 定义获取和设置电影属性的方法
+ 
+    
+    
+    // 定义获取电影信息的方法，无返回值
+public void say()
+{
+    System.out.println("电影名称："+name+"，电影类别："+lei+"，电影时长："+time+"，地区："+arer+"。");
+}
+}
+    
+    
+/********** End **********/练习-Java类和对象之包的定义
+mdpd,1=
+/*
+任务：求出对战人信息。
+输出样式：a的对手x
+*/
+ 
+public class TeamMate {
+    public static void main(String[] args) {
+       
+        
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 第一步：使用循环求出与c的对战的人
+        
+        // 第二步：使用循环求出与a的对战的人
+        
+        // 第三步：使用循环求出与b对战的人
+        
+        // 第三步：打印对战信息
+        for(char a = 'x';a <= 'z';a++) {
+            for(char b = 'x';b <= 'z';b++) {
+                if(a != b){
+                    for(char c = 'x';c <= 'z';c++){
+                    if( c != b && a != c){
+                            if(c != 'x' && c != 'z' && a != 'x'){
+                                 System.out.println("a的对手"+a);
+                                 System.out.println("b的对手"+b);
+                                 System.out.println("c的对手"+c);
+                                 break ;       
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        /********** End **********/
+ 
+    }
+}练习-Java循环之嵌套循环之比赛名单判断
+mjzc,1=
+/**
+ * 任务：已知圆环的大圆半径 R 和 小圆半径 r 的长度分别为 32.0 和 10.0，求该圆环的面积和周长。
+ * 类名为：RingArea
+ */
+public class RingArea {
+    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+    /********** Begin **********/
+ 
+    // 定义三个量，两个变量分别为大圆半径和小圆半径，常量表示π，它的值可以调用 Math.PI获取，并将其设为静态常量。
+    static double PI = Math.PI;
+    double R;
+    double r;
+    // 定义一个无参构造方法，将小圆半径设为 10.0，大圆半径设为32.0
+    public RingArea() {
+        this.R = 32.0;
+        this.r = 10.0;
+    }
+    /**
+     * 定义一个静态方法，该方法实现计算圆环的周长，携带两个参数，分别为传来的小圆半径和大圆半径的值。
+     * 将圆环周长的计算结果返回，返回类型为double
+     */
+    public static double ring(double R,double r){
+        return 2 * PI * (R + r);
+    }
+    /**
+     * 定义一个静态方法，该方法实现计算圆环的面积，携带两个参数，分别为传来的小圆半径和大圆半径的值。
+     * 将圆环面积的计算结果返回，返回类型为double
+     */
+    public static double area(double R,double r){
+        return PI * (R * R - r * r);
+    }
+    // 定义主方法
+public static void main(String[] args) {
+    // 在主方法中通过定义的无参构造方法定义一个对象
+        RingArea ringArea = new RingArea();
+    // 通过类名.方法名的方式调用计算圆环周长的方法，获取圆环周长，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
+        double c = RingArea.ring(ringArea.R,ringArea.r);
+    // 通过类名.方法名的方式调用计算圆环面积的方法，获取圆环面积，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
+        double s = RingArea.area(ringArea.R,ringArea.r);
+    // 不换行四舍五入保留两位小数后格式化输出求出的值，输出格式：该圆环的周长为xx，面积为xx
+        System.out.print("该圆环的周长为" + String.format("%.2f",c));
+        System.out.print("，面积为" + String.format("%.2f",s));
+        }
+    /********** End **********/
+}学习-Java类和对象之static关键字之求圆环面积和周长
+mnsj,1=
+/**
+ * 任务：实现手机的基本功能。
+ * 类名为：Phone
+ */
+
+public class Phone {
+
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+
+/********** Begin **********/
+
+    // 定义五个变量，分别表示品牌、型号、价格、操作系统和内存
+    String brand;
+    String type;
+    double price;
+    String os;
+    int memory;
+
+    // 无参构造
+public void Phone(){		
+        	
+    }
+
+    // 有参构造
+        public void Phone(String brand,String type,double price,String os,int memory){	
+        this.brand = brand;
+        this.type = type;
+        this.price = price;
+        this.os = os;
+        this.memory = memory;
+    }
+
+    /**
+     * 定义一个方法，该方法实现查询手机信息的方法，无返回值
+     * 输出格式：品牌：xx
+     *           型号：xx
+     *           操作系统：xx
+     *           价格：xx
+     *           内存：xx
+     * 中间用换行符隔开
+     */
+public void about(){
+        System.out.print("品牌：" + brand+"\n型号：" + type + "\n操作系统：" + os + "\n价格：" + price + "\n内存：" + memory + "\n正在给妈妈打电话\n正在播放浮夸" );
+    }
+
+
+    /**
+     * 定义一个方法，该方法实现打电话的功能，无返回值，
+     * 携带一个int型参数，其中1,2,3分别表示爸爸、妈妈、姐姐的号，
+     * 输出格式  如果参数为1，换行输出：正在给爸爸打电话
+     * 如果出现其它情况，换行输出：你所拨打的电话为空号
+     */
+public static void main(String[] args){
+        Phone p1 = new Phone();				//在这里赋值老是报错，所以我用p1对象一个个赋值
+        p1.brand = "小米";
+        p1.type = "小米9";
+        p1.os = "Android 9";
+        p1.price = 2599.0;
+        p1.memory = 8;
+        p1.about();							//调用方法
+        
+    }
+
+
+    /**
+     * 定义一个方法，该方法实现听音乐的功能，无返回值
+     * 携带一个参数，其表示为歌曲名
+     * 不换行输出格式：正在播放xx
+     */
+
+
+
+    // 定义主方法
+
+
+    // 通过无参构造创建手机对象
+
+    // 设置手机品牌为小米，型号为小米9，操作系统为Android 9，价格为2599，运行内存为8
+
+    // 查询手机信息
+
+    // 给妈妈拨打电话
+
+    // 播放浮夸这首歌
+
+
+/********** End **********/
+
+}
+练习-Java类和对象之对象引用之模拟手机功能
+ospd,1=
+import java.util.Scanner;
+/**
+ * 任务：输入两个整数，判断其是否同为偶数。
+ */
+public class ApplicationTest {
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明整型变量 x ， y 获取控制台的输入
+        int x = scanner.nextInt();
+        int y = scanner.nextInt();
+        /********** Begin **********/
+        // 第一步，使用 if 语句，分别判断变量 x 和 y 是否是偶数，并且用逻辑运算符连接两个判断结果
+        if (x % 2 == 0 && y % 2== 0){
+        // 第二步，如果同为偶数，则打印输出“两个数同为偶数！”
+        System.out.print("两个数同为偶数！");
+        }else{
+            
+        // 第三步，如果不同为偶数，则打印输出“两个数至少有一个数为奇数！”
+            System.out.print("两个数至少有一个数为奇数！");
+        }
+       
+        /********** End **********/
+    }
+}学习-Java双路分支之偶数判断
+ospd,1=
+import java.util.Scanner;
+/**
+ * 任务：输入两个整数，判断其是否同为偶数。
+ */
+public class ApplicationTest {
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明整型变量 x ， y 获取控制台的输入
+        int x = scanner.nextInt();
+        int y = scanner.nextInt();
+        /********** Begin **********/
+        // 第一步，使用 if 语句，分别判断变量 x 和 y 是否是偶数，并且用逻辑运算符连接两个判断结果
+        if (x % 2 == 0 && y % 2== 0){
+        // 第二步，如果同为偶数，则打印输出“两个数同为偶数！”
+        System.out.print("两个数同为偶数！");
+        }else{
+            
+        // 第三步，如果不同为偶数，则打印输出“两个数至少有一个数为奇数！”
+            System.out.print("两个数至少有一个数为奇数！");
+        }
+       
+        /********** End **********/
+    }
+}Java双路分支之偶数判断
+pdhw,1=
+import java.util.Scanner;
+/**
+ * 任务：判断一个给定的 5 位数是否是一个回文数
+ */
+public class ApplicationTest {
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明 int 类型的变量 num ，用来获取控制台输入
+        int num = scanner.nextInt();
+        /********** Begin **********/
+        // 第一步：获取个位数的数值
+        int ge = num%10;
+        // 第二步：获取十位数的数值
+        int shi = num/10%10;
+        // 第三步：获取百位数的数值
+        int bai = num/100%10;
+        // 第四步：获取千位数的数值
+        int qian = num/1000%10;
+        // 第五步：获取万位数的数值
+        int wan = num/10000%10;
+        // 第六步：将获取的个位数值乘以 10000 
+        int gec = ge * 10000;
+        // 第七步：将获取的十位数值乘以 1000 
+        int shic = shi*1000;
+        // 第八步：将获取的百位数值乘以 100 
+        int baic = bai * 100;
+        // 第九步：将获取的千位数值乘以 10 
+        int qianc = qian *10;
+        // 第十步：将获取的万位数值乘以 1 
+        int wanc = wan *1;
+        // 第十一步：将第六、七、八、九、十步转换后的数值相加
+        int sumc = gec + shic + baic + qianc + wanc ;
+        // 第十二步：判断变量 num 是否等于第十一步的数值，如果等于，则在控制台输出“回文数”；反之，则输出“不是回文数”
+        if ( num == sumc ){
+            System.out.print("回文数");
+        }else {
+            System.out.print("不是回文数");
+        }
+         /********** End **********/
+    }
+}Java双路分支之判断回文数
+pdss,1=
+/*
+任务：判断给定的任意一个大于 1 的正整数是否是素数。
+素数的定义：在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的自然数。
+思路：接收给定的正整数n，从2到n对该数取余，如果存在余数为零，那么该数不为素数，否则就是素数
+      
+如果不是：请输出“x不是一个素数”。
+如果是：请输出“x是一个素数”。
+
+*/
+import java.util.Scanner;
+
+public class BreakTest {
+    public static void main(String[] args) {
+       
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        Scanner in = new Scanner(System.in);
+        int a = in.nextInt();
+        int p =0;
+        for (int i = 2;i<a;i++){
+            if (a%i==0){
+                p = 1;
+            }
+        }
+        if (p==0){
+            System.out.println(a + "是一个素数");
+        }else {
+            System.out.println(a + "不是一个素数");
+        }
+       
+        
+        /********** End **********/
+
+    }
+}学习-Java循环之break之判断素数
+pdzfc,1=
+/*
+任务：
+1.获取输入的两个字符串；
+2.使用new分别创建两个字符串对象；
+3.输出字符串；
+4.分别使用equals和==比较这两个字符串是否相等。
+输出样式见预期输出。
+*/
+import java.util.Scanner;
+ 
+public class StrTest {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        Scanner scanner = new Scanner(System.in);
+        String s = scanner.next();
+        String s1 = scanner.next();
+        // 第一步：使用new创建第一个字符串对象，并输出该字符串
+        System.out.println("获取的第一个字符串："+s);
+        // 第二步：使用new创建第二个字符串对象，并输出该字符串
+        System.out.println("获取的第二个字符串："+s1);
+        // 第三步：分别使用==和equals比较创建的两个字符串是否相等，并输出比较结果
+        System.out.print("使用==比较的结果:");
+        System.out.println(s==s1);
+        System.out.println("使用equals比较的结果:"+s.equals(s1));
+        /********** End **********/
+ 
+    }
+}
+ 学习-Java字符串之String类创建字符串之使用equals和==判断字符串是否相等
+pjf,1=
+package step3;
+import java.util.Scanner;
+ 
+public class Score {
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+ 
+        int failCount = 0;
+        int passCount = 0;
+        int middleCount = 0;
+        int goodCount = 0;
+        int excellentCount = 0;
+ 
+        double totalScore = 0;
+        int studentCount = 0;
+ 
+        
+ 
+        while (true) {
+            double score = input.nextDouble();
+ 
+            if (score == -1) {
+                break;
+            }
+            if (score < 0 || score > 100) {
+            	System.out.println("请输入0~100之间的数。");
+            }
+            totalScore += score;
+            studentCount++;
+ 
+            if (score < 60) {
+                failCount++;
+            } else if (score < 70) {
+                passCount++;
+            } else if (score < 80) {
+                middleCount++;
+            } else if (score < 90) {
+                goodCount++;
+            } else {
+                excellentCount++;
+            }
+        }
+		
+        double averageScore = totalScore / studentCount;
+
+        System.out.println("不及格的人数为：" + failCount);
+        System.out.println("及格的人数为：" + passCount);
+        System.out.println("中等的人数为：" + middleCount);
+        System.out.println("良好的人数为：" + goodCount);
+        System.out.println("优秀的人数为：" + excellentCount);
+        System.out.printf("全班平均分为：%.1f",averageScore );
+    }
+}
+求平均分及各个区间段的人数
+pjz,1=
+/*
+任务：通过Scanner对象获取输入值n,求所有小于n的自然数的平均值。
+输出的平均值请转化为double类型。
+*/
+
+import java.util.Scanner;
+
+public class DWhileTest {
+    public static void main(String[] args) {
+        // 定义变量n，接收输入值
+        int n;
+        // 定义求和变量sum，并赋初值0
+        int sum=0;
+        // 定义变量i,并赋初值0
+        int i=0;
+        //创建Scanner对象
+        Scanner input = new Scanner(System.in);
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 获取输入值n
+        n = input.nextInt();
+        do{
+            if (i<n){
+                sum = sum + i ;
+            }
+            i++;
+        }
+        // 在while后判断条件，当i不小于n时退出循环
+        while(i<n);
+        // 输出平均值，保留两位小数
+        double avg=(double)sum/i;
+        System.out.println(String.format("%.2f",avg));
+        
+        /********** End **********/
+
+    }
+}
+学习-Java循环do…while之前n个自然数平均值
+pjzfc,1=
+/*
+任务：接收给定的加速度（第一个数）和时间（第二个数），计算该时间所处的距离。
+
+具体输出样式见预期输出。
+*/
+
+import java.util.Scanner;
+public class StrTest {
+    public static void main(String[] args) {
+            // 请在Begin-End间编写代码
+            /********** Begin **********/
+
+            // 第一步：接收加速度
+            Scanner scanner = new Scanner(System.in);
+            int a = scanner.nextInt();
+            // 第二步：接收时间
+            int t=scanner.nextInt();
+            // 第三步：使用格式化字符串的方式输出距离
+            double s = 8.0*t+0.5*a*t*t;
+            // System.out.print("当时间为" + t);
+            // System.out.print("，加速度为" + a);
+            // System.out.print("时，距离为" + s);
+            System.out.printf("当时间为%d，加速度为%d时，距离为%.1f",t,a,s);//为啥double的输出格式是%f,而不是%lf
+            /********** End **********/
+
+    }
+}
+练习-Java字符串之String类并置运算之字符串拼接
+qmj,1=
+/**
+ * 任务：已知一个球的半径为 12.0，求该球的表面积。
+ * 类名为：Sphere
+ */
+public class Sphere {
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+    // 定义圆的半径和π，π为 Math中的π
+double r;
+    // 无参构造
+Sphere(){
+    
+}
+    // 有参构造
+Sphere(double r){
+    this.r=r;
+}
+    /**
+     * 定义一个方法，该方法实现计算球的表面积，返回值为double，携带一个参数，为球的半径
+     */
+public static double mian(double r){
+    return 4*(Math.PI)*r*r;
+}
+    // 定义主方法
+public static void main(String[] args){
+    // 通过无参构造创建球对象
+Sphere sphere=new Sphere();
+    // 调用计算球面积的方法，将半径 r 的值传入
+double result = sphere.mian(12.0);
+    // 四舍五入格式化不换行输出球的面积，输出格式：球的表面积为xx
+System.out.print("球的表面积为"+ String.format("%.2f",result));
+}
+/********** End **********/
+ 
+}学习-Java类和对象之参数传值机制之求球面积
+qt,1=
+import java.util.Scanner;
+
+/**
+ * 任务：给定一个整数 a，判断其是否是自然数同时又是偶数。
+ */
+public class ApplicationTest {
+
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明 int 类型的变量 a 用来获取控制台输入
+        int a = scanner.nextInt();
+        /********** Begin **********/
+        // 第一步：判断变量 a 是否大于等于 0 ,如果符合条件，则进入第二步；反之，则在控制台输出"该数不是自然数"
+        if (a>0){
+            if (a%2==0){
+                System.out.print("该数既是自然数又是偶数");
+            }else{
+                System.out.print("该数为自然数，但不是偶数");
+            }
+        }else{
+            System.out.print("该数不是自然数");
+        }
+            // 第二步：判断变量 a 取模 2 是否为 0 ，如果为 0 ，则在控制台输出 "该数既是自然数又是偶数"；反之，则输出"该数为自然数，但不是偶数"
+            
+      
+
+        /********** End **********/
+    }
+}
+
+
+学习-Java分支结构之嵌套
+qtj,1=
+/**
+ * 任务：已知一个球的半径为 12.0，求该球的体积。
+ * 类名为：Sphere
+ */
+ 
+public class Sphere {
+ 
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+ 
+/********** Begin **********/
+ 
+    // 定义圆的半径和π，π为 Math中的π
+ 
+double pi=Math.PI;
+double r;
+    // 无参构造
+Sphere()
+{
+    this(12.0);
+}
+Sphere(double r1)
+{
+    r=r1;
+}
+double tiji(double R)
+{
+return (double)4/3*pi*R*R*R;
+}
+ 
+    // 有参构造
+ 
+    /**
+     * 定义一个方法，该方法实现计算球的体积，返回值为double，携带一个参数，为球的半径
+     */
+public static void main(String[]args)
+{
+    Sphere p1=new Sphere();
+    System.out.printf("球的体积为%.2f",p1.tiji(p1.r)) ;
+}
+ 
+    // 定义主方法
+ 
+ 
+    // 通过无参构造创建球对象
+ 
+ 
+    // 调用计算球体积的方法，将半径 r 的值传入
+ 
+    // 四舍五入格式化不换行输出球的体积，输出格式：球的体积为xx
+ 
+ 
+/********** End **********/
+ 
+}练习-Java类和对象之参数传值机制之求球体积
+qws,1=
+/*
+任务：接收一个整数，判断该数是否是完数。
+完数的定义：一个数如果恰好等于它的因子之和（本身除外），这个数就称为完数。
+例如数字6，其因子为1，2，3，6（本身除外），满足1+2+3=6，所以这个数为完数。
+如果是完数，请输出：x是完数
+如果不是完数，请输出：x不是完数
+具体输出样式见预期输出。
+*/
+ 
+import java.util.Scanner;
+ 
+public class ForTest {
+    public static void main(String[] args) {
+        // 定义变量sum，用于求因子的和，并赋初值为0
+        int sum=0;
+        // 创建Scanner对象
+        Scanner input = new Scanner(System.in);
+        // 获取输入值
+        int x = input.nextInt();
+        // 请在 Begin-End 间编写代码
+ 
+        /********** Begin **********/
+        // 第一步：使用for循环判断获取的整数是否为完数
+        for(int j = 1; j < x; ++j){
+            if(x % j == 0)
+                sum += j;
+            }      
+        // 第二步：如果是完数，请输出x是完数
+        if(x == sum){
+            System.out.print(x+"是完数");
+        }         
+        // 第三步：如果不是，请输出x不是完数
+        else{
+            System.out.print(x+"不是完数");
+        }
+        /********** End **********/
+ 
+    }
+}练习-Java循环for之求完数
+rldy,1=
+/*
+接收一个年份数（大于等于1900）和一个月份数，打印出该月的日历。
+日历输出格式如下：
+==================================================
+日	一	二	三	四	五	六
+						1	
+2	3	4	5	6	7	8	
+9	10	11	12	13	14	15	
+16	17	18	19	20	21	22	
+23	24	25	26	27	28	29	
+==================================================
+其中日期上下的分隔符用的是50个=。
+日期之间以及星期之间使用\t分隔。
+1900年1月1日是星期1。
+
+
+思路分析：
+求1900年到输入年份之间的累计天数，其中闰年366天，平年365天；
+求1月到输入月份之间的累计天数；
+得到1900-1-1到输入年月之前所有天数，用总天数对7求余，对余数加1，该数值即为该月1号的星期；
+判断输入月份有多少天；
+控制格式打印日历。
+*/
+
+// 请在Begin-End间编写完整代码，类名请使用Calendar
+/********** Begin **********/
+// 导入 Scanner 类
+import java.util.Scanner;
+// 定义公开类 Calendar
+public class Calendar{
+	// 定义主方法 main，在该方法中完成本关任务
+    public static void main(String [] args){
+        Scanner sin = new Scanner(System.in);
+        int y=sin.nextInt();
+        int m=sin.nextInt();
+        if(y<1900)
+            System.out.println("请输入大于或等于1900的年份");
+        else if(m>12||m<1)
+            System.out.println("请输入正确的月份");
+        else{
+            int sum=0;  //记录一共多少天
+            int d=0;   //标记某月有多少天
+            for(int i=1990;i<y;i++){      //计算整年的天数
+                if(i%4==0&&i%100!=0||i%400==0)
+                    sum+=366;
+                else
+                    sum+=365;
+            }
+            for(int i=1;i<=m;i++){    //计算整月的天数
+                switch(i){
+                    case 2: if(y%4==0&&y%100!=0||y%400==0) d=29;
+                            else  d=28;break;
+                    case 4:
+                    case 6:
+                    case 9:
+                    case 11: d=30;break;
+                    default : d=31;
+                }
+                if(i<m)   //天数加到前一个月
+                    sum+=d;
+            }
+            //System.out.println(sum);
+            
+            int count=(sum+1)%7; //表示与星期一相隔几天；
+            //System.out.println(count);
+            System.out.println("==================================================");
+            System.out.println("日	一	二	三	四	五	六"); //复制测试结果中的格式
+            for(int i=1;i<=count;i++)
+                System.out.print("\t");
+            for(int i=1;i<=d;i++){
+                
+                System.out.printf("%d\t",i);
+                if((i+count)%7==0)
+                    System.out.println();
+            }
+            System.out.println();
+            System.out.println("==================================================");
+        }
+    }
+
+}
+/********** End **********/
+
+练习-Java循环综合练习四之日历打印
+sbqmj,1=
+/**
+ * 任务：根据从键盘输入的三角形的三个边长，求出三角形的面积。
+ * 类名为：TriangleArea
+ */
+
+
+import java.util.Scanner;
+
+public class TriangleArea {
+    public static void main(String[] args) {
+        Scanner reader = new Scanner(System.in);
+
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+
+        // 第一步：获取键盘三次输入的值
+        double a = reader.nextDouble();
+        double b = reader.nextDouble();
+        double c = reader.nextDouble();
+        // 第二步：根据三角形面积公式求取三角形面积
+        double p = (a+b+c)/2.0;
+        double s = Math.sqrt(p*(p-a)*(p-b)*(p-c));
+        
+        // 第三步：格式化输出三角形的面积
+        System.out.printf("三角形的面积为：%.2f",s);
+        /********** End **********/
+
+
+    }
+}Java顺序结构之数学函数之根据三角形三边长求面积
+scsgs,1=
+import java.util.Scanner;
+
+/**
+ * 任务：按升序（从小到大）输出三个数
+ */
+public class ApplicationTest {
+
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明整型变量 x ， y ，z 获取控制台的输入
+        int x = scanner.nextInt();
+        int y = scanner.nextInt();
+        int z = scanner.nextInt();
+        // 声明整型变量 temp ，用于变量值的临时存储
+        int temp = 0;
+        /********** Begin **********/		
+        // 使用 if 语句判断 x、y、z 的大小 ，并将三个数中的最小值赋值给 x，最大值赋值给 z。
+        if (x>y){
+            temp = y;
+            y = x;
+            x = temp; 
+        }
+        if (y>z){
+            temp = y;
+            y = z;
+            z = temp;
+        }
+        if (x>y){
+            temp = y;
+            y = x;
+            x = temp; 
+        }
+      
+       
+        /********** End **********/
+        System.out.println("从小到大排列:" + x + " " + y + " " + z);
+    }
+
+}
+练习-Java单路分支之按序输出三个数
+scta,1=
+/**
+ * 任务：输出实心等腰三角形。
+ * 类名为：OutputTriangle
+ */
+ 
+public class OutputTriangle {
+    public static void main(String[] args) {
+    	 // 请在下面的 Begin-End 处，按照所给的代码注释完成相应代码的编写
+         /********** Begin **********/
+         // 使用空格和*，向控制台输出一个高为4，底为7的等腰三角形，最后一个输出采用不换行输出
+         System.out.println("   *");
+         System.out.println("  ***");
+         System.out.println(" *****");
+         System.out.print("*******");
+
+        /********** End **********/
+
+    }
+} 
+Java顺序结构之无输入输出给定图案
+
+scxdx,1=
+package step2;
+abstract class Employee {
+    public abstract double earnings();
+}
+class YearWorker extends Employee {
+    @Override
+    public double earnings() {
+ 
+ 
+        return 100000.0;
+    }
+    //重写earnings()方法
+    /********** Begin **********/
+ 
+ 
+    /********** End **********/
+}
+class MonthWorker extends Employee {
+    @Override
+    public double earnings() {
+        return 120000.0;
+    }
+    //重写earnings()方法
+    /********** Begin **********/
+ 
+ 
+    /********** End **********/
+}
+class WeekWorker extends Employee {
+    @Override
+    public double earnings() {
+    //注意题目是按照28天计算
+        return 5000.0*4*12 ;
+    }
+    //重写earnings()方法
+    /********** Begin **********/
+ 
+ 
+    /********** End **********/
+}
+class Company {
+    Employee[] employees;
+    double salaries = 0;
+    Company(Employee[] employees) {
+        this.employees = employees;
+    }
+    public double salariesPay() {
+        salaries = 0;
+        //计算salaries
+        /********** Begin **********/
+ 
+        for  (Employee employee:
+             employees) {
+           salaries+= employee.earnings();
+        }
+ 
+        /********** End **********/
+        return salaries;
+    }
+}
+public class HardWork {
+    public static void main(String[] args) {
+//        创建了20个雇员
+        Employee[] employees = new Employee[20];
+        //区别不同工资的雇员
+        for (int i = 0; i < employees.length; i++) {
+            if(i%3==0)
+                employees[i] = new WeekWorker();
+            else if(i%3==1)
+                employees[i] = new MonthWorker();
+            else if(i%3==2)
+                employees[i] = new YearWorker();
+        }
+        Company company = new Company(employees);
+        System.out.println("公司年工资总额:" + company.salariesPay());
+    }
+}
+上转型对象的使用，多态的特性
+sjgsh,1=
+import java.util.Date;
+import java.util.Scanner;
+public class StrTest {
+    public static void main(String[] args) {
+            // 请在Begin-End间编写代码
+            /********** Begin **********/
+Scanner sc = new Scanner(System.in);
+ 
+String str = sc.nextLine(); //输入字符串
+Date date = new Date(str);  //破译字符串
+ 
+String oneyearday = String.format("%tj",date);      //返回一年中的第几天
+System.out.println("该日期是这一年中的第" + oneyearday + "天");
+ 
+String foryear = String.format("%tY", date);        //返回4位数年份
+String onemonth = String.format("%tm", date);       //返回2位数月份
+String onemonthday = String.format("%td", date);    //返回2位数日份
+System.out.println("该日期的年月日为：" + foryear + "-" + onemonth + "-" + onemonthday);
+ 
+String hour = String.format("%tH", date);           //24小时制的小时
+String minute = String.format("%tM", date);
+String second = String.format("%tS", date);
+System.out.println("时：" + hour + "\n分：" + minute + "\n秒：" + second);
+    }
+}学习-Java字符串之String类格式化字符串之日期时间格式化输出
+sjhs,1=
+/**
+ * 任务：从键盘输入的值分别为三角形的 a、b 两条边长和两边夹角 C 的角度，求出该三角形的面积，请对最终结果保留两位小数。
+ * 类名为：TriangleArea
+ */
+
+
+import java.util.Scanner;
+
+public class TriangleArea {
+    public static void main(String[] args) {
+
+        Scanner reader = new Scanner(System.in);
+
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+        // 第一步：获取键盘第一次输入的值
+        double a = reader.nextDouble();
+        // 第二步：获取键盘第二次输入的值
+        double b = reader.nextDouble();
+        // 第三步：获取键盘第三次输入的值
+        double c = reader.nextDouble();
+        // 第四步：求sinC的值
+        double rad = Math.toRadians(c);
+        double sinC = Math.sin(rad);
+        // 第五步：根据三角形面积公式求取三角形面积，此处用0.5代替1/2
+        double s = 0.5*(a*b*sinC);
+        // 第六步：不换行输出三角形的面积
+        System.out.printf("%.2f",s);
+
+        /********** End **********/
+
+    }
+}
+练习-Java顺序结构之数学函数之三角函数
+sjqc,1=
+import java.util.Arrays;
+import java.util.Scanner;
+public class ArrTest {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 接收给定的数据
+    Scanner input=new Scanner(System.in);
+    int n=input.nextInt();
+    int [] arr=new int[n];
+    for(int i=0;i<n;i++){
+        arr[i]=input.nextInt();
+    }
+        // 通过临时数组对原数组去重，最后将临时数组赋值给原数组
+    int [] aar=new int[n];
+    int z=0;
+    for(int i=0;i<n;i++){
+        int t=0;
+        for(int j=0;j<i;j++){
+            if(arr[i]==arr[j]){
+                t=1;
+                break;
+            }
+        }
+        if(t==0)
+        aar[z++]=arr[i];
+    }
+        // 打印去重后的数组值
+    
+        /********** End **********/
+    for(int i=0;i<z;i++)
+    System.out.println(aar[i]);
+    }
+}练习-Java数组之一维数值数组之数据去重
+sjstj,1=
+import java.util.Random;
+import java.util.Scanner;
+public class RandomTest {
+    public static void main(String[] args) {
+           // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 接收给定数据
+        Scanner scanner = new Scanner(System.in);
+        int z = scanner.nextInt();     // 数组长度
+        long l = scanner.nextLong();     // 随机数种子
+        // 创建Random对象，并设置随机种子
+        Random random = new Random(l);
+        // 定义数组添加数据
+        int a[] = new int[z];
+        for (int i = 0; i < a.length; ++i) {
+            a[i] = random.nextInt(20);
+        }
+        // 统计每个数出现的次数
+        int b[] = new int[z];
+        for (int i = 0; i < b.length; ++i) {
+            b[i] = 0;
+        }
+        for (int i = 0; i < a.length; ++i) {
+            b[a[i]]++;
+        }
+        // 输出结果
+        for (int i = 0; i < z; ++i) {
+            if(b[i]>0) {
+                System.out.println(i + "出现了:" + b[i] + " 次");
+            }
+        }
+        /********** End **********/
+    }
+}学习-Java数组之一维数值数组之随机数统计
+sjx,1=
+package step1;
+ 
+ 
+import java.lang.Math;
+import java.util.Scanner;
+ 
+ 
+public class Triangle {
+	double a,b,c;
+	
+	public Triangle(double a, double b, double c) {
+		this.a = a;
+		this.b = b;
+		this.c = c;
+	}
+ 
+	public double getArea() {
+		double s = (a + b + c) / 2;
+		return Math.sqrt(s * (s - a) * (s - b) * (s - c));
+	}
+ 
+	public double getPerimeter() {
+		return a + b + c;
+	}
+ 
+	public static void main(String[] args) {
+		Scanner input =new Scanner(System.in);
+		double a = input.nextDouble();
+		double b = input.nextDouble();
+		double c = input.nextDouble();
+    	Triangle t1 = new Triangle(a, b, c);
+    	System.out.printf("三角形(%.1f,%.1f,%.1f)的面积为:%.2f\n",t1.a,t1.b,t1.c,t1.getArea());
+    	System.out.printf("三角形(%.1f,%.1f,%.1f)的周长为:%.2f",t1.a,t1.b,t1.c,t1.getPerimeter());
+	}
+ 
+}
+编写一个代表三角形的类
+sltj,1=
+/*
+任务：统计给定一列数的正数和负数个数
+给定的数举例：-1 2 3 -4 %
+其中%用于while中，判断输入结束
+*/
+ 
+import java.util.Scanner;
+ 
+public class DWhile {
+    public static void main(String[] args) {
+        // 定义变量positive，并赋初值0,用于统计正数个数
+        int positive=0;
+        // 定义变量negative，并赋初值0，用于统计负数个数
+        int negative=0;
+        
+        // 创建Scanner对象
+        Scanner input = new Scanner(System.in);
+        
+        // 在do后的花括号中编写循环语句
+        do{
+        // 请在 Begin-End 间编写代码
+        /********** Begin **********/
+            // 第一步： 获取输入值
+            int n = input.nextInt();
+            // 第二步：判断输入值是否为正数，如果是，把正数个数变量positive加1
+           if(n>0){
+               positive++;
+           }
+            // 第三步：判断输入值是否为负数，如果是，把负数个数变量negative加1
+           if(n<0){
+               negative++; 
+            }
+            if(n==0){
+                continue;
+            }
+        }
+           // 第四步：在while后判断条件，当输入值的下一个值为%时，终止循环
+        while(!input.hasNext("%"));
+           // 第五步：输出正数和复数个数，具体格式见预期输出
+        System.out.printf("正数个数为：%d。负数个数为：%d",positive,negative);
+        /********** End **********/
+    }
+}练习-Java循环do…while之正负数数量统计
+srxq,1=
+
+/**
+ * 任务：一小球以 v0 米/秒 的水平速度平抛，重力加速度取9.8米/秒2，
+ * 在忽略空气阻力的情况下，求经过时间 t 秒后，
+ * 小球所在位置与抛出点之间的距离 (假设小球距地面足够高)。
+ * 类名为：Distance
+ */
+
+import java.util.Scanner;
+
+public class Distance {
+    public static void main(String[] args) {
+
+        double g = 9.8;     // 声明浮点型变量 g，用于表示重力加速度
+
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+        // 第一步：创建一个Scanner的实例对象，命名为reader
+        Scanner reader = new Scanner(System.in);
+        // 第二步：获取键盘第一次输入的值，将其命名为V0，用于表示水平初速度
+        double V0  = reader.nextDouble();
+        // 第三步：获取键盘第二次输入的值，将其命名为t，用于表示小球飞行的时间
+        double t = reader.nextDouble();
+        // 第四步：计算水平距离，并赋值给s
+        double s = V0*t;
+        // 第五步：计算垂直距离，并赋值给h
+        double h =g*t*t/2;
+        // 第六步：计算小球与原点的距离，并赋值给d，Math.sqrt()可以用来对括号里的值求平方根
+        double d= Math.sqrt(s*s+h*h);
+        // 第七步：打印出小球与原点的距离d，最后结果四舍五入后保留两位小数
+        System.out.printf("%.2f",d);
+
+        /********** End **********/
+
+    }
+}
+
+Java顺序结构之有输入格式化输出平抛小球与抛出点之间的距离
+
+ssjk,1=
+/**
+ * 编写一个学校接待方面的程序，招待不同身份的人的食宿问题
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+ 
+// 定义一个接口类 Person
+interface Person{
+    // 定义 eat()，实现输出吃饭的功能，无返回值
+    public abstract void eat();
+    // 定义 sleep()，实现睡觉的功能，无返回值
+    public abstract void sleep();
+}
+// 定义一个 Student 类并实现 Person 接口
+class Student implements Person{
+    // 实现 eat()：输出：“学生去食堂吃饭。”；
+    public void eat() {
+        System.out.println("学生去食堂吃饭。");
+    }
+    // 实现 sleep()：输出：“学生在宿舍睡觉。”。
+    public void sleep() {
+        System.out.println("学生在宿舍睡觉。");
+    }
+}
+ 
+// 定义一个 Teacher 类并实现 Person 接口
+class Teacher implements Person{
+    // 实现 eat()：输出：“老师去教师食堂吃饭。”；
+    public void eat() {
+        System.out.println("老师去教师食堂吃饭。");
+    }
+    // 实现 sleep()：输出：“老师在学校公寓睡觉。”。
+    public void sleep() {
+        System.out.println("老师在学校公寓睡觉。");
+    }
+}
+/********** End **********/练习-Java继承和多态之接口
+sszd,1=
+import java.util.Scanner;
+/**
+ * 任务：使用单路分支的 if 语句完成从控制台输入的三个数值中获取最大值的任务
+ */
+public class ApplicationTest {
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        //声明整型变量 a ， b ，c 获取控制台的输入。
+        int a = input.nextInt();
+        int b = input.nextInt();
+        int c = input.nextInt();
+        //声明整型变量 max ， 用来存储最大值。
+        int max = 0;
+        /********** Begin **********/
+        //第一步，将变量 a 的值赋值给变量 max ，假设变量 a 的值为最大值。
+        max = a;
+        //第二步，使用 if 语句比较变量 b 与变量 max 的大小，如果值大于 max ，则将值赋值给 max。
+        if (b>max){
+            max = b;
+        }
+		//第三步，使用 if 语句比较变量 c 与变量 max 的大小，如果值大于 max ，则将值赋值给 max。
+        if (c>max){
+            max= c;
+        }
+        /********** End **********/
+        System.out.println("最大值为：" + max);
+    }
+}学习-Java单路分支之求三个数中最大者
+super,1=
+/*
+* 定义 Person 类和 Student 类，分别实现定义各自基本属性的功能。
+ */
+ 
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********* Begin *********/
+// 声明一个名为Person的类，里面有name与age两个属性，分别为String和int型，并声明一个含有两个参数的构造方法
+ class Person//这里不需要公开的类public
+{
+    String name;
+    int age;
+    public Person(String name,int age)
+    {
+        this.name=name;
+        this.age=age;
+    }
+}
+public class Student extends Person
+{
+    String school;
+    Student(String name,int age,String school)
+    {
+        super(name,age);
+    this.school=school;
+    }
+}
+// 声明一个名为Student的类，此类继承自Person类，添加一个属性school，字符串类型
+// 在子类的有参构造方法中调用父类中有两个参数的构造方法
+ 
+ 
+/********** End **********/练习-Java继承和多态之super关键字
+supergjz,1=
+/*
+* 根据要求补全 Salary 类，实现输出员工基本信息和薪水的功能。
+ */
+class Employee {
+    private String name;// 员工姓名
+    private String birth;// 出生年月
+    private String position;// 职位
+ 
+    // 使用有参构造方法初始化Employee
+    public Employee(String name, String birth, String position) {
+        this.name = name;
+        this.birth = birth;
+        this.position = position;
+    }
+    // 定义 introduction 方法输出员工信息
+    public void introduction() {
+        System.out.println("员工姓名：" + name + "\n出生年月：" + birth + "\n职位：" + position);
+    }
+ 
+}
+ 
+public class Salary extends Employee {
+    private double salary; // 薪水
+    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+    /********* Begin *********/
+    // 定义Salary的有参构造方法，同时在子类中指代父类构造器
+public Salary(String name,String birth,String position,double salary){
+    super(name,birth,position);
+    this.salary=salary;
+}
+ 
+    // 重写introduction方法，使用super保留父类原有的功能，新添输出员工薪水的功能
+public void introduction(){
+    super.introduction();
+    System.out.print("薪水："+salary);
+}
+    /********** End **********/
+}学习-Java继承和多态之super关键字
+sxh,1=
+/*
+* 任务：使用for循环输出所有的水仙花数
+*水仙花数特征：
+  - 该值处于 100（包括）到 999（包括）之间；
+  - 其个位数的三次幂，十位数的三次幂，百位数的三次幂的和等于这个数本身。
+* 输出样式：x是一个水仙花数。
+*/
+
+
+public class ForTest {
+    public static void main(String[] args) {
+    
+        // 请在 Begin-End 间编写代码
+        
+        /********** Begin **********/
+        // 第一步：使用for循环依次取999到100中的每个数，判断是否为水仙花数
+      
+        for (int i = 999;i>=100;i--){
+          // 第二步：获取个位
+          int ge = i % 10;
+          // 第三步：获取十位
+          int shi = i / 10 % 10 ;
+          // 第四步：获取百位
+          int bai = i /100 % 10 ;
+          int sum =ge*ge*ge+shi*shi*shi+bai*bai*bai;
+          if (sum == i){
+            System.out.println(i+"是一个水仙花数。");
+          }
+        }
+        // 第五步：判断个位数的三次幂，十位数的三次幂，百位数的三次幂的和是否等于这个数本身，等于的话，输出该数
+        
+       /********** End **********/
+    
+    }
+}学习-Java循环for之求水仙花数
+syfz,1=
+package case1;
+public class TestPersonDemo {
+ public static void main(String[] args) {
+ // 声明并实例化一个 Person 对象 p
+ Person p = new Person();
+ // 给 p 中的属性赋值
+ p.setName("张三");
+ p.setAge(18);
+ // 调用 Person 类中的 talk()方法
+ p.talk();
+ }
+}
+// 在这里定义 Person 类
+class Person {
+ // 将属性私有化
+ 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;
+ }
+ // 定义 talk()方法
+ public void talk() {
+ System.out.println("我是：" + name + "，今年：" + age + "岁");
+ }
+}
+什么是封装，如何使用封装
+syjc,1=
+package case2;
+public class extendsTest {
+ public static void main(String args[]) {
+ // 实例化一个 Cat 对象，设置属性 name 和 age，调用 voice()和 eat()方法，再打印出名
+字和年龄信息
+ /********* begin *********/
+ Cat cat = new Cat();
+ cat.setName("大花猫");
+ cat.setAge(6);
+ cat.voice();
+ cat.eat();
+ System.out.println(cat.getName() + cat.getAge() + "岁");
+ /********* end *********/
+ // 实例化一个 Dog 对象，设置属性 name 和 age，调用 voice()和 eat()方法，再打印出名
+字和年龄信息
+ /********* begin *********/
+ Dog dog = new Dog();
+ dog.setName("大黑狗");
+ dog.setAge(8);
+ dog.voice();
+ dog.eat();
+ System.out.println(dog.getName() + dog.getAge() + "岁");
+ /********* end *********/
+ }
+}
+class Animal {
+ 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;
+ }
+}
+class Cat extends Animal {
+ // 定义 Cat 类的 voice()和 eat()方法
+ public void voice() {
+ System.out.println(getName() + "喵喵叫");
+ }
+ public void eat() {
+ System.out.println(getName() + "吃鱼");
+ }
+}
+class Dog extends Animal {
+ // 定义 Dog 类的 voice()和 eat()方法
+ public void voice() {
+ System.out.println(getName() + "汪汪叫");
+ }
+ public void eat() {
+ System.out.println(getName() + "吃骨头");
+ }
+}什么是继承，怎样使用继承
+syjs,1=
+/**
+ * 任务：假定一个用户每月向一个储蓄帐户中存 1000 元人民币，年利率为 2.25％。那么月利率为 0.0225/12=0.001875。
+ * 编写一个程序，输出 6 个月后的账户金额。
+ * 类名为：BankRate
+ */
+
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+
+// 第一步：创建一个名为 BankRate 的公开类
+class BankRate{
+// 第二步：在这个类中定义主方法
+public static void main(String[] args){
+// 第三步：在主方法中计算第六个月后总资金为多少
+double yueli = 0.001875;
+double a = 1000;
+for (int i=0;i<6;i++){
+    a=a*(1+yueli);
+}
+// 第四步：格式化输出六个月后账户的总金额，结果保留两位小数
+System.out.printf("%.2f",a);
+}
+}
+
+练习-Java顺序结构综合练习一之银行复利计息收益计算
+szdsy,1=
+package step2;
+import java.util.Scanner;
+public class HelloWorld {
+ public static void main(String[] args) {
+ /********** Begin **********/
+ //在这里定义一个长度为 4 的字符串数组，用来存放学生姓名
+ String[] stuNames = new String[4];
+ //在这里给 stuNames 数组赋值 分别为 张三,张无忌,张三丰,张岁山
+ stuNames[0] = "张三";
+ stuNames[1] = "张无忌";
+ stuNames[2] = "张三丰";
+ stuNames[3] = "张岁山";
+ //在这里输出 stuNames 数组中的数据
+ System.out.println("数组中的第一个数据为：" + stuNames[0]);
+ System.out.println("数组中的第二个数据为：" + stuNames[1]);
+ System.out.println("数组中的第三个数据为：" + stuNames[2]);
+ System.out.println("数组中的第四个数据为：" + stuNames[3]);
+ Scanner sc = new Scanner(System.in);
+ //在这里使用 Scanner 获取系统输入的整数,并用获取到的数据来设置 scores 数组的长度
+ System.out.print("请输入数组 scores 的长度：");
+ int length = sc.nextInt();
+ int[] scores = new int[length];
+ /********** End **********/
+ System.out.println("数组 scores 的长度为：" + scores.length);
+ }
+}
+数组的使用
+szpx,1=
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class ArrTest {
+    
+    public static void main(String[] args) {
+		// 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 从控制台获取输入值（当输入值为%时，终止获取），并给数组赋值
+        Scanner scanner = new Scanner(System.in);
+        int m= scanner.nextInt();
+        int [] arr=new int[m];     // 定义一维数组
+        int n=0;
+        while(!scanner.hasNext("%")){
+          arr[n] = scanner.nextInt();
+          n++;
+        }
+        // 对数组元素求平方并排序
+         for(int i=0;i<arr.length;i++){
+             arr[i]=arr[i]*arr[i];
+        }  
+        Arrays.sort(arr);          
+        // 输出新数组
+        System.out.print(Arrays.toString(arr));
+       /********** End **********/
+    }
+}
+练习-Java数组之Arrays类操作数组之数组排序
+szpx,1=
+import java.util.Scanner;
+import java.util.Arrays;
+public class SortTest {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 接收给定数据
+        int n=0;
+        Scanner scanner = new Scanner(System.in);
+        int x = scanner.nextInt();
+        // 定义数组
+        int[] arr = new int[x];
+        // 给数组赋值
+        while (!scanner.hasNext("#")){
+            int y = scanner.nextInt();
+            arr[n]=y;
+            n++;
+        }
+       // 使用直接选择排序法对数组升序排序，并输出每次排序的结果
+        for (int i = 0; i < arr.length - 1; i++) {
+            int  min = i;
+            for (int j = i + 1; j < arr.length; j++) {
+                if (arr[min] > arr[j]) {
+                    min = j;
+                }
+            }
+            if (min != i) {
+                int tmp = arr[min];
+                arr[min] = arr[i];
+                arr[i] = tmp;
+            }
+            System.out.println("第"+(i+1)+"次排序:"+Arrays.toString(arr));
+        }
+        // 输出排序后的数组
+        System.out.println("排序后的结果为："+Arrays.toString(arr));
+        /********** End **********/
+    }
+}学习-Java数组之一维数值数组之排序
+szys,1=
+ 
+import java.util.Arrays;
+import java.util.Scanner;
+public class ArrTest {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 第一步：从控制台获取输入值（当输入值为%时，终止获取），并给数组赋值
+        Scanner scanner = new Scanner(System.in);
+        int m= scanner.nextInt();
+        int [] arr=new int[m];     // 定义一维数组
+        int n=0;
+        while(!scanner.hasNext("%")){
+          arr[n] = scanner.nextInt();
+          n++;
+    }
+        // 第二步：替换数组
+        for(int i=0;i<arr.length;){
+            Arrays.fill(arr,i,i+1,18);
+            i+=4;
+        }
+        // 第三步：输出替换后的数组
+        System.out.print(Arrays.toString(arr));
+        /********** End **********/
+    }
+}学习-Java数组之Arrays类操作数组之填充替换数组元素
+tcptx,1=
+package step3;
+ 
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.util.Scanner;
+ 
+public class Client {
+ 
+    public static void main(String[] args) throws Exception {
+        Server server = new Server();
+        server.start();
+        Scanner sc = new Scanner(System.in);
+ 
+        //创建客户端Socket(s)，指定服务器端IP地址和端口号
+        /********** Begin **********/
+        Socket s = new Socket("127.0.0.1", 8080);
+ 
+        /**********  end  **********/
+        DataOutputStream dos = new DataOutputStream(s.getOutputStream());
+        DataInputStream dis = new DataInputStream(s.getInputStream());
+        System.out.println(dis.readUTF());
+        String name = sc.next();
+        dos.writeUTF(name);
+        System.out.println(dis.readUTF());
+        s.close();
+    }
+}
+简单TCP通信
+tddx,1=
+/**
+ * 任务：使用 instanceof 运算符判断指定对象是否为特定类的一个实例
+ */
+class Person{}
+class Students extends Person{}
+class Sch extends Students{}
+public class Demos{
+    public static void main(String[] args) {
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********* Begin *********/
+        // 创建一个Students对象，判断该对象是否是Person类的实例
+        //如果是输出：true，否则为false
+    Students students=new Students();
+    if(students instanceof Person){
+        System.out.println("true");
+    }else System.out.println("false");
+        // 创建一个Sch对象，判断该对象是否是Person类的实例
+        // 输出判断结果
+    Sch sch=new Sch();
+    if(sch instanceof Person){
+        System.out.println("true");
+    }else System.out.println("false");
+        // 创建一个Person对象，判断该对象是否是Students类的实例
+        // 输出判断结果
+    Person person = new Person();
+    if(person instanceof Students){
+        System.out.println("true");
+    } else System.out.println("false");
+        /********** End **********/
+    }
+}学习-Java继承和多态之子类对象特点
+this,1=
+/**
+ * 任务：定义一个完整的学生类，该类定义了学生的基本信息。
+ * 类名为：Student
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 创建一个名为 Student 的公开类
+public class Student {
+    // 定义学生的两个属性：姓名（name String）和年龄（age int）
+    String name;
+    int age;
+	// 获取学生年龄
+    public int getAge() {
+        return age;
+    }
+    // 设置学生的年龄，将形参的值赋值给成员变量
+    public void setAge(int age) {
+        this.age = age;
+    }
+	// 获取学生姓名
+    public String getName() {
+        return name;
+    }
+    // 设置学生姓名，将形参的值赋值给成员变量
+    public void setName(String name) {
+        this.name = name;
+    }
+    // 该方法实现输出学生信息的功能。 输出格式：学生姓名：xx，年龄：xx
+    public void info() {
+        System.out.println("学生姓名："+ name +"，年龄：" + age);
+    }
+}
+ 
+/********** End **********/练习-Java类和对象之this关键字
+tsjs,1=
+import java.util.Scanner;
+
+/**
+ * 任务：根据给定的年份和月份，获取该月份的天数。
+ */
+public class ApplicationTest {
+
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码。
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int year = scanner.nextInt();
+        int month = scanner.nextInt();
+        int day = 0;
+        /********** Begin **********/
+        // 第一步：判断变量 month 是否为 1、3、5、7、8、10、12 内的月份，如果是，则将数值 31 赋值给变量 day
+        int[] yue1 = {1,3,5,7,8,10,12};
+        for (int i =0;i<yue1.length;i++){
+            if (month == yue1[i]){
+                day = 31;
+            }
+        } 
+
+        // 第二步：判断变量 month 是否为 4、6、9、11 内的月份，如果是，则将数值 30 赋值给 day
+        int[] yue2 = {4,6,9,11};
+        for (int j =0;j<yue2.length;j++){
+            if (month == yue2[j]){
+                day = 30;
+            }
+        } 
+        // 第三步：如果以上条件都不满足，则进入最后一种情况
+        // 第四步：判断是否是闰年，是闰年，则将数值 29 赋值给 day；反之，则将数值 28 赋值给 day
+        if (month == 2){
+            if (year/400==0 || year / 100!=0){
+                day = 29;
+            }else {
+                day = 28;
+            }
+        }
+        /********** End **********/
+        System.out.print(year + "年" + month + "月有" + day + "天");
+    }
+}练习-Java多路分支之月份天数计算
+tymj,1=
+public class EllipseArea {
+    double Short;				//变量名不能用short，short好像会关键字报错，long也是
+    double Long;
+
+    public void EllipseArea(){
+
+    }
+
+    public void EllipseArea(double a,double b){
+        Short = a;
+        Long = b;
+    }
+
+    public double area(double a,double b){
+        double c = Math.PI * a * b;			//椭圆面积 = 长轴长 * 短轴长 * π
+        return c;
+    }
+
+    public static void main(String[] args){
+        EllipseArea a = new EllipseArea();
+        double b = a.area(15.5,20.0);
+        System.out.print("椭圆形的面积为" +String.format("%.2f",b) );
+    }
+}
+
+学习-Java类和对象之构造方法与对象创建之求椭圆面积
+tzsy,1=
+/**
+ * 任务：编写程序，读入投资额、年利率和投资年限，利用题目所给公式计算投资的未来价值
+ * 类名为：Finance
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+
+// 第一步：导入Scanner类
+import java.util.Scanner;
+// 第二步：创建一个名为 Finance 的公开类
+public class Finance {
+// 第三步：定义主方法
+public static void main(String[] arge){
+    Scanner in = new Scanner(System.in);
+// 第四步：在主方法中，根据题目给出的计算投资的未来价值公式来计算未来价值
+double touzi = in.nextDouble();
+double nianli = in.nextDouble();
+int age = in.nextInt();
+double weilai = touzi*(Math.pow((1+(nianli/12)),12*age));
+// 第五步：格式化输出未来价值，结果保留两位小数
+System.out.printf("%.2f",weilai);
+}
+}
+
+
+/********** End **********/
+
+练习- Java顺序结构综合练习三之金融投资收益计算
+wdzh,1=
+/**
+ * 任务：编写一个程序，依次将摄氏温度为 1°、2°、3°、4°、5° 所对应的华氏温度的值四舍五入后保留两位小数输出， 摄氏温度和华氏温度转换公式如下：
+ * fahrenheit（华氏温度） = ( 9/5 ) × celsius（摄氏温度） + 32。
+ * 类名为：Temperature
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 第一步：创建一个名为 Temperature 的公开类
+public class Temperature{
+// 第二步：在这个类中定义主方法
+public static void main(String[] arge){
+// 第三步：在主方法中依次计算摄氏温度为 1°、2°、3°、4°、5° 所对应的华氏温度的值，四舍五入后保留两位小数，最后格式化输出华氏温度的值，例子：摄氏温度为1时，华氏温度为xx。
+double hua1 = (9.0/5.0)*1+32;
+double hua2 = (9.0/5.0)*2+32;
+double hua3 = (9.0/5.0)*3+32;
+double hua4 = (9.0/5.0)*4+32;
+double hua5 = (9.0/5.0)*5+32;
+System.out.printf("摄氏温度为1时，华氏温度为%.2f。\n",hua1);
+System.out.printf("摄氏温度为2时，华氏温度为%.2f。\n",hua2);
+System.out.printf("摄氏温度为3时，华氏温度为%.2f。\n",hua3);
+System.out.printf("摄氏温度为4时，华氏温度为%.2f。\n",hua4);
+System.out.printf("摄氏温度为5时，华氏温度为%.2f。",hua5);
+}
+}
+/********** End **********/练习- Java顺序结构综合练习二之温度换算
+wdzh,1=
+import java.util.Scanner;
+public class StrTest {
+    public static void main(String[] args) {
+	    	// 请在Begin-End间编写代码
+            /********** Begin **********/
+            // 接收给定的摄氏温度
+            Scanner input = new Scanner(System.in);
+            int c = input.nextInt();
+            // 格式化输出对应的华氏温度
+            double f = c * (9 * 1.0 / 5) + 32;
+            System.out.println("摄氏温度" + c + "对应的华氏温度为：" + String.format("%.2f",f));
+			/********** End **********/
+    }
+}练习-Java字符串之String类格式化字符串之温度转化
+xqdjl,1=
+/**
+ * 任务：一小球以 10米/秒 的水平速度平抛，重力加速度取9.8米/秒2，
+ * 在忽略空气阻力的情况下，求经过时间 3 秒后，
+ * 小球所在位置与抛出点之间的距离 (假设小球距地面足够高)。
+ * 类名为：Distance
+ */
+
+public class Distance {
+    public static void main(String[] args) {
+
+
+        double g = 9.8;     // 声明浮点型变量 g，用于表示重力加速度
+        int v0 = 10;      // 声明整型变量 v0, 用于表示水平初速度
+        int t = 3;      // 声明整型变量 t, 用于表示小球飞行的时间
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+        // 第一步：计算水平距离，并赋值给s
+        int s = v0*t;
+        // 第二步：计算垂直距离，并赋值给h
+        double h = 9.8*t*t/2;
+        // 第三步：计算小球与原点的距离，并赋值给d，Math.sqrt()表示的是对括号里的值求平方根
+        double d = Math.sqrt(s*s+h*h);
+        // 第四步：打印出小球与原点的距离d  输出格式：小球所在位置与抛出点之间的距离为 xxx 米。     其中 xxx 为求出的距离
+        System.out.print("小球所在位置与抛出点之间的距离为 "+d+" 米。");
+        /********** End **********/
+
+    }
+}练习-Java顺序结构之无输入求平抛小球与抛出点之间的距离
+xqj,1=
+/**
+ * 任务：2017 年 1 月 1 日是星期天，求 10 天后是星期几。
+ * 类名为：Week
+ */
+
+public class Week {
+    public static void main(String[] args) {
+
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+        // 第一步：声明 int 型变量 pre，值为一周的总天数
+        int pre = 7;
+        // 第二步：声明 int 型变量 sum，值为几天后加上周几（2017 年 1 月 1 日是周几）的值
+        int sum = 7+ 10;
+        // 第三步：求天数除以一周的天数的余数，这个余数就是10天后为周几的值了
+        int day = sum%pre;
+        // 第四步：格式化输出这个值  如果结果是1，那么输出格式为：10天后是星期 1。
+        System.out.print("10天后是星期 " +day+"。");
+        /********** End **********/
+
+    }
+}
+顺序结构之无输入格式化输出求星期几
+
+xs,1=
+package step3;
+ 
+ 
+ 
+public class Student {
+	int id;
+	int age;
+	String name;
+ 
+	public Student(int id, int age, String name) {
+		this.id = id;
+		this.age = age;
+		this.name = name;
+	}
+ 
+	public void increaseAge() {
+		this.age += 1;
+	}
+ 
+	public static void main(String[] args) {
+		// 创建并初始化学生数组
+		Student s1 = new Student(1, 18, "小明");
+		Student s2 = new Student(2, 20, "小张");
+		Student s3 = new Student(3, 19, "小李");
+		Student s4 = new Student(4, 18, "小王");
+		Student s5 = new Student(5, 20, "小赵");
+ 
+		Student s[] = { s1, s2, s3, s4, s5 }; // 给对象数组赋值
+		System.out.println("班级学生名单如下：");
+ 
+		// 显示所有学生信息
+		for (Student student : s) {
+			System.out.println("学号:" + student.id + ",姓名:" + student.name + ",年龄:" + student.age);
+		}
+ 
+		// 将所有学生年龄增加1岁
+		System.out.println("所有学生年龄加 1 后...");
+		for (Student student : s) {
+			student.increaseAge();
+		}
+		for (Student student : s) {
+			System.out.println("学号:" + student.id + ",姓名:" + student.name + ",年龄:" + student.age);
+		}
+ 
+		// 显示所有年龄大于20岁的学生信息
+		int number = 0;
+		for (Student student : s) {
+			if (student.age > 20) {
+				number++;
+			}
+		}
+		System.out.println("大于 20 岁人数是：" + number);
+	}
+}
+编写一个学生类
+xsdx,1=
+import java.util.Scanner;
+public class Student {  
+    private String name;  // 学生的姓名  
+    private String num;  // 学生的学号信息  
+    private double grades;  // 学生的成绩  
+    // 有参构造方法  
+    public Student(String name, String num, double grades) {  
+        this.name = name;  
+        this.num = num;  
+        this.grades = grades;  
+    }  
+    // 获取和设置学生的属性信息  
+    public String getName() {  
+        return name;  
+    }
+    public void setName(String name) {  
+        this.name = name;  
+    }
+    public String getNum() {  
+        return num;  
+    }
+    public void setNum(String num) {  
+        this.num = num;  
+    }
+    public double getGrades() {  
+        return grades;  
+    }
+    public void setGrades(double grades) {  
+        this.grades = grades;  
+    }
+    public static void main(String[] args) {  
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码  
+        /********** Begin **********/  
+        Scanner scanner = new Scanner(System.in);  
+        // 创建可以存放三个对象的对象数组  
+        Student student[] = new Student[3];  
+        // 将数组中的对象进行实例化  
+        for (int i = 0; i < student.length; i++) {  
+            String s = scanner.next();  
+            student[i]=new Student(s.split(",")[0],s.split(",")[1],Double.valueOf(s.split(",")[2]));  
+        }  
+        // 打印输出每个学生的信息  
+        for (int i = 0; i < student.length; i++) {  
+            System.out.printf("姓名：%s\t学号：%s\t成绩：%.1f\n",student[i].getName(),student[i].getNum(),student[i].getGrades());  
+        }  
+        /********** End **********/  
+    }  
+}  练习-Java类和对象之对象数组
+xsl,1=
+/**
+ * 任务：定义一个 Student 学生公开类，该类具有学号 id(int)，年龄 age(int)，grade(int) 等属性；
+ * 它们所具有的行为有学习 study()，考试 examination()，讲话 tell()，它们都无返回值和传入的参数。
+ * 类名为：Student
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+ 
+// 第一步：创建一个名为 Student 的公开类
+public class Student{
+// 第二步：定义学生的属性
+int id=20110624;
+int age=18;
+int grade=12;
+// 第三步：定义学生的行为方法
+public void study(){
+    System.out.println("学号为" + id +"的学生正在学习。");
+}
+public void examination(){
+    System.out.println(grade + "年级正在考试。");
+}
+public void tell(){
+    System.out.println("正在讲话的是一个"+ age +"岁的学生。");
+}
+}
+/********** End **********/学习-Java类和对象之类的声明之学生类的定义
+ycpc,1=
+/*
+任务：接收给定的两个整数（第一个为被除数，第二个为除数），实现以下需求：
+1.求这两个数的商；
+2.当除数为 0 时，不捕获但要避免抛出运行时异常 ArithmeticException。
+程序执行示例：
+输入：5 3
+输出：1
+输入：4 0
+输出：除数不能为0
+ 
+*/
+ 
+import java.util.Scanner;
+ 
+public class ExcTest {
+ 
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 第一步：接收给定的两个整数
+        Scanner input = new Scanner(System.in);
+        int a = input.nextInt();
+        int b = input.nextInt();
+        // 第二步：当除数为0时，避免抛出运行时异常
+        try{
+            int x = a / b;
+        }catch (ArithmeticException e){
+            System.out.println("除数不能为0");
+        }
+        // 第三步：输出两个数的商
+        if (b != 0){
+            System.out.println(a / b);
+        }
+        /********** End **********/
+    }
+}
+ 学习-Java异常处理之RuntimeException之避免异常抛出
+yfjs,1=
+import java.util.Scanner;
+
+/**
+ * 任务：变量 p 为每公里每吨货物的基本运费，
+ * 变量 w 为货物重量，s 为运输距离，d 为折扣，
+ * 根据题目中的总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
+ * 类名为：Logistics
+ */
+
+public class Logistics {
+    public static void main(String[] args) {
+    	Scanner reader = new Scanner(System.in);        
+    	double p = reader.nextDouble();     // 表示每公里每吨货物的基本运费
+    	double w = reader.nextDouble();     // 表示货物重量
+    	double s = reader.nextDouble();     // 运输距离
+    	double d = 0.0;// 折扣
+        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+        /********** Begin **********/
+    	double Exp = 0;
+        // 第一步：判断该运输距离的折扣为多少 如果0 < s < 250，则折扣为0，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
+    		if (s>0&&s<250){
+                Exp = p*w*s*1;
+            }else if (s>=250&&s<500){
+                Exp = p*w*s*(1-0.02);
+            }else if (s>=500&&s<1000){
+                Exp = p*w*s*(1-0.05);
+            }else{
+                Exp = p*w*s*(1-0.08);
+            }
+            System.out.printf("%.2f",Exp);
+    	// 第二步：如果250 ≤ S < 500，则折扣为0.02，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
+
+        // 第三步：如果500 ≤ S < 1000，则折扣为0.05，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
+
+			
+		// 第四步：如果1000 ≤ S，则折扣为0.08，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
+  	
+    	    	
+        /********** End **********/
+
+    }
+}
+练习-Java分支结构综合练习二之物流运费计算
+yh,1=
+package step2;
+ 
+import java.lang.Math;
+ 
+public class Ring {
+    double innerRadius, outerRadius;
+    String color;
+ 
+    public Ring(double innerRadius, double outerRadius, String color) {
+        this.innerRadius = innerRadius;
+        this.outerRadius = outerRadius;
+        this.color = color;
+    }
+ 
+    public double getArea() {
+        return Math.PI * (outerRadius * outerRadius - innerRadius * innerRadius);
+    }
+ 
+    public double getInnerPerimeter() {
+        return 2 * Math.PI * innerRadius;
+    }
+ 
+    public double getOuterPerimeter() {
+        return 2 * Math.PI * outerRadius;
+    }
+    
+    public void setInnerRadius(double innerRadius){
+    	this.innerRadius = innerRadius;
+    }
+    
+    public void setOuterRadius(double outerRadius){
+    	this.outerRadius = outerRadius;
+    }
+    
+    public void setColor(String color){
+    	this.color = color;
+    }
+    
+ 
+    public static void main(String[] args) {
+    	Ring ring = new Ring(5, 8, "red");
+        System.out.printf("圆环的内半径: %.1f\n",ring.innerRadius);
+        System.out.printf("圆环的外半径: %.1f\n",ring.outerRadius);
+        System.out.println("圆环的颜色: "+ring.color);
+        System.out.printf("圆环的面积: %.2f\n",ring.getArea());
+        System.out.printf("圆环的外圆周长: %.2f\n",ring.getOuterPerimeter());
+        System.out.printf("圆环的内圆周长: %.2f\n",ring.getInnerPerimeter());
+        System.out.println();
+        ring.setInnerRadius(4);
+		ring.setOuterRadius(6);
+		ring.setColor("blue");
+		System.out.printf("圆环的内半径: %.1f\n",ring.innerRadius);
+        System.out.printf("圆环的外半径: %.1f\n",ring.outerRadius);
+        System.out.println("圆环的颜色: "+ring.color);
+        System.out.printf("圆环的面积: %.2f\n",ring.getArea());
+        System.out.printf("圆环的外圆周长: %.2f\n",ring.getOuterPerimeter());
+        System.out.printf("圆环的内圆周长: %.2f",ring.getInnerPerimeter());
+		
+        
+ 
+    }
+}
+编写一个圆环类
+
+yhsjx,1=
+/*
+* 任务：从控制台获取输入的正整数n，打印带有n行的杨辉三角形
+* 
+杨辉三角形的特点：
+- 第 n 行有 n 个数字；
+- 每一行的开始和结尾数字都为 1；
+- 从第 3 行起，除去每一行的开始和结尾数字，其余每个数都满足以下条件：任意一个数等于上一行同列和上一行前一列的和，
+如以下杨辉三角形中第 3 行第 2 列中的 2 等于它上一行同列（第 2 行第 2 列中的 1）和上一行前一列（第 2 行第 1 列中的 1）的和。
+以下是有5行的杨辉三角形：
+             1
+           1   1
+         1   2   1
+       1   3   3   1
+     1   4   6   4   1
+*/
+import java.util.Scanner;
+public class Test {
+    public static void main(String[] args) {
+        // 创建Scanner对象
+        Scanner input = new Scanner(System.in);
+        // 获取输入的整数值
+        int n = input.nextInt();
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 第一步：定义外循环打印行数
+        for(int i =0;i<n;i++) {
+            int number = 1;
+        System.out.printf("%"+(n-i)*2+"s","");    
+        // 第二步：定义内循环打印数字，其中数字之间以4位宽度显示，具体样式见预期输出
+            for(int j=0;j<=i;j++) {
+                System.out.format("%4d",number);
+                number = number * (i - j) / (j + 1);
+                           }
+                           System.out.println();
+                    }
+        /********** End **********/
+    }
+}练习-Java循环综合练习三之杨辉三角形
+ywcjtj,1=
+/*
+任务：仔细阅读给出的代码框架及注释，在 Begin-End 间编写程序代码，求班级数学平均成绩，具体要求如下：
+- 接收给定的数据（如：4，88，43，43，98，#...，其中第一个数代表数组长度，
+  其余数代表班级所有人数学成绩，# 号用于终止接收数据），遇到 # 号终止接收；
+- 求班级数学平均成绩，平均成绩用 double 类型表示。
+注意：数字分隔符为中文逗号。
+*/
+import java.util.Scanner;
+ 
+public class ArrTest {
+    public static void main(String[] args) {
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 第一步：接收给定的第一个数，用于定义数组长度
+     Scanner in=new Scanner(System.in);
+int len=in.nextInt();
+int sum=0;
+        // 第二步：定义数组
+int []arry=new int[len];
+        // 第三步：把成绩赋值给数组元素
+ for(int i=0;i<arry.length;i++)
+ {
+	 arry[i]=in.nextInt();
+	 if(in.hasNext("#"))break;
+ }
+        // 第四步：求所有成绩的和
+ for(int i=0;i<arry.length;i++)
+ {
+	  sum=sum+arry[i];
+ }
+        // 第五步：求平均成绩
+     // double avg=sum/arry.length;
+    //  System.out.print("数学平均成绩为："+avg);这两行需要理解；
+     System.out.print("数学平均成绩为："+(double)sum/arry.length);
+        /********** End **********/
+    }
+}学习-Java数组之一维数值数组之成绩统计
+yxyz,1=
+import java.util.Scanner;
+public class StrTest {
+    public static void main(String[] args) {
+
+        
+        Scanner scanner = new Scanner(System.in);
+
+        String filename = scanner.nextLine();
+        String email = scanner.nextLine();
+
+        int beginIndex = filename.lastIndexOf(".");         //获取最后一个点出现的位置
+
+        if(beginIndex != -1){
+            //substring（）方法：从第beginIndex下标截取，截取到末尾，返回lastName，然后直接用equals方法判断是否相等.java
+           String lastName = filename.substring(beginIndex,filename.length());
+
+
+            if(beginIndex != 0 && lastName.equals(".java")){
+                System.out.println("Java文件名正确");
+            }else{
+                System.out.println("Java文件名无效");
+            }
+        }else{
+            System.out.println("Java文件名无效");
+        }
+
+//lastIndexOf（）方法， 获取字符串出现的位置，可以返回一个int类型
+        int atIndex = email.lastIndexOf("@");         //获取最后一个@出现的位置
+        int pointIndex = email.lastIndexOf(".");      //获取最后一个.出现的位置
+        if(atIndex != -1 && atIndex < pointIndex){
+            System.out.print("邮箱名正确");
+        }else{
+            System.out.println("邮箱名无效");
+        }
+
+    }   
+}        // Scanner sc = new Scanner(System.in);
+   
+练习-Java字符串之String类常用方法之文件名与邮箱验证
+yzmj,1=
+class Circle{
+    static final double PI = Math.PI;
+    double r;           //底面半径
+
+    public Circle(double r){
+        this.r = r;
+    }
+
+    double area(){
+        double a = PI * r * r;
+        return a;
+    }
+}
+//扇形类
+class Sector {
+    double l;          //母线
+    static final double PI = Math.PI;
+    double r;
+
+    public Sector(double l,double r) {
+        this.l = l;
+        this.r = r;
+    }
+
+    double area() {   //圆锥侧面积
+        double s = PI * r * l;
+        return s;
+    }
+}
+//公开圆锥类
+class Cone{
+    Circle circle;
+    Sector sector;
+    public Cone(Circle circle,Sector sector){
+        this.circle = circle;
+        this.sector = sector;
+    }
+    double area(){    //圆锥表面积
+        double s = circle.area() + sector.area();
+        return s;
+    }
+
+    public static void main(String[] args) {
+        Circle circle = new Circle(8);      //圆对象
+        Sector sector = new Sector(8,15);     //扇形对象
+        Cone cone = new Cone(circle,sector);
+        double s = cone.area();
+
+        System.out.printf("圆锥的表面积为%.2f",s);
+
+    }
+}
+
+练习-Java类和对象之对象组合之求圆锥体表面积
+yzsjx,1=
+import java.util.Scanner;
+
+public class Triangle {
+
+
+    static void judge(double a,double b,double c){
+        if(a + b > c && a + c > b && c + b > a){
+            System.out.print("这三条边可以构成三角形");
+        }else{
+            System.out.print("这三条边不能构成三角形");
+        }
+    }
+    
+
+
+    // 定义主方法
+    public static void main(String[] args){
+        Scanner sc = new Scanner(System.in);
+        double a = sc.nextDouble();
+        double b = sc.nextDouble();
+        double c = sc.nextDouble();
+        judge(a,b,c);
+    }
+  
+}
+
+练习-Java类和对象之static关键字之检验三边是否构成三角形
+yztj,1=
+/**
+ * 任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。
+ */
+ 
+ 
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+ 
+/********** Begin **********/
+ 
+// 定义一个圆类，类名为 Circle
+class  Circle
+{
+    double r;
+    double pi=Math.PI;
+     Circle(double r1)
+     {
+         r=r1;
+     }
+     double area()
+     {
+        return (double)r*r*pi;
+     }
+}
+ 
+    // 定义两个量，分别为半径和π值
+ 
+ 
+    // 有参构造器
+ 
+ 
+ 
+    // 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
+ 
+ 
+// 定义一个公开的圆柱类 Cylinder
+public class Cylinder
+{
+    double h;
+    Cylinder(double height)
+    {
+        h=height;
+    }
+    double tiji(double area)
+    {
+        return area*h;
+    }
+ 
+ 
+ 
+    // 定义圆柱中的高
+ 
+    // 引用圆类
+ 
+ 
+    // 有参构造
+ 
+ 
+    /**
+     * 定义一个方法，该方法实现计算圆柱的体积，返回值为double
+     */
+ 
+    
+    // 定义主方法
+    public static void main(String[] args) {
+        // 通过有参构造创建圆对象，将底面半径设置为 20
+Circle c1=new Circle(20);
+        // 通过有参构造创建圆柱对象，将圆柱的高设置为 50，将圆对象传入
+ Cylinder c2=new  Cylinder(50);
+    // 调用计算圆柱积的方法
+System.out.printf("圆柱的体积为%.2f",c2.tiji(c1.area()));
+    // 四舍五入格式化不换行输出圆柱的体积，输出格式：圆柱的体积为xx
+    }
+}
+/********** End **********/学习-Java类和对象之对象组合之求圆柱体积
+zcj,1=
+// 请在Begin-End间编写代码
+/********** Begin **********/
+import java.util.Scanner;
+// 第一步：创建ExcTest类
+public class ExcTest {
+    public static void main(String[] args) throws Exception {
+        // 第二步：接收给定一行字符串
+        Scanner input = new Scanner(System.in);
+        String str = input.nextLine();
+        // 第三步：切割字符串
+        String[] array = str.split(" ");
+        int sum = 0;
+        // 第四步：遍历字符串中各科成绩，当成绩大于100或者小于0时，抛出异常，提示“成绩录入异常”
+        for (String i:array){
+            int score = Integer.parseInt(i);
+            if (score > 100 | score < 0){
+                throw new Exception("成绩录入异常");
+            }
+            sum += score;
+        }
+        // 第五步：当所有成绩处于0-100之间时，输出总成绩
+        System.out.println("该学生总成绩为：" + sum);
+    }
+}
+/********** End **********/
+ 练习-Java异常处理之throw之学生总成绩
+zfccd,1=
+/*
+任务：接收输入值（字符串），将该字符串反转输出，例如接收字符串"abc"，输出"cba"。
+*/
+
+import java.util.Scanner;
+
+public class StrTest {
+    public static void main(String[] args) {
+
+            Scanner sc = new Scanner(System.in);
+            String str = sc.next();
+            
+            char[] chars = str.toCharArray();   //将字符串转换为字符数组
+
+            for (int i = (str.length()) - 1; i >= 0; i--){  // 根据字符串长度判断i的范围
+                System.out.print(chars[i]);                 //逆向打印字符数组
+            }
+    }
+}
+学习-Java字符串之String类常用方法之字符串长度
+zfcpj,1=
+import java.util.Random;
+import java.util.Scanner;
+
+public class StrTest {
+
+    public static void main(String[] args) {
+
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+        // 第一步：接收给定的两个字符串，第一个为名字，第二个为姓氏
+
+        Scanner input = new Scanner(System.in);
+        String str1 = input.next();
+        String str2 = input.next();
+        // 第二步：拼接姓氏和名字
+        String str = str2.concat(str1);
+        // 第三步：输出姓名
+        System.out.println(str);
+        /********** End **********/
+
+    }
+}
+学习-Java字符串之String类并置运算之字符串拼接
+zfcxd,1=
+/*
+任务：
+1.使用字符串常量引用赋值创建以下两个字符串
+字符串1：World
+字符串2：world
+2.使用equals和==比较这两个字符串是否相等
+3.输出比较结果
+*/
+
+public class StrTest {  
+    public static void main(String[] args) {  
+        // Begin  
+  
+        // 第一步：使用字符串常量引用赋值创建给定的两个字符串  
+        String string1 = "World";  
+        String string2 = "world";  
+  
+        // 第二步：分别使用==和equals比较创建的两个字符串是否相等，并输出比较结果  
+        // 使用==比较  
+        System.out.println("使用==比较的结果：" + (string1 == string2)); // 这里会输出 false，因为它们是两个不同的引用  
+  
+        // 使用 equals 比较  
+        System.out.println("使用equals比较的结果：" + string1.equals(string2)); // 这里也会输出 false，因为内容不相同（区分大小写）  
+  
+        // 如果你想检查不区分大小写的相等性，可以使用 equalsIgnoreCase 方法  
+        // 这里会输出 true，因为内容相同（忽略大小写）  
+  
+        // End  
+    }  
+}练习- Java字符串之String类创建字符串之使用equals和==判断字符串是否相等
+zfssl,1=
+import java.util.Scanner;
+ 
+public class ForeachTest {
+    public static void main(String[] args) {
+       
+        // 请在Begin-End间编写代码
+        /********** Begin **********/
+		// 接收给定一行整数
+	Scanner input=new Scanner(System.in);
+    int n = input.nextInt();	
+		// 创建数组  
+    int[] a= new int[n];
+        // 把给定整数添加到数组中
+    for(int i=0;i<a.length;i++){
+        a[i] =input.nextInt();
+    }   
+        // 获取数组中的每个数，统计正负数个数
+    int fu=0,zheng=0;
+    for(int i=0;i<a.length;i++){
+        if(a[i]<0){
+            fu++;
+        }
+        else zheng++;
+    }
+        // 输出结果
+    System.out.println("正数个数："+zheng+"。负数个数："+fu+"。"); 
+        /********** End **********/
+ 
+    }
+}学习-Java数组之foreach遍历数组之正负数数量统计
+zhgpa,1=
+import java.util.Scanner;
+
+/**
+ * 任务：给出一个 GPA 成绩，输出与之对应的百分制成绩区间。
+ */
+public class ApplicationTest {
+
+    /**
+     * 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        // 声明 char 类型的变量 score 用来获取控制台输入的成绩
+        char score = scanner.next().charAt(0);
+        /********** Begin **********/
+        switch (score){
+            case 'A' :
+            System.out.print("百分制分数段为90分以上");
+            break;
+            case 'B' :
+            System.out.print("百分制分数段为80-89分");
+            break;
+            case 'C' :
+            System.out.print("百分制分数段为70-79分");
+            break;
+            case 'D' :
+            System.out.print("百分制分数段为60-69分");
+            break;
+            case 'E' :
+            System.out.print("百分制分数段为60分以下");
+            break;
+        }
+        /**
+         * 使用 switch 构建 A 、B、C、D、E 五条分支
+         *      分支 A ，控制台输出 “百分制分数段为90分以上”
+         *      分支 B ，控制台输出 “百分制分数段为80-89分”
+         *      分支 C ，控制台输出 “百分制分数段为70-79分”
+         *      分支 D ，控制台输出 “百分制分数段为60-69分”
+         *      分支 E ，控制台输出 “百分制分数段为60分以下”
+         */
+
+
+    
+        /********** End **********/
+    }
+}
+
+学习-Java多路分支之switch之百分制成绩转换GPA成绩
+zhlx,1=
+
+/**
+ * 按照动物、宠物、猫和蜘蛛的关系，通过编程实现各自的关系并声明自己的属性和方法。
+ */
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 创建Animal类，它是所有动物的抽象父类
+abstract class Animal {
+    // 声明一个受保护的字符串类型属性type，它记录动物的种类
+    protected String type;
+    // 声明一个受保护的整数类型属性legs，它记录动物的腿的数目
+    protected int legs;
+    // 定义一个受保护的有参构造器，用来初始化type和legs属性
+    protected Animal(String type,int legs){
+        this.type = type;
+        this.legs = legs;
+    }
+    // 声明抽象方法eat，无返回值
+    public abstract void eat();
+    // 声明具体方法walk来打印动物是如何行走的（包括腿的数目）。
+    // 输出格式：用 xx 条腿走路
+    public void walk(){
+        System.out.println(type +"用 " + legs +  " 条腿走路");
+    }
+}
+// 定义蜘蛛类 Spider继承Animal类
+class Spider extends Animal{
+    // 定义默认构造器，它调用父类构造器来指明动物类别是spider，且所有蜘蛛都是8条腿。
+    public Spider(){
+        super("spider",8);
+    }
+    // 实现eat方法，输出：spider eating
+    public void eat() {
+        System.out.println("spider eating");
+    }
+}
+// 创建pet（宠物）接口
+interface Pet {
+    // 提供setName(String name) 为该宠物命名
+    public void setName(String name);
+    // 提供getName() 返回该宠物的名字，返回类型为String
+    public String getName();
+    // 提供 play()方法，无返回值
+    public void play();
+}
+// 定义公开的猫类 Cat 继承动物类并实现宠物接口
+public class Cat extends Animal implements Pet{
+    // 定义一个name属性来存宠物的名字
+    private String name;
+    // 定义一个有参构造器，它使用String参数指定猫的名字
+    // 该构造器必须调用超类构造器来指明动物种类是cat，且所有的猫都是四条腿
+    public Cat(String name){
+        super("cat",4);
+        this.name = name;
+    }
+    // 另定义一个无参的构造器。该构造器调用前一个构造器（用this关键字）并传递一个空字符串作为参数
+    public Cat(){
+        this("");
+    }
+    // 实现 Pet接口的方法
+    // 设置猫的名称
+
+    public void setName(String name) {
+        this.name = name;
+    }
+    // 获取猫的名称
+
+    public String getName() {
+        return name;
+    }
+    // 重写 Animal 类的play()，输出：Cat is playing
+    public void play() {
+        System.out.println("Cat is playing");
+    }
+    // 重写 Animal 类的eat()，输出：xx eating
+    // xx 表示姓名
+    public void eat() {
+        System.out.println(name+" eating");
+    }
+}
+/********** End **********/
+练习-Java继承和多态之综合练习
+zljcx,1=
+/**
+ * 任务：定义一个 Dog 类，继承 Animal 类，定义自己的性别属性，并定义获取和设置性别属性的方法和 sleep 方法。
+ * 类名为：Dog
+ */
+ 
+// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
+/********** Begin **********/
+// 定义一个Dog的公开类，并继承Animal类
+ 
+    //定义小狗的性别sex，字符串类型
+ 
+ 
+    // 定义获取和设置小狗性别的方法。
+public class Dog extends Animal
+{
+    public String sex;
+    public Dog(String type, String name, int age)
+    {
+        super(type,name,age);
+    }
+ 
+public void setSex(String sex)
+{
+    this.sex=sex;
+}
+ 
+public void sleep()
+{
+    System.out.print("一只名为"+getName()+"性别为"+sex+"的小狗，现在"+getAge()+"岁，它正在睡觉");
+}
+}
+ 
+ 
+    //定义小狗的睡觉方法，实现输出：一只名为xx性别为xx的小狗，现在xx岁，它正在睡觉
+ 
+学习-Java继承和多态之子类继承性
+zmpx,1=
+public class Transpose {
+    public static void main(String[] args) {
+        // 定义二维数组并初始化
+        char[][] a = {{'d','v','g','r'},{'h','s','r','a'},{'q','e','t','z'},{'o','p','d','s'}};
+        // 请在Begin-End间编写代码        
+        /********** Begin **********/
+        // 第一步：排序，从第一个元素开始，依次取每个元素与该元素之后的每个元素比较大小
+        for (int i = 0; i < a.length; i++) {     // 二维数组的长度
+            for (int j = 0; j < a[i].length; j++) {     // 每个一维数组的长度
+                int n = j + 1;
+                for (int m = i; m < a.length; m++) {     // 排序
+                    for (; n < a[i].length; n++) {
+                        if (a[i][j] < a[m][n]) {
+                            char max = a[m][n];
+                            a[m][n] = a[i][j];
+                            a[i][j] = max;
+                        }
+                    }
+                    n = 0;     // 此处是给n从第二个一维数组开始取0这个坐标
+                }
+            }
+        }
+        // 第二步：输出排序后的数组
+        for (int i = 0; i < a.length; i++) {
+            for (int j = 0; j < a[i].length; j++) {
+                System.out.print(a[i][j] + " ");
+            }
+            System.out.println();
+        }
+        /********** End **********/
+        }
+}学习-Java数组之二维字符数组之按字母序排序
+zzfc,1=
+import java.util.Scanner;
+import java.util.StringTokenizer;
+public class StrTest {
+    public static void main(String[] args) {
+// 请在Begin-End间编写代码
+/********** Begin **********/
+// 第一步：接收输入的字符串
+        Scanner sc = new Scanner(System.in);
+        String s = sc.next();
+        StringTokenizer stringtokenizer = new StringTokenizer(s,",");
+        String[] a = new String[stringtokenizer.countTokens()+1];
+        String[] b = new String[stringtokenizer.countTokens()+1];
+        int i=0,j=0,k=0;
+        while (stringtokenizer.hasMoreTokens()){
+            a[i] = stringtokenizer.nextToken();
+            i++;
+        }
+        while (j!=i){
+            boolean matches = a[j].matches("^a.*li.*z$");
+            if(matches){
+                b[k] = a[j];
+                k++;
+            }
+            j++;
+        }
+        for(i=0;i<k;i++){
+            //System.out.println(b[i]);
+            System.out.println("将符合条件的子字符串转化为小写："+b[i].toLowerCase());
+            System.out.println("将符合条件的子字符串转化为大写："+b[i].toUpperCase());
+        }
+        if(k!=0) System.out.println("字符串中共有符合条件的子字符串"+k+"个");
+        else System.out.println(s+"该字符串没有符合条件的子字符串");
+// 第二步：对字符串做指定操作操作
+ 
+/********** End **********/
+    }
+}练习-Java字符串之String类常用方法之满足条件的子字符串
+ClassOne,1=
+package step1;
+//请在此添加实现代码
+/********** Begin **********/
+public class ThreadClassOne extends Thread {
+ public void run() {
+ for (int i = 1; i <= 10; i += 2) {
+ System.out.print(i + " ");
+ }
+ }
+}创建线程ClassOne.java 程序 
+/********** End **********/
+ClassTwo,1=
+package step1;
+//请在此添加实现代码
+/********** Begin **********/
+public class ThreadClassTwo implements Runnable {
+ public void run() {
+ for (int i = 0; i <= 10; i += 2) {
+ System.out.print(i + " ");
+ }
+ }
+}创建线程ClassTwo.java 程序 
+/********** End **********/
+String,1=
+package step1;
+
+public class StringExample {
+    public static void main(String args[]) {
+        String s1 = new String("you are a student");
+        String s2 = new String("how are you");
+        // 使用equals方法判断s1与s2是否相同
+        if (s1.equals(s2)) {
+            System.out.println("s1与s2相同");
+        } else {
+            System.out.println("s1与s2不相同");
+        }
+        String s3 = new String("13971918888");
+        // 判断手机号是否以“139”开头
+        if (s3.startsWith("139")) {
+            System.out.println("手机号以139开头");
+        }
+        String s4 = new String("你"), s5 = new String("我");
+        // 按着字典序s4大于s5的表达式
+        if (s4.compareTo(s5) > 0) {
+            System.out.println("按字典序s4大于s5");
+        } else {
+            System.out.println("按字典序s4小于s5");
+        }
+        /******************************************************/
+        int position = 0;
+        String path = "d:\\java\\A.java";
+        // 获取path中最后出现\\的位置
+        position = path.lastIndexOf("\\");
+        System.out.println(path + "中最后出现\\的位置为: " + position);
+        // 利用字符串截取方法获取path中“A.java”子字符串
+        String fileName = path.substring(path.lastIndexOf("\\") + 1);
+        System.out.println(path + "中含有的文件名为: " + fileName);
+        /******************************************************/
+        String s6 = new String("100");
+        String s7 = new String("123.678");
+        // 将s6转化成int型数据
+        int n1 = Integer.parseInt(s6);
+        // 将s7转化成double型数据
+        double n2 = Double.parseDouble(s7);
+        double m = n1 + n2;
+        System.out.println(n1 + " + " + n2 + " 的和为: " + m);
+        // String类调用valueOf(double n)方法将m转化为字符串对象
+        String s8 = String.valueOf(m);
+        position = s8.indexOf(".");
+        // 利用字符串截取方法获取s8中小数点后面的小数
+        String temp = s8.substring(position + 1);
+        System.out.println("数字" + m + "有" + temp.length() + "位小数");
+        String s9 = new String("ABCDEF");
+        // 将s9存放到数组a中
+        char a[] = s9.toCharArray();
+        System.out.print(s9 + " 逆序字符输出为: ");
+        for (int i = a.length - 1; i >= 0; i--) {
+            System.out.print(" " + a[i]);
+        }
+    }
+}
+String类的常用方法
+
+第1关：通过Thread类创建线程
+package step1;
+import java.lang.Thread;
+
+public class MyThread extends Thread {
+	private int num;//任务就是在子线程中计算num的阶乘
+	
+	public MyThread() {
+		this(0);
+	}
+	
+	//constructor，创建实例的时候初始化参数
+	public MyThread(int num) {
+		/***begin your code here***/ 
+		this.num = num;
+		/***end your code***/
+	}
+	
+    @Override
+    public void run() {    	
+    	//重写run方法，在子线程中想要执行的代码写在run方法中
+    	int result = 1;//result保存计算出的结果
+    	
+        /***begin your code here***/ 
+		for(int i = num; i>=1;i--){
+			result = result*i;
+		}
+		/***end your code***/
+    	
+    	//直接输出结果
+    	System.out.println(result);
+    }
+}
+
+第2关：通过Runnable接口创建线程
+package step2;
+
+public class MyRunnable implements Runnable {
+	private int num;
+	
+    public MyRunnable() {
+    	this(0);
+    }
+    
+    public MyRunnable(int num) {
+    	/***begin your code here***/
+    	this.num = num;
+    	/***end your code here***/
+    }
+	
+	@Override
+	public void run() {
+		//重写run方法，在子线程中想要执行的代码写在run方法中
+    	int result = 1;//result保存计算出的结果
+    	
+        /***begin your code here***/ 
+		for(int i = num; i>=1;i--){
+			result = result*i;
+		}
+		/***end your code***/
+    	
+    	//直接输出结果
+    	System.out.println(result);
+	}
+
+}
+
+第3关：使用匿名Thread和Runnable对象创建线程
+package step3;
+
+/**
+ * 模拟一个工具类，该类不用来实例化，只提供各种静态函数
+ * @author Administrator
+ *
+ */
+public class ThreadHelper {
+	/**
+	 * 在子线程中计算参数的阶乘并输出
+	 * @param num
+	 */
+    static public void calcOnNewThread(int num) {
+    	//使用Thread匿名对象以及Runnable匿名对象创建并执行子线程
+    	new Thread(new Runnable() {
+    	    @Override public void run() {
+    	    	int result = 1;
+    	    	/***begin your code here***/ 
+    			for(int i = num; i>=1;i--){
+				result = result*i;
+				}
+    			/***end your code***/
+    	    	//直接输出
+    	    	System.out.println(result);
+    	    }		
+    	}).start();
+    }
+    
+    /**
+     * 使用一个私有的构造器，防止该类被实例化
+     */
+    private ThreadHelper() {
+    	throw new UnsupportedOperationException(this.getClass().getSimpleName() + " can not be instantiated.");
+    }
+}
+第4关：Thread创建综合
+package step4;
+
+//注意文件名，这里应该写MyRunnable类
+/***begin your code here***/
+class MyRunnable implements Runnable{
+    int num;
+    public MyRunnable(int num){
+        this.num = num;
+    }
+    public void run(){
+        int result = 1;
+    try{
+         Thread.sleep(200);
+    }
+    catch(InterruptedException e){
+        System.out.print("");
+    }
+       
+        for(int i = num; i>=1;i--){
+			result = result*i;
+		}
+        
+        System.out.println(result);
+    }
+}
+/***end your code***/
+
+第1关：创建线程
+package step1;
+//请在此添加实现代码
+//使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下：1 3 5 7 9；
+/********** Begin **********/
+public class ThreadClassOne extends Thread { //创建一个类来继承Thread类
+    public void run(){ //重写父类的run 方法
+        for(int i=0;i<=10;i++){
+            if(i%2 == 1)
+                System.out.print(i+" ");
+            }
+        }
+}
+ 
+//使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-10之间的偶数，输出结果如下：0 2 4 6 8 10
+class ThreadClassTwo implements Runnable{
+    public void run(){
+        for(int i=0;i<=10;i++){
+            if(i%2==0) 
+                System.out.print(i+" ");
+        }
+    }
+}
+/********** End **********/
+第1关：InetAddress类
+package step1;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class InetAddressExample {
+    public static void main(String[] args) throws UnknownHostException {
+        // ---------------------Begin------------------------
+        // 获取两个东西：主机名，IP地址
+        // 获取主机名
+        InetAddress localHost = InetAddress.getLocalHost();
+        String hostName = localHost.getHostName();
+        System.out.println("主机名： " + hostName);
+        // 获取IP地址
+        InetAddress[] allByName = InetAddress.getAllByName(hostName);
+        for (int i = 0; i < allByName.length; i++) {
+            System.out.println("IP地址" + (i + 1) + ": " + allByName[i].getHostAddress());
+        }
+        // ---------------------End------------------------
+    }
+}
+学习-Java输入输出之InputStream类之字节数据
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定文件路径
+        Scanner Scanner = new Scanner(System.in);
+        String s = Scanner.nextLine();
+        // 创建字节输入流对象
+         try(
+             InputStream input = new FileInputStream(s)){
+             int n = 0;
+            
+        // 读取文件，并将内容转换为字符输出
+           while((n=input.read())!=-1){
+               System.out.print((char)n);
+             }
+        }  
+        /********** End **********/
+    }
+}
+学习-Java输入输出之OutputStream类之字节数
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定字符串
+        Scanner input = new Scanner(System.in);
+        String str = input.next();
+        // 切割字符串
+        String[] string= str.split("，");
+        String a = string[0];
+        String path = string[1];
+        // 创建FileOutputStream对象
+        OutputStream fos = new FileOutputStream(path);
+        // 写入数据
+        byte[] b = a.getBytes();
+        fos.write(b);
+        try{
+            fos.close();
+        }catch (Exception e){
+            
+        }
+        /********** End **********/
+    }
+}
+练习-Java输入输出之字节数据输入输出之综合练
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 使用字节输出流和输入流，把给定文件里的内容复制到另一个给定文件中
+        Scanner input = new Scanner(System.in);
+        String str1 = input.next();
+        String str2 = input.next();
+        FileInputStream fileInputStream = new FileInputStream(str1);
+        FileOutputStream fileOutputStream1 = new FileOutputStream(str2);
+        int len;
+        while ((len = fileInputStream.read()) != -1){
+            fileOutputStream1.write(len);
+        }
+        fileInputStream.close();
+        fileOutputStream1.close();
+        /********** End **********/
+    }
+}
+第1关：学习-Java输入输出之Reader类之字符数据输入
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 定义变量
+        int len;
+        // 接收给定字符串
+        Scanner input = new Scanner(System.in);
+        String str = input.next();
+        // 创建Reader对象
+        Reader reader = new FileReader(str);
+        // 打印字符
+        for (;;){
+            len = reader.read();
+            if (len == -1){
+                break;
+            }
+            System.out.print((char)len);
+        }
+        reader.close();
+        /********** End **********/
+}
+}
+1关：学习-Java输入输出之Writer类之字符数据输出
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定字符串
+        Scanner input = new Scanner(System.in);
+        String string = input.next();
+        // 切割字符串
+        String[] str = string.split("，");
+        // 创建FileWriter对象
+        Writer writer = new FileWriter(str[0]);
+        // 向文件中写入字符流
+        writer.write(str[1]);
+        writer.flush();
+        /********** End **********/
+        try{
+            writer.close();
+        }catch (Exception e){
+ 
+        }
+    }
+}
+第1关：学习-Java输入输出之File类之获取文件信息
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定字符串
+        Scanner sc = new Scanner(System.in);
+        String s = sc.next();
+        // 创建文件对象
+		File f = new File(s);
+        // 如果字符串是文件，获取文件名并输出文件大小
+        if(f.isFile()){
+            String name = f.getName();
+            System.out.println(name);
+            long length = f.length();
+            System.out.println(length);
+        // 如果字符串是目录，输出该目录下的所有文件
+        }else if(f.isDirectory()){
+            String[] list = f.list();
+            System.out.println(Arrays.toString(list));
+        // 如果字符串既不是文件，又不是目录，输出提示语句：“非法字符串”
+        }else{
+            System.out.println("非法字符串");
+        }
+        
+        /********** End **********/
+    }
+}
+第1关：练习-Java输入输出之文件字节IO流之合并文件
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        
+        Scanner scanner = new Scanner(System.in);     // 获取给定字符串
+        String s = scanner.nextLine();
+        
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 切割给定字符串，得到子文件目录和目标文件名
+        String[] array = s.split("，");
+        // 循环读取子文件内容，写入到目标文件
+        File file1 = new File(array[0]);
+        File file2 = new File(array[1]);
+        FileOutputStream fileOutputStream = new FileOutputStream(file2);
+        for (int i = 1; i < file1.listFiles().length; i ++){
+            FileInputStream fileInputStream = new FileInputStream(array[0] + "/" + array[1] + "-" + i);
+            int len = 0;
+            while((len = fileInputStream.read()) != -1)
+                fileOutputStream.write(len);
+        }
+        fileOutputStream.close();
+        // 输出目标文件大小
+        System.out.println("最后目标文件的大小：" + file2.length() + "字节");
+        FileReader fileReader = new FileReader(array[1]);
+        int lenx = 0;
+        while((lenx = fileReader.read()) != -1){
+            System.out.print((char)lenx);
+        }
+        fileReader.close();
+        
+        /********** End **********/
+ 
+    }
+}
+第1关：Java输入输出之文件字符IO流之文件加密
+import java.io.*;
+import static java.lang.Character.isLetterOrDigit;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+		// 接收给定字符串，获取相关路径
+		Scanner input = new Scanner(System.in);
+        String str = input.nextLine();
+        String[] array = str.split("，");
+        // 读取源文件
+        File file1 = new File(array[0]);
+        char[] chars = new char[Math.toIntExact(file1.length())];
+        try(
+                FileReader fileReader = new FileReader(file1);) {
+            fileReader.read(chars);
+        }
+        // 加密
+		for (int i = 0; i < chars.length; i ++){
+            chars[i] = (char) Encryption(chars[i]);
+        }
+        // 把加密后的内容保存到目标文件
+        File file2 = new File(array[1]);
+        try(
+                FileWriter fileWriter = new FileWriter(file2);) {
+            fileWriter.write(chars);
+        }
+    }
+ 
+        // 定义加密方法
+        public static int Encryption(int len){
+        if ((len >= '0' & len < '9') | (len >= 'a' & len < 'z') | (len >= 'A' & len < 'Z')){
+            return len + 1;
+        }else if (len == '9'){
+            return len - 9;
+        }else if (len == 'z' | len == 'Z'){
+            return len - 25;
+        }else {
+            return len;
+        }
+    }
+        /********** End **********/
+ 
+}
+第1关：学习-Java输入输出之字节缓冲IO流之复制文件
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        Scanner input = new Scanner(System.in);     // 获取给定字符串
+        String str = input.nextLine();
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 切割给定字符串，切割给定字符串，获取源文件路径和目标文件路径
+        String[] array = str.split("，");
+        InputStream inputStream = new FileInputStream(array[0]);
+        OutputStream outputStream = new FileOutputStream(array[1]);
+        File file = new File(array[0]);
+        // 创建缓冲流对象，实现文件复制
+        byte[] bytes = new byte[Math.toIntExact(file.length())];
+        try (
+                BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);){
+            while (bufferedInputStream.read(bytes) != -1);
+        }
+        try (
+                BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);) {
+                bufferedOutputStream.write(bytes);
+        }
+        // 输出目标文件长度
+        System.out.println("文件长度：" + file.length());
+        // for (int i = 0; i < bytes.length; i ++){
+        //     System.out.print((char) bytes[i]);
+        // }
+        /********** End **********/
+    }
+}
+第1关：练习-Java输入输出之文件字符IO流之文件解密
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 接收给定字符串
+        Scanner input = new Scanner(System.in);
+        String str = input.nextLine();
+        String[] array = str.split("，");
+        // 读取源文件
+        File file1 = new File(array[0]);
+        char[] chars = new char[Math.toIntExact(file1.length())];
+        try(
+                FileReader fileReader = new FileReader(file1);) {
+            fileReader.read(chars);
+        }
+		// 打印源文件中的内容	
+        System.out.println("解密前的内容：");
+        for (int i = 0; i < chars.length; i ++){
+            System.out.print(chars[i]);
+        }
+        System.out.println();
+        // 进行解密
+        for (int i = 0; i < chars.length; i ++){
+            chars[i] = (char) Deciphering(chars[i]);
+        }
+        // 把解密后的内容保存到目标文件，并输出解密后的内容
+        File file2 = new File(array[1]);
+        try (
+                FileWriter fileWriter = new FileWriter(file2);) {
+            fileWriter.write(chars);
+        }
+        System.out.println("解密后的内容：");
+        for (char i : chars){
+            System.out.print(i);
+        }
+    }
+ 
+ 
+        // 把解密后的内容保存到目标文件，并输出解密后的内容
+        // 定义解密方法
+        public static int Deciphering(int len){
+        if ((len >= '1' & len <= '9') | (len > 'a' & len <= 'z') |       (len > 'A' & len <= 'Z')){
+            return len - 1;
+        }else if (len == '0'){
+            return len + 9;
+        }else if (len == 'a' | len == 'A'){
+            return len + 25;
+        }else {
+            return len;
+        }
+    }
+}
+练习-Java输入输出之字节缓冲IO流之字节缓存流的高性能
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Scanner;
+ 
+public class StudentTest {
+    Scanner input = new Scanner(System.in);     // 获取给定文件字符串
+	String str = input.next();
+ 
+    public Long bufferStream() throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 使用缓冲流读取给定文件，并返回读取时间
+        byte[] bytes = new byte[8];
+        try (
+                BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(str));){
+            long t1 = System.currentTimeMillis();
+            while (bufferedInputStream.read(bytes) != -1);
+            long t2 = System.currentTimeMillis();
+            bufferedInputStream.close();
+            return t2 - t1;
+        }
+        /********** End **********/
+ 
+    }
+    public Long inputStream() throws IOException{
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 使用文件字节流读取给定文件，并返回读取时间
+        byte[] bytes = new byte[8];
+        try (
+                FileInputStream fileInputStream = new FileInputStream(str);){
+            long t1 = System.currentTimeMillis();
+            while (fileInputStream.read(bytes) != -1);
+            long t2 = System.currentTimeMillis();
+            fileInputStream.close();
+            return t2 - t1;
+        }
+        /********** End **********/
+    }
+}
+学习-Java输入输出之字符缓冲IO流之往文件中插入分隔符
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        Scanner scanner = new Scanner(System.in);     // 接收字符串
+        String next = scanner.nextLine();
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 切割字符串
+        String[] str = next.split("，");
+        // 复制源文件内容到目标文件，并在每一行之间插入分隔符
+        BufferedReader bufferedReader = new BufferedReader(new FileReader(str[0]));
+        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(str[1]));
+        String str1 = null;
+        while((str1 = bufferedReader.readLine()) != null){
+            bufferedWriter.write(str1);
+            bufferedWriter.newLine();
+            bufferedWriter.write(str[2]);
+            bufferedWriter.newLine();
+        }
+        bufferedReader.close();
+        bufferedWriter.close();
+        /********** End **********/
+    }
+}
+练习-Java输入输出之字符缓冲IO流之移除文件中的注释
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        Scanner scanner = new Scanner(System.in);
+        String javaFile = scanner.next();
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 读取文件内容
+        File file = new File(javaFile);
+        StringBuffer stringBuffer = new StringBuffer();
+        try (
+                FileReader fileReader = new FileReader(file);
+                BufferedReader bufferedReader = new BufferedReader(fileReader);){
+            String str = null;
+            while ((str = bufferedReader.readLine()) != null){
+                if (str.trim().startsWith("//")){
+                    continue;
+                }
+                stringBuffer.append(str).append("\r\n");
+            }
+        }
+        // 输出去除注释后的文件长度
+        try (
+                FileWriter fileWriter = new FileWriter(javaFile);
+                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);){
+            bufferedWriter.write(stringBuffer.toString());
+        }
+        System.out.print("文件长度：" + file.length());
+ 
+        /********** End **********/
+    }
+}
+练习-Java输入输出之随机IO流之向文件中指定位置添加内容
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {       
+        Scanner scanner = new Scanner(System.in);    // 接收给定字符串
+        String str = scanner.nextLine();
+		// 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 切割字符串
+        String[] strs= str.split("，");
+        // 创建一个临时文件
+        File tem=new File(strs[0]);
+		// 将插入点之后的内容保存到临时文件
+        RandomAccessFile raf = new RandomAccessFile(tem,"rw");
+        //设置指针位置
+        raf.seek(Long.parseLong(strs[1]));
+        //读取指针后面的字符数并返回
+        byte[] by=new byte[1024]; 
+        int len =raf.read(by);
+               
+        //上面读取后指针位置发生移动，再次设置指针位置
+        raf.seek(Long.parseLong(strs[1]));
+        // System.out.println();
+        //先写入指定字符，在写人前面读取的s并指定写入长度，防止空格
+        raf.write(strs[2].getBytes());
+        raf.write(by,0,len);
+ 
+        raf.close();
+        // 将给定的内容和临时文件中的内容依次追加到原文件的插入点后
+           
+        /********** End **********/
+ 
+    }
+}
+练习-Java输入输出之数组IO流之将给定整数转换为字符写入到给定文件中
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        // 请在此编写代码
+        /********** Begin **********/
+        // 接收给定数据，将字节整数转化为字符，
+        Scanner input = new Scanner(System.in);
+        String[] array = new String[100];
+        int i = 0;
+        while (!input.hasNext("%")){
+            array[i] = input.next();
+            i ++;
+        }
+        // 并使用ByteArrayOutputStream将其写入到给定文件中（字符为a的除外）
+        try (
+                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+                FileOutputStream fileOutputStream = new FileOutputStream(array[0]);
+                ){
+            for (int j = 1; j < i; j ++){
+                if (Integer.parseInt(array[j]) == 'a'){
+                    continue;
+                }
+                byteArrayOutputStream.write(Integer.parseInt(array[j]));
+            }
+            byte[] bytes = byteArrayOutputStream.toByteArray();
+            fileOutputStream.write(bytes);
+        }
+        /********** End **********/
+    }
+}
+习-Java输入输出之数据IO流之把文件中内容转为大写后写入另一个文件
+import java.io.*;
+import java.util.Arrays;
+import java.util.Scanner;
+ 
+public class FileTest {
+ 
+    public static void main(String[] args) throws IOException {
+        // 接收给定的一行字符串
+        Scanner scanner = new Scanner(System.in);
+        String line = scanner.nextLine();
+ 
+        // 请在此编写代码
+        /********** Begin **********/
+        
+        // 切割字符串，获取源文件目录和目标文件目录
+        String[] strs = line.split("，");
+        File file1 = new File(strs[0]);
+        File file2 = new File(strs[1]);
+        BufferedReader fis = new BufferedReader(new FileReader(file1));
+        BufferedWriter fos = new BufferedWriter(new FileWriter(file2));
+        // 将源文件中的前三行内容转为大写后写入到目标文件中
+        for(int i=0;i<3;i++){
+             String str = fis.readLine();
+             fos.write(str.toUpperCase());
+             System.out.println(str.toUpperCase());
+             fos.newLine();
+        }
+        /********** End **********/
+        fis.close();
+        fos.close();
+ 
+    }
+}
+练习-Java输入输出之字节数据输入输出之综合练习
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 使用字节输出流和输入流，把给定文件里的内容复制到另一个给定文件中
+        Scanner input = new Scanner(System.in);
+        String str1 = input.next();
+        String str2 = input.next();
+        FileInputStream fileInputStream = new FileInputStream(str1);
+        FileOutputStream fileOutputStream1 = new FileOutputStream(str2);
+        int len;
+        while ((len = fileInputStream.read()) != -1){
+            fileOutputStream1.write(len);
+        }
+        fileInputStream.close();
+        fileOutputStream1.close();
+        /********** End **********/
+    }
+}
+学习-Java输入输出之Reader类之字符数据输入
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 定义变量
+        int len;
+        // 接收给定字符串
+        Scanner input = new Scanner(System.in);
+        String str = input.next();
+        // 创建Reader对象
+        Reader reader = new FileReader(str);
+        // 打印字符
+        for (;;){
+            len = reader.read();
+            if (len == -1){
+                break;
+            }
+            System.out.print((char)len);
+        }
+        reader.close();
+        /********** End **********/
+}
+}
+第1关：什么是封装，如何使用封装
+package case1;
+ 
+public class TestPersonDemo {
+	public static void main(String[] args) {
+		/********* begin *********/
+		// 声明并实例化一Person对象p
+        Person p = new Person();
+		// 给p中的属性赋值
+        p.Set("张三",18);
+		// 调用Person类中的talk()方法
+        p.talk();
+ 
+		/********* end *********/
+	}
+}
+// 在这里定义Person类
+class Person {
+	/********* begin *********/
+    private String name;
+    private int age;
+    public void talk(){
+        System.out.println("我是："+this.name+"，今年："+this.age+"岁");
+    }
+    public void Set(String name,int age){
+        this.name = name;
+        this.age = age;
+    }
+ 
+	/********* end *********/
+}
+
+第2关：什么是继承，怎样使用继承
+package case2;
+ 
+public class extendsTest {
+	public static void main(String args[]) {
+		// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
+		/********* begin *********/
+        Cat cat=new Cat();
+        cat.Set("大花猫",6);
+        cat.putName(); cat.voice();
+        System.out.println();
+        cat.putName();cat.eat();
+        System.out.println();
+        cat.putName();cat.putAge();
+        System.out.println();
+ 
+		/********* end *********/
+ 
+// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
+		/********* begin *********/
+        Dog dog=new Dog();
+        dog.Set("大黑狗",8);
+        dog.putName(); dog.voice();
+        System.out.println();
+        dog.putName();dog.eat();
+        System.out.println();
+        dog.putName();dog.putAge();
+        System.out.println();
+ 
+		/********* end *********/
+	}
+}
+ 
+class Animal {
+	/********* begin *********/
+    private String name;
+    private int age;
+    public void Set(String name,int age){
+        this.name=name;
+        this.age=age;
+    }
+    public void putName(){
+        System.out.print(this.name);
+    }
+    public void putAge(){
+        System.out.print(this.age+"岁");
+    }
+ 
+	/********* end *********/
+ 
+}
+ 
+class Cat extends Animal {
+	// 定义Cat类的voice()和eat()方法
+	/********* begin *********/
+ 
+    public void voice(){
+        System.out.print("喵喵叫");
+    }
+    public void eat(){
+        System.out.print("吃鱼");
+    }
+ 
+	/********* end *********/
+}
+ 
+class Dog extends Animal {
+	// 定义Dog类的voice()和eat()方法
+	/********* begin *********/
+    public void voice(){
+        System.out.print("汪汪叫");
+    }
+    public void eat(){
+        System.out.print("吃骨头");
+    }
+ 
+	/********* end *********/
+}
+第3关：方法的重写与重载
+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 *********/
+    String name;
+    int age;
+    public void talk(){
+        System.out.println("我是："+name+"，今年："+age+"岁");
+    }
+ 
+	/********* end *********/
+}
+ 
+class Student extends Person {
+	/********* begin *********/
+    String school;
+    public Student(String n,int a,String sch){
+        this.name=n;
+        this.age=a;
+        this.school=sch;
+    }
+    public void talk(){
+        System.out.println("我是："+name+"，今年："+age+"岁，我在"+school+"上学");
+    }
+ 
+	/********* end *********/
+}
+第4关：抽象类
+package case5;
+ 
+public class abstractTest {
+	public static void main(String[] args) {
+		/********* begin *********/
+		// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
+		Student s=new Student("张三",20,"学生");
+        Worker w=new Worker("李四",30,"工人");
+		// 分别调用各自类中被复写的talk()方法 打印信息。
+		s.talk();
+        w.talk();
+		/********* end *********/
+		
+	}
+}
+ 
+// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
+abstract class Person {
+	/********* begin *********/
+    String name;
+    int age;
+    String occupation;
+    abstract public void talk();
+ 
+	/********* end *********/
+}
+ 
+// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
+class Student extends Person {
+	/********* begin *********/
+    public Student(String n,int a,String o){
+        this.name=n;
+        this.age=a;
+        this.occupation=o;
+    }
+    public void talk(){
+        System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
+    }
+ 
+	/********* end *********/
+}
+ 
+// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
+class Worker extends Person {
+	/********* begin *********/
+    public Worker(String n,int a,String o){
+        this.name=n;
+        this.age=a;
+        this.occupation=o;
+    }
+    public void talk(){
+        System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
+    }
+ 
+	/********* end *********/
+}
+第5关：接口
+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 *********/
+    final String name="张三";
+    final int age=18;
+    final String occupation="学生";
+    abstract public void talk();
+ 
+	/********* end *********/
+}
+ 
+// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
+class Student implements Person {
+	/********* begin *********/
+    public void talk(){
+        System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
+    }
+ 
+	/********* end *********/
+}
+
+第6关：什么是多态，怎么使用多态
+package case8;
+ 
+public class TestPolymorphism {
+	public static void main(String[] args) {
+		// 以多态方式分别实例化子类对象并调用eat()方法
+		/********* begin *********/
+        Dog dog=new Dog();
+        Cat cat=new Cat();
+        Lion lion=new Lion();
+        dog.eat();
+        cat.eat();
+        lion.eat();
+ 
+		/********* end *********/
+	}
+}
+// Animal类中定义eat()方法
+class Animal {
+	/********* begin *********/
+    public void eat(){
+        System.out.print("...");
+ 
+    }
+ 
+	/********* 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关：顺序输出
+package step1;
+ 
+public class Task {
+	public static void main(String[] args) throws Exception {
+		/********* Begin *********/
+		//在这里创建线程， 开启线程
+        Object a = new Object();
+		Object b = new Object();
+		Object c = new Object();
+        /*其中，MyThread是一个自定义的线程类，而"AA"、"BB"和"CC"是线程的名称，a、b和c是三个共享资源。
+在创建th1时，传递了三个参数，分别是线程名称、a和c，表示这个线程需要访问a和c这两个共享资源。
+同样的，创建th2时，传递了三个参数，分别是线程名称、c和b，表示这个线程需要访问c和b这两个共享资源。
+创建th3时，传递了三个参数，分别是线程名称、b和a，表示这个线程需要访问b和a这两个共享资源。
+整个代码的意思是，在三个线程之间共享a、b和c这三个资源，每个线程需要访问两个资源，但是访问的顺序是不同的。具体的执行过程需要参考MyThread类的实现。*/
+        MyThread th1 = new MyThread("AA", a, c);
+		MyThread th2 = new MyThread("BB", c, b);
+		MyThread th3 = new MyThread("CC", b, a);
+        // 分别启动三个线程，并在每个线程启动后暂停10毫秒
+        th1.start();
+		Thread.sleep(10);
+		th2.start();
+		Thread.sleep(10);
+		th3.start();
+		Thread.sleep(10);
+        // 结束程序
+		System.exit(0);
+		/********* End *********/
+	}
+}
+ 
+class MyThread extends Thread {
+	/********* Begin *********/
+    // 定义了三个成员变量：线程名，Object类型的对象a和b
+	String threadName;
+	Object a = null;
+	Object b = null;
+    // 定义了一个构造方法，传入线程名和a、b对象
+	public MyThread(String threadName, Object a, Object b) {
+		super();
+		this.threadName = threadName;
+		this.a = a;
+		this.b = b;
+	}
+ 
+	public synchronized void run() {// 重写了Thread类中的run方法
+ 
+		int count = 5;	// 定义了一个计数器count，初始值为5
+        // 当计数器count大于0时，循环执行以下操作
+		while (count > 0) {
+			synchronized (a) { // 先获取a对象的锁
+				synchronized (b) {// 再获取b对象的锁
+					System.out.println("Java Thread" + this.threadName);// 输出线程名
+					count--; // 计数器count减1
+					b.notify();// 唤醒等待b对象锁的线程
+ 
+				}
+				try {
+					a.wait();// 释放a对象锁，并将该线程阻塞
+				} catch (InterruptedException e) {// TODO 自动生成的 catch 块
+					e.printStackTrace();// 如果有中断异常，则打印异常信息
+				}
+			}
+		}
+ 
+	}
+	/********* End *********/
+}
+练习-Java输入输出之字节数据输入输出之综合练习
+import java.io.*;
+import java.util.Scanner;
+ 
+public class FileTest {
+    public static void main(String[] args) throws IOException {
+        // 请在Begin-End间编写完整代码
+        /********** Begin **********/
+        // 使用字节输出流和输入流，把给定文件里的内容复制到另一个给定文件中
+        Scanner input = new Scanner(System.in);
+        String str1 = input.next();
+        String str2 = input.next();
+        FileInputStream fileInputStream = new FileInputStream(str1);
+        FileOutputStream fileOutputStream1 = new FileOutputStream(str2);
+        int len;
+        while ((len = fileInputStream.read()) != -1){
+            fileOutputStream1.write(len);
+        }
+        fileInputStream.close();
+        fileOutputStream1.close();
+        /********** End **********/
+    }
+}
+第2关：字节流-输入输出
+package step2;
+ 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+ 
+public class Task {
+	
+	public void task() throws IOException{
+		/********* Begin *********/
+		File file1 = new File("src/step2/input/task.txt");
+		InputStream fs = new FileInputStream(file1);
+		byte[] b1 = new byte[1024];
+		fs.read(b1);
+        String str1 = new String(b1, "utf-8");
+		System.out.print(str1);
+		fs.close();
+ 
+		File file = new File("src/step2/output");
+		if(!file.exists()){
+			file.mkdir();
+		}
+		String file2 = "src/step2/output/output.txt";
+		OutputStream out = new FileOutputStream(file2);
+		String str2 = "learning practice";
+		byte[] b2 = str2.getBytes(); //字符转化成字节
+		out.write(b2);
+		out.flush(); //刷新缓冲区数据（类似保存数据）
+		out.close();
+		/********* End *********/
+	}
+	
+}
+第3关：字符流 - 输入输出
+package step3;
+ 
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+ 
+public class Task {
+	
+	public void task() throws IOException{
+		/********* Begin *********/
+		String file1 = "src/step3/input/input.txt";   //创建文件
+		FileReader fr = new FileReader(file1);
+		char[] cbuf = new char[1024];//定义一个1K的字符数组
+		fr.read(cbuf);//将文件的数据读到数组中
+        /*FileReader fr = new FileReader(file1);   //实例化
+		char[] ch = new char[8];  //创建数组
+		fr.read(ch);              //将文件的数据读入到数组中（从前到后）这点特别需要注意一下下*/
+        String file2 = "src/step3/output/output.txt";//创建新的文件
+        FileWriter fw = new FileWriter(file2);//将其实例化
+        fw.write(cbuf); // 读入数组中的数据到文件中（从后到前）
+        fr.close();   //输入关闭流
+        fw.flush();   //输出刷新流
+        fw.close();   //输出关闭流
+		/********* End *********/		
+	}
+}
+第4关复制文件
+package step4;
+ 
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+ 
+public class Task {
+	
+	public void task() throws IOException{
+		/********* Begin *********/
+		//复制文本，字符流更快
+        FileReader fr = new FileReader("src/step4/input/input.txt");//创建文件并将其实例化
+        int len = 0;
+		char[] cbuf = new char[1024];
+ 
+		FileWriter fw = new FileWriter("src/step4/output/output.txt");//创建文件将其实例化
+		while((len = fr.read(cbuf)) != -1){//读入从左往右依次判断
+			fw.write(cbuf, 0, len);//读出从右往左，读入需要的数据
+		}
+ 
+		fr.close();//关闭输入流
+		fw.close();//关闭写入流
+		//复制图片字节流，更广泛
+		FileInputStream fs = new FileInputStream("src/step4/input/input.jpg");//同样将其创实例
+		FileOutputStream fos = new FileOutputStream("src/step4/output/output.jpg");//创建实例
+ 
+		int len1 = 0;
+		byte[] b = new byte[1024];
+ 
+		while((len1 = fs.read(b)) != -1){//从左到右
+			fos.write(b, 0, len1);//从右到左
+		}
+ 
+		fs.close();
+		fos.close();
+		
+		/********* End *********/		
+	}
+}
+测试输入： 泰迪 male brown 波斯猫 male 2.5 预期输出： 名称：泰迪，性别：male，颜色：brown，汪汪叫 泰迪吃骨头！ 名称：波斯猫，性别：male，体重：2.5kg，喵喵叫 波斯猫吃鱼！
+
+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
+		/********* 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 *********/
+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 *********/
+}
+测试输入：
+张三
+男
+20
+史蒂文
+男
+22
+预期输出：
+姓名：张三，性别：男，年龄：20，我是中国人，我喜欢吃饭!
+姓名：史蒂文，性别：男，年龄：22，我是英国人，我喜欢吃三明治!
+张三在练习太极拳!
+史蒂文在练习骑马！
+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 person){
+    person.eat();
+}
+	/********* end *********/
+}
+ 
+// 抽象类Person 封装属性name、sex和age
+// 构造函数初始化name、sex和age
+// 声明抽象方法eat()
+abstract class Person {
+	/********* begin *********/
+private String name;
+private String sex;
+private int age;
+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 int getage(){
+    return age;
+}
+public void setage(int age){
+    this.age=age;
+} 
+public Person (String name,String sex,int age){
+    this.name=name;
+    this.sex=sex;
+    this.age=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){
+    super(name,sex,age);
+    sex=super.getname();
+    name=super.getname();
+    age=super.getage();
+}
+public void eat(){
+    System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是中国人，我喜欢吃饭！");
+}
+public void shadowBoxing(){
+    System.out.println(super.getname()+"在练习太极拳！");
+}
+	/********* 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){
+    super(name,sex,age);
+    sex=super.getname();
+    name=super.getname();
+    age=super.getage();
+}
+public void eat(){
+    System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是英国人，我喜欢吃三明治！");
+}
+public void horseRiding(){
+    System.out.println(super.getname()+"在练习骑马！");
+}
+	/********* end *********/
+}
+测试输入：
+张继科
+30
+易建联
+31
+刘国梁
+42
+杜锋
+37
+package case3;
+ 
+import java.util.Scanner;
+ 
+public class Task3 {
+	public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		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);
+        System.out.println(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);
+        System.out.println(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);
+        System.out.println(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);
+        System.out.println(bcName+"---"+bcAge);
+        bc.sleep();
+        bc.eat();
+        bc.teach();
+		/********* end *********/
+		System.out.println("----------------");
+	}
+}
+ 
+// 说英语接口 声明抽象方法speak()
+interface SpeakEnglish {
+	/********* begin *********/
+    void speak();
+	/********* end *********/
+}
+ 
+// 定义人的抽象类Person 封装name和age
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 定义具体方法sleep() 输出'人都是要睡觉的'
+// 抽象方法eat()（吃的不一样）
+abstract 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 Person(String name,int age){
+        this.name=name;
+        this.age=age;
+    }
+    public void sleep(){
+        System.out.println("人都是要睡觉的");
+    }
+    abstract void eat();
+	/********* end *********/
+}
+ 
+// 定义运动员Player（抽象类）继承自Person类
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
+abstract class Player extends Person {
+	/********* begin *********/
+    public Player(String name,int age){
+        super(name,age);
+        name=super.getname();
+        age=super.getage();
+    }
+    abstract void study();
+	/********* end *********/
+}
+ 
+// 定义教练Coach（抽象类）继承自Person类
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 教练教的不一样 定义抽象方法teach()
+abstract class Coach extends Person {
+	/********* begin *********/
+    public Coach(String name,int age){
+        super(name,age);
+        name=super.getname();
+        age=super.getage();
+    }
+    abstract void teach();
+	/********* end *********/
+}
+ 
+// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
+// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
+// 实现自己的speak()方法 输出'乒乓球运动员说英语'
+class PingPangPlayer extends Player implements SpeakEnglish {
+	/********* begin *********/
+    public PingPangPlayer(String name,int age){
+        super(name,age);
+        name=super.getname();
+        age=super.getage();
+    }
+    public void eat(){
+        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
+    }
+    public void study(){
+        System.out.println("乒乓球运动员学习如何发球和接球");
+    }
+    public void speak(){
+        System.out.println("乒乓球运动员说英语");
+    }
+	/********* end *********/
+}
+ 
+// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
+// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
+class BasketballPlayer extends Player {
+	/********* begin *********/
+    public BasketballPlayer(String name,int age){
+        super(name,age);
+        name=super.getname();
+        age=super.getage();
+    }
+    public void eat(){
+        System.out.println("篮球运动员吃牛肉，喝牛奶");
+    }
+    public void study(){
+        System.out.println("篮球运动员学习如何运球和投篮");
+    }
+	/********* end *********/
+}
+ 
+// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
+// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
+// 实现自己的speak()方法 输出'乒乓球教练说英语'
+class PingPangCoach extends Coach implements SpeakEnglish {
+	/********* begin *********/
+    public PingPangCoach(String name,int age){
+        super(name,age);
+        name=super.getname();
+        age=super.getage();
+    }
+    public void eat(){
+        System.out.println("乒乓球教练吃小白菜，喝大米粥");
+    }
+    public void teach(){
+        System.out.println("乒乓球教练教如何发球和接球");
+    }
+    public void speak(){
+        System.out.println("乒乓球教练说英语");
+    }
+	/********* end *********/
+}
+ 
+// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
+// 无参构造函数
+// 有参构造函数初始化name和age
+// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
+// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
+class BasketballCoach extends Coach {
+	/********* begin *********/
+    public BasketballCoach(String name,int age){
+        super(name,age);
+        name=super.getname();
+        age=super.getage();
+    }
+    public void eat(){
+        System.out.println("篮球教练吃羊肉，喝羊奶");
+    }
+    public void teach(){
+        System.out.println("篮球教练教如何运球和投篮");
+    }
+	/********* end *********/
+}
+ 
\ No newline at end of file