diff --git a/新建 文本文档.txt b/新建 文本文档.txt
deleted file mode 100644
index c90fd89..0000000
--- a/新建 文本文档.txt	
+++ /dev/null
@@ -1,2572 +0,0 @@
-三元运算符
-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 **********/    
-    }
-}
-文件二
-
-```lua
-/********** 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 *********/		
-	}
-}