From 73ad990aa3cad4b1fe2730cfe25565759866aa9b Mon Sep 17 00:00:00 2001
From: pbftx924k <1850975767@qq.com>
Date: Wed, 5 Jun 2024 21:54:31 +0800
Subject: [PATCH] =?UTF-8?q?Delete=20'=E6=96=B0=E5=BB=BA=20=E6=96=87?=
 =?UTF-8?q?=E6=9C=AC=E6=96=87=E6=A1=A3.txt'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 新建 文本文档.txt | 7770 ---------------------------------------
 1 file changed, 7770 deletions(-)
 delete mode 100644 新建 文本文档.txt

diff --git a/新建 文本文档.txt b/新建 文本文档.txt
deleted file mode 100644
index fa9f51e..0000000
--- a/新建 文本文档.txt	
+++ /dev/null
@@ -1,7770 +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 *********/		
-	}
-}
-
-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类的常用方法
\ No newline at end of file