|
|
三元运算符
|
|
|
package step4;
|
|
|
import java.util.Scanner;
|
|
|
public class TestYear {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc=new Scanner(System.in);
|
|
|
int year=sc.nextInt();
|
|
|
boolean result;
|
|
|
/********start********/
|
|
|
result=(year%400==0)? true : false;
|
|
|
result=(year%4==0&&year%100!=0)? true : false;
|
|
|
System.out.println(year + "年是否为闰年:" + result);
|
|
|
/********end********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
运算符的优先级
|
|
|
package step5;
|
|
|
import java.util.Scanner;
|
|
|
public class TestDemo5 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc=new Scanner(System.in);
|
|
|
System.out.println("输入：");
|
|
|
int m=sc.nextInt();
|
|
|
int n=sc.nextInt();
|
|
|
System.out.println("输出：");
|
|
|
/*****start*****/
|
|
|
System.out.println( (m+n)*2 );
|
|
|
System.out.println( (m-n)%3 );
|
|
|
System.out.println((m-n)/2 + (m+n)*2);
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第 2 章 Java入门之控制结构
|
|
|
Java入门 - 分支结构
|
|
|
第1关：Java分支结构之 if…else
|
|
|
package step2;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloIfStep2 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
/******start******/
|
|
|
System.out.println("请输入学员成绩：");
|
|
|
int score = input.nextInt();
|
|
|
if (score >= 85)
|
|
|
System.out.println("优，非常棒！");
|
|
|
else {
|
|
|
System.out.println("良，下次加油！");
|
|
|
}
|
|
|
/******end******/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第6关：来吧，我是BOSS！
|
|
|
package step5;
|
|
|
import java.util.Scanner;
|
|
|
public class Practice {
|
|
|
final static Scanner sc = new Scanner(System.in); //扫描仪
|
|
|
//第一题
|
|
|
public void first(){
|
|
|
System.out.println("请输入人数：");
|
|
|
int input = sc.nextInt(); //获取输入的数据
|
|
|
/*****start*****/
|
|
|
if (input < 10){
|
|
|
System.out.println("打半场");
|
|
|
}else {
|
|
|
System.out.println("打全场");
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
|
|
|
//第二题
|
|
|
public void second(){
|
|
|
System.out.println("请输入今天星期几：");
|
|
|
int input = sc.nextInt(); //获取输入的数据
|
|
|
/*****start*****/
|
|
|
if (input == 1){
|
|
|
System.out.println("今天吃米饭");
|
|
|
}else if(input == 2){
|
|
|
System.out.println("今天吃牛排");
|
|
|
}else if(input == 3){
|
|
|
System.out.println("今天吃鸡排");
|
|
|
}else{
|
|
|
System.out.println("今天吃红烧肉");
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
|
|
|
//第三题
|
|
|
public void third(){
|
|
|
System.out.println("请输入今天星期几：");
|
|
|
int input = sc.nextInt(); //获取输入的数据
|
|
|
/*****start*****/
|
|
|
switch (input) {
|
|
|
case 1:
|
|
|
System.out.println("今天吃米饭");
|
|
|
break;
|
|
|
case 2:
|
|
|
System.out.println("今天吃牛排");
|
|
|
break;
|
|
|
case 3:
|
|
|
System.out.println("今天吃鸡排");
|
|
|
break;
|
|
|
default :
|
|
|
System.out.println("今天吃红烧肉");
|
|
|
break;
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Java循环结构之do…while循环
|
|
|
package step3;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
int count= 0; //定义变量存储6的倍数出现的次数
|
|
|
/*****start*****/
|
|
|
int i=1;
|
|
|
do{
|
|
|
if(i%6==0){
|
|
|
count++;
|
|
|
i++;
|
|
|
}i++;
|
|
|
}while(i<=100);
|
|
|
/*****end*****/
|
|
|
System.out.println("6的倍数出现的次数为：" + count);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Java循环结构之for循环
|
|
|
package step5;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
System.out.println("请给定一个自然数N：");
|
|
|
//获取输入的整数N
|
|
|
int sum = 1;
|
|
|
/*****start*****/
|
|
|
for(int N = sc.nextInt(); N>0; N--) {
|
|
|
sum=sum*N;
|
|
|
}
|
|
|
/*****end*****/
|
|
|
System.out.println("自然数N的阶乘为" + sum);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for循环的进阶使用-嵌套循环（1）
|
|
|
package step1;
|
|
|
public class ForPractice1 {
|
|
|
public static void test() {
|
|
|
/*****start*****/
|
|
|
for(int i=0;i<10;i++){
|
|
|
for ( int j= 0;j <10; j++){
|
|
|
System.out.print("*");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for循环的进阶使用-嵌套循环（2）
|
|
|
package step2;
|
|
|
public class ForPractice2 {
|
|
|
public static void main(String[] args) {
|
|
|
/*****start*****/
|
|
|
//在这里打印出正三角形
|
|
|
for(int x=0;x<10;x++){
|
|
|
for(int y=0;y<=x;y++){
|
|
|
System.out.print("*");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
System.out.println("————我是华丽的分界线—————");
|
|
|
//在这里打印出倒三角形
|
|
|
for(int x=10;x>0;x--){
|
|
|
for(int y=x;y>0;y--){
|
|
|
System.out.print("*");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}
|
|
|
99乘法表
|
|
|
package step3;
|
|
|
public class ForPractice3 {
|
|
|
public static void main(String[] args) {
|
|
|
/*****start*****/
|
|
|
for(int i=1;i<10;i++){
|
|
|
for(int j=1;j<=i;j++){
|
|
|
System.out.print(j+"*"+i+"="+i*j+"\t");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
综合练习之ATM取款机
|
|
|
package step4
|
|
|
import java.util.Scanner;
|
|
|
public class ForPractice4 {
|
|
|
public static void main(String[] args) {
|
|
|
/*****start*****/
|
|
|
int money = 1000;
|
|
|
int cash = 0;
|
|
|
int isornot = 0;
|
|
|
Scanner input =new Scanner(System.in);
|
|
|
System.out.println("欢迎使用中国人民银行ATM取款机");
|
|
|
do {
|
|
|
System.out.println("输入取款金额：");
|
|
|
cash = input.nextInt();
|
|
|
if(money >=cash)
|
|
|
{
|
|
|
money=money-cash;
|
|
|
}
|
|
|
else {
|
|
|
System.out.println("目前余额："+money+"无法满足您的取款需求！");
|
|
|
continue;
|
|
|
}
|
|
|
System.out.println("剩余金额："+money+"，是否继续（'1'：结束，'2'：继续）：");
|
|
|
isornot=input.nextInt();
|
|
|
if(isornot==1)
|
|
|
{
|
|
|
break;}
|
|
|
}while(money>0);
|
|
|
System.out.println("取款结束！");
|
|
|
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第 3 章 Java入门之数组
|
|
|
Java入门 - 数组基础
|
|
|
数组练习-平均值和最大值
|
|
|
package step3;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int[] scores = new int[sc.nextInt()];
|
|
|
//循环给数组赋值
|
|
|
for(int i = 0 ; i< scores.length;i++){
|
|
|
scores[i] = sc.nextInt();
|
|
|
}
|
|
|
/********** Begin **********/
|
|
|
//在这里计算数组scores的平均值和最大值
|
|
|
float sum = 0;
|
|
|
int max = scores[0];
|
|
|
float avg;
|
|
|
for(int i = 0; i < scores.length; i++){
|
|
|
sum = sum + scores[i];
|
|
|
}
|
|
|
for(int i = 1; i < scores.length; i++){
|
|
|
if(scores[i]>scores[i-1]){
|
|
|
max = scores[i];
|
|
|
}else{
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
avg = sum / scores.length;
|
|
|
System.out.println("平均值："+avg);
|
|
|
System.out.println("最大值："+max);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
二维数组
|
|
|
package step4;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
/********** Begin **********/
|
|
|
int[][] scores = {{92,85},{91,65},{90,33}};
|
|
|
for(int i=0; i<scores.length; i++){ //行循环次数scores.length（每一列的长度）
|
|
|
for(int j=0; j<scores[i].length; j++){ //列循环次数scores[i].length（每一行的长度）
|
|
|
System.out.println(scores[i][j]);
|
|
|
}
|
|
|
//System.out.println();
|
|
|
}
|
|
|
//scores[][] = {{1,2},{1,2},{1,2}}; //是错误的
|
|
|
for(int i=0; i<scores.length; i++){
|
|
|
scores[i][0] = 1;
|
|
|
scores[i][1] = 2;
|
|
|
}
|
|
|
for(int i=0; i<scores.length; i++){ //行循环次数
|
|
|
for(int j=0; j<scores[i].length; j++){ //列循环次数
|
|
|
System.out.println(scores[i][j]);
|
|
|
}
|
|
|
//System.out.println();
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
数组进阶
|
|
|
package step1;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
//动态构建arr1
|
|
|
int[] arr1 = new int[3];
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
for(int i = 0 ; i< arr1.length ; i++){
|
|
|
arr1[i] = sc.nextInt();
|
|
|
}
|
|
|
/********** Begin **********/
|
|
|
//创建数组arr2
|
|
|
int[] arr2 = new int[3];
|
|
|
|
|
|
//使用for循环将arr1的数据复制给arr2
|
|
|
for(int j =0 ; j<arr1.length ; j++){
|
|
|
arr2[j] =arr1[j];
|
|
|
System.out.println(arr2[j]);
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
选择排序
|
|
|
package step4;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
//动态创建数组
|
|
|
int[] arr = new int[sc.nextInt()];
|
|
|
for(int i = 0 ; i< arr.length ; i++){
|
|
|
arr[i] = sc.nextInt();
|
|
|
}
|
|
|
/********** Begin **********/
|
|
|
for (int j = 0; j < arr.length - 1; j++) {
|
|
|
for (int i = j; i < arr.length -1; i++) {
|
|
|
if(arr[j] < arr[i+1]){
|
|
|
int temp = arr[j];
|
|
|
arr[j] = arr[i+1];
|
|
|
arr[i+1] = temp;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
System.out.println(Arrays.toString(arr));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
冒泡排序
|
|
|
package step5;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
//动态创建数组
|
|
|
int[] arr = new int[sc.nextInt()];
|
|
|
for(int i = 0 ; i< arr.length ; i++){
|
|
|
arr[i] = sc.nextInt();
|
|
|
}
|
|
|
/********** Begin **********/
|
|
|
for(int j = 1 ; j< arr.length;j++){
|
|
|
for (int i = 0; i < arr.length -j; i++) {
|
|
|
if(arr[i] > arr[i+1]){
|
|
|
int temp = arr[i];//交换位置
|
|
|
arr[i] = arr[i+1];
|
|
|
arr[i+1] = temp;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
System.out.println(Arrays.toString(arr));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
第 4 章 Java入门之方法
|
|
|
Java入门 - 方法的使用
|
|
|
第2关：掌握无参有返回值方法的调用
|
|
|
package setp7;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
/********** Begin **********/
|
|
|
// 调用calcAvg()方法，并将返回值保存在变量avg中
|
|
|
double avg =calcAvg();
|
|
|
/********** End **********/
|
|
|
System.out.println("平均成绩为：" + avg);
|
|
|
}
|
|
|
// 定义一个返回值为double类型的方法
|
|
|
/********** Begin **********/
|
|
|
public static double calcAvg() {
|
|
|
double java = 92.5;
|
|
|
double php = 83.0;
|
|
|
double avg = (java + php) / 2; // 计算平均值
|
|
|
return avg;
|
|
|
// 使用return返回值
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
掌握有参数无返回值方法的调用
|
|
|
package setp9;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
HelloWorld hello = new HelloWorld();
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int score1 = sc.nextInt(); //第一门成绩
|
|
|
int score2 = sc.nextInt(); //第二门成绩
|
|
|
/********** Begin **********/
|
|
|
// 调用方法，传入两门课程的成绩
|
|
|
hello.calcAvg(score1,score2);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
/*
|
|
|
* 功能：计算两门课程考试成绩的平均分并输出平均分
|
|
|
* 定义一个包含两个参数的方法，用来传入两门课程的成绩
|
|
|
*/
|
|
|
/********** Begin **********/
|
|
|
public static void calcAvg(int score1,int score2){
|
|
|
int avg=(score1+score2)/2;
|
|
|
System.out.print("平均分："+avg);
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
掌握有参数有返回值方法的调用
|
|
|
package step3;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
HelloWorld hello=new HelloWorld();
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int i = sc.nextInt(); //获取第一个输入的整数
|
|
|
int j = sc.nextInt(); //获取第二个输入的整数
|
|
|
int max = hello.getMax(i,j);
|
|
|
/********** Begin **********/
|
|
|
//在这里调用方法获取返回值
|
|
|
System.out.println( i+"和"+j+"比较，最大值是：" + max );
|
|
|
/********** End **********/
|
|
|
}
|
|
|
/*在这里创建getMax方法，以两个整数作为参数，返回两个整数中较大的值*/
|
|
|
/********** Begin **********/
|
|
|
public static int getMax(int i,int j){
|
|
|
if(i>j) return i;
|
|
|
else return j;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
掌握数组作为参数的使用
|
|
|
package setp10;
|
|
|
import java.util.Arrays;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
HelloWorld hello=new HelloWorld();
|
|
|
int[] scores={79,52,98,81};
|
|
|
/********** Begin **********/
|
|
|
//调用方法，传入成绩数组，并获取成绩的个数
|
|
|
int count=hello.sort(scores);
|
|
|
/********** End **********/
|
|
|
System.out.println("共有"+count+"个成绩信息！");
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* 功能：将考试成绩排序并输出，返回成绩的个数
|
|
|
*
|
|
|
*/
|
|
|
/********** Begin **********/
|
|
|
public static int sort( int[] data ){
|
|
|
// 数组从小到大排序处理
|
|
|
for(int i=0;i<data.length-1;i++)
|
|
|
for(int j=i+1;j<data.length;j++){
|
|
|
if(data[i]>data[j])
|
|
|
{
|
|
|
int temp=data[i];
|
|
|
data[i]=data[j];
|
|
|
data[j]=temp;
|
|
|
}
|
|
|
}
|
|
|
// 打印出数组
|
|
|
System.out.print("[");
|
|
|
for(int i=0;i<data.length-1;i++)
|
|
|
System.out.print(data[i]+", ");
|
|
|
System.out.print(data[3]+"]");
|
|
|
System.out.println();
|
|
|
//返回数组中元素的个数
|
|
|
return data.length;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
方法的重载
|
|
|
package setp15;
|
|
|
/**
|
|
|
* @author tangzhiqiang
|
|
|
* @date 2018-04-25 22:31
|
|
|
*/
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
/********** Begin **********/
|
|
|
// 调用无参的方法
|
|
|
print();
|
|
|
// 调用带有一个字符串参数的方法
|
|
|
print("educoder");
|
|
|
// 调用带有一个整型参数的方法
|
|
|
print(666);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
/********** Begin **********/
|
|
|
// 无参print方法的定义
|
|
|
public static void print(){
|
|
|
System.out.println("无参的print方法");
|
|
|
}
|
|
|
// 字符串print方法的定义
|
|
|
public static void print(String name){
|
|
|
System.out.println("带有一个字符串参数的print方法，参数值为："+name);
|
|
|
}
|
|
|
// 整型print方法的定义
|
|
|
public static void print(int id){
|
|
|
System.out.println("带有一个整型参数的print方法，参数值为："+id);
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
|
|
|
第8关：方法通关挑战
|
|
|
package setp17;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
/********** Begin **********/
|
|
|
/**
|
|
|
* 第一题：定义一个方法 接收两个整数类型的参数 a和b，返回两个数的和 返回值类型为int 方法名为：getSum
|
|
|
*/
|
|
|
public static int getSum(int a ,int b){
|
|
|
int sum = a + b;
|
|
|
return sum;
|
|
|
}
|
|
|
/**
|
|
|
* 第二题： 定义一个方法 接收三个double类型参数a，b，c， 返回这三个数的平均值 返回值类型为double 方法名为：getAvg
|
|
|
*/
|
|
|
public static double getAvg(double a ,double b,double c){
|
|
|
double avg = (a + b + c) / 3;
|
|
|
return avg;
|
|
|
}
|
|
|
/**
|
|
|
* 第三题： 定义一个方法 接收两个参数 a 和b 打印a行 b列的一个矩形 不需要返回值 方法名为：printRect
|
|
|
*/
|
|
|
public static void printRect(int a , int b){
|
|
|
for (int i = 1 ; i <= a ;i++) {
|
|
|
for (int k = 1 ; k <= b;k++){
|
|
|
System.out.print("*");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* 第四题：定以一个方法，接收整形数组 为参数 对这个数组进行升序排序 最后输出该数组 不需要返回值 方法名为 sortArr
|
|
|
*/
|
|
|
public static void sortArr(int[] arr){
|
|
|
for(int i = 0; i< arr.length-1;i++){
|
|
|
for(int j = i+1; j< arr.length;j++){
|
|
|
if(arr[i] > arr[j]){
|
|
|
int tmp = arr[i];
|
|
|
arr[i] = arr[j];
|
|
|
arr[j] = tmp;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
for(int i = 0; i< arr.length;i++){
|
|
|
System.out.println(arr[i]);
|
|
|
}
|
|
|
}
|
|
|
/**
|
|
|
* 第五题
|
|
|
* 你只需要实现for 循环括号的内容就可 ，打印语句系统已经给你完成
|
|
|
*/
|
|
|
public static void Print99() {
|
|
|
for (int i = 1 ; i<=9;i++) {
|
|
|
for (int j = 1;j <= i ;j++) {
|
|
|
System.out.print(j + " * " + i + " = " + i * j + "\t");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
第 5 章 Java 面向对象之类和对象
|
|
|
Java面向对象 - 类与对象
|
|
|
第1关：什么是类，如何创建类
|
|
|
|
|
|
package step1;
|
|
|
|
|
|
public class Test {
|
|
|
public static void main(String[] args) {
|
|
|
/********** Begin **********/
|
|
|
//创建Dog对象
|
|
|
//设置Dog对象的属性
|
|
|
Dog wuhuarou = new Dog();
|
|
|
wuhuarou.name = "五花肉";
|
|
|
wuhuarou.color = "棕色";
|
|
|
wuhuarou.variety = "阿拉斯加";
|
|
|
|
|
|
//输出小狗的属性
|
|
|
System.out.println("名字：" +wuhuarou.name+ "，毛色：" +wuhuarou.color + "，品种：" +wuhuarou.variety );
|
|
|
|
|
|
//调用方法
|
|
|
wuhuarou.eat();
|
|
|
wuhuarou.run();
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//在这里定义Dog类
|
|
|
/********** Begin **********/
|
|
|
|
|
|
class Dog{
|
|
|
String name;
|
|
|
String color;
|
|
|
String variety;
|
|
|
void eat(){
|
|
|
System.out.println("啃骨头");
|
|
|
}
|
|
|
void run(){
|
|
|
System.out.println("叼着骨头跑");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
第2关：构造方法
|
|
|
package step2;
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Test {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String name = sc.next();
|
|
|
String sex = sc.next();
|
|
|
/********** Begin **********/
|
|
|
//分别使用两种构造器来创建Person对象
|
|
|
Person person1 = new Person();
|
|
|
|
|
|
Person person2 = new Person(name,sex);
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//创建Person对象，并创建两种构造方法
|
|
|
/********** Begin **********/
|
|
|
class Person{
|
|
|
String name;
|
|
|
String sex;
|
|
|
|
|
|
public Person(){
|
|
|
System.out.println("一个人被创建了");
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public Person(String name, String sex){
|
|
|
this.name = name;
|
|
|
this.sex = sex;
|
|
|
System.out.println("姓名："+name+'，'+"性别："+sex+'，'+"被创建了");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
第4关：This关键字
|
|
|
package step3;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Test {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String name = sc.next();
|
|
|
int age = sc.nextInt();
|
|
|
String sex = sc.next();
|
|
|
Person p = new Person(name,age,sex);
|
|
|
p.display();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class Person{
|
|
|
String name = "张三";
|
|
|
int age = 18;
|
|
|
String sex = "男";
|
|
|
/********** Begin **********/
|
|
|
|
|
|
public Person(String name,int age,String sex){
|
|
|
this(age);
|
|
|
this.name = name;
|
|
|
this.sex = sex;
|
|
|
}
|
|
|
|
|
|
public Person(int age){
|
|
|
this.age = age;
|
|
|
}
|
|
|
|
|
|
public void display(){
|
|
|
String name = "baby";
|
|
|
int age = 45;
|
|
|
String sex = "女";
|
|
|
System.out.println("name：" + this.name);
|
|
|
System.out.println("age：" + this.age);
|
|
|
System.out.println("sex：" + this.sex);
|
|
|
}
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
第5关：类与对象练习
|
|
|
文件一
|
|
|
|
|
|
package step4;
|
|
|
import java.util.Scanner;
|
|
|
public class Test {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String theMa = sc.next();
|
|
|
int quantity = sc.nextInt();
|
|
|
boolean likeSoup = sc.nextBoolean();
|
|
|
/********** Begin **********/
|
|
|
//使用三个参数的构造方法创建WuMingFen对象 取名 f1
|
|
|
WuMingFen f1 = new WuMingFen(theMa, quantity, likeSoup);
|
|
|
//使用两个参数的构造方法创建WuMingFen对象 取名 f2
|
|
|
WuMingFen f2 = new WuMingFen(theMa, quantity);
|
|
|
//使用无参构造方法创建WuMingFen对象 取名 f3
|
|
|
WuMingFen f3 = new WuMingFen();
|
|
|
//分别调用三个类的 check方法
|
|
|
f1.check();
|
|
|
f2.check();
|
|
|
f3.check();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
文件二
|
|
|
|
|
|
/********** Begin **********/
|
|
|
//在这里添加包名 step4
|
|
|
package step4;
|
|
|
//创建类 添加属性和方法
|
|
|
public class WuMingFen{
|
|
|
String theMa = "酸辣";
|
|
|
int quantity = 2;
|
|
|
boolean likeSoup = false;
|
|
|
public WuMingFen() {
|
|
|
likeSoup = true;
|
|
|
}
|
|
|
public WuMingFen(String theMa, int quantity, boolean likeSoup) {
|
|
|
this.theMa = theMa;
|
|
|
this.quantity = quantity;
|
|
|
this.likeSoup = likeSoup;
|
|
|
}
|
|
|
public WuMingFen(String theMa, int quantity) {
|
|
|
this.theMa = theMa;
|
|
|
this.quantity = quantity;
|
|
|
}
|
|
|
public void check(){
|
|
|
System.out.println("面码："+ theMa +"，粉的份量：" + quantity + "两，是否带汤：" + likeSoup );
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
第6关：static关键字
|
|
|
package step5;
|
|
|
|
|
|
public class Test {
|
|
|
/********** Begin **********/
|
|
|
static String name = "楚留香";
|
|
|
static
|
|
|
{
|
|
|
System.out.println("hello educoder");
|
|
|
}
|
|
|
public static void main(String[] args) {
|
|
|
System.out.println("我叫" + name);
|
|
|
study();
|
|
|
}
|
|
|
|
|
|
public static void study(){
|
|
|
System.out.println("我喜欢在educoder上学习java");
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
Java面向对象 - 封装、继承和多态
|
|
|
第1关：什么是封装，如何使用封装
|
|
|
|
|
|
package case1;
|
|
|
public class TestPersonDemo {
|
|
|
public static void main(String[] args) {
|
|
|
/********* begin *********/
|
|
|
// 声明并实例化一Person对象p
|
|
|
Person p = new Person();
|
|
|
// 给p中的属性赋值
|
|
|
p.setName("张三");
|
|
|
p.setAge(18);
|
|
|
// 调用Person类中的talk()方法
|
|
|
p.talk();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
// 在这里定义Person类
|
|
|
class Person {
|
|
|
/********* begin *********/
|
|
|
private String name;
|
|
|
private int age;
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
public int getAge() {
|
|
|
return age;
|
|
|
}
|
|
|
public void setAge(int age) {
|
|
|
this.age = age;
|
|
|
}
|
|
|
void talk() {
|
|
|
System.out.println("我是：" + name + "，今年：" + age + "岁");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第2关：什么是继承，怎样使用继承
|
|
|
package case2;
|
|
|
public class extendsTest {
|
|
|
public static void main(String args[]) {
|
|
|
// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
|
|
|
/********* begin *********/
|
|
|
Cat cat= new Cat();
|
|
|
cat.name="大花猫";
|
|
|
cat.age=6;
|
|
|
cat.voice();
|
|
|
cat.eat();
|
|
|
System.out.println(cat.name+cat.age+"岁");
|
|
|
/********* end *********/
|
|
|
|
|
|
// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
|
|
|
/********* begin *********/
|
|
|
Dog dog= new Dog();
|
|
|
dog.name="大黑狗";
|
|
|
dog.age=8;
|
|
|
dog.voice();
|
|
|
dog.eat();
|
|
|
System.out.println(dog.name+dog.age+"岁");
|
|
|
/********* end *********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class Animal {
|
|
|
/********* begin *********/
|
|
|
protected String name;
|
|
|
protected int age;
|
|
|
|
|
|
public String getName(){
|
|
|
return name;
|
|
|
}
|
|
|
public void setName(String name){
|
|
|
this.name = name;
|
|
|
}
|
|
|
|
|
|
public int getAge(){
|
|
|
return age;
|
|
|
}
|
|
|
public void setAge(int age){
|
|
|
this.age = age ;
|
|
|
}
|
|
|
/********* end *********/
|
|
|
|
|
|
}
|
|
|
|
|
|
class Cat extends Animal {
|
|
|
// 定义Cat类的voice()和eat()方法
|
|
|
/********* begin *********/
|
|
|
public void voice(){
|
|
|
System.out.println(name+"喵喵叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println(name+"吃鱼");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
class Dog extends Animal {
|
|
|
// 定义Dog类的voice()和eat()方法
|
|
|
/********* begin *********/
|
|
|
public void voice(){
|
|
|
System.out.println(name+"汪汪叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println(name+"吃骨头");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
第3关：super关键字的使用
|
|
|
package case3;
|
|
|
public class superTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
|
|
|
/********* begin *********/
|
|
|
Person p= new Person();
|
|
|
p.setName("张三");
|
|
|
p.setAge(18);
|
|
|
p.talk();
|
|
|
Student stu= new Student();
|
|
|
|
|
|
stu.school="哈佛大学";
|
|
|
|
|
|
System.out.println("，学校："+stu.school);
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class Person {
|
|
|
/********* begin *********/
|
|
|
|
|
|
private String name ;
|
|
|
private int age;
|
|
|
|
|
|
public String getName(){
|
|
|
return name;
|
|
|
}
|
|
|
|
|
|
public void setName(String name){
|
|
|
this.name= name;
|
|
|
}
|
|
|
|
|
|
public int getAge(){
|
|
|
return age;
|
|
|
}
|
|
|
|
|
|
public void setAge(int age){
|
|
|
this.age= age;
|
|
|
}
|
|
|
|
|
|
public void talk(){
|
|
|
System.out.print("姓名："+name+"，年龄："+age);
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
class Student extends Person {
|
|
|
/********* begin *********/
|
|
|
public String school;
|
|
|
public String getSchool(){
|
|
|
return school;
|
|
|
}
|
|
|
|
|
|
public void setSchool(String name){
|
|
|
this.school= school;
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
第4关：方法的重写与重载
|
|
|
package case4;
|
|
|
public class overridingTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 实例化子类对象s，调用talk()方法打印信息
|
|
|
/********* begin *********/
|
|
|
Student s=new Student("张三",18,"哈佛大学");
|
|
|
s.talk();
|
|
|
/********* end *********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class Person {
|
|
|
/********* begin *********/
|
|
|
public String name;
|
|
|
public int age;
|
|
|
void talk(){
|
|
|
System.out.println("我是："+name+"，今年："+age+"岁");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
class Student extends Person {
|
|
|
/********* begin *********/
|
|
|
String school;
|
|
|
Student(String name,int age,String school){
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
this.school=school;
|
|
|
}
|
|
|
void talk(){
|
|
|
System.out.println("我是："+name+"，今年："+age+"岁，我在"+school+"上学");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第5关：抽象类
|
|
|
package case5;
|
|
|
public class abstractTest {
|
|
|
public static void main(String[] args) {
|
|
|
/********* begin *********/
|
|
|
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
|
|
|
Student s=new Student("张三",20,"学生");
|
|
|
Worker w=new Worker("李四",30,"工人");
|
|
|
s.talk();
|
|
|
w.talk();
|
|
|
// 分别调用各自类中被复写的talk()方法 打印信息。
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
|
|
|
abstract class Person {
|
|
|
/********* begin *********/
|
|
|
String name;
|
|
|
int age;
|
|
|
String occupation;
|
|
|
abstract void talk();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
|
|
|
class Student extends Person {
|
|
|
/********* begin *********/
|
|
|
Student(String name,int age,String occupation){
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
this.occupation=occupation;
|
|
|
}
|
|
|
void talk(){
|
|
|
System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
|
|
|
class Worker extends Person {
|
|
|
/********* begin *********/
|
|
|
Worker(String name,int age,String occupation){
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
this.occupation=occupation;
|
|
|
}
|
|
|
void talk(){
|
|
|
System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第6关：final关键字的理解与使用
|
|
|
package case6;
|
|
|
public class finalTest {
|
|
|
public static void main(String args[]) {
|
|
|
Bike1 obj = new Bike1();
|
|
|
obj.run();
|
|
|
|
|
|
Honda honda = new Honda();
|
|
|
honda.run();
|
|
|
|
|
|
Yamaha yamaha = new Yamaha();
|
|
|
yamaha.run();
|
|
|
}
|
|
|
}
|
|
|
//不可以修改 final 变量的值
|
|
|
// final方法,不可以重写
|
|
|
//// 不可以扩展 final 类
|
|
|
//请在此添加你的代码
|
|
|
/********** Begin *********/
|
|
|
class Bike1 {
|
|
|
final int speedlimit = 90;
|
|
|
|
|
|
void run() {
|
|
|
speedlimit = 120;
|
|
|
System.out.println("speedlimit=120");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
class Bike2 {
|
|
|
final void run() {
|
|
|
System.out.println("running");
|
|
|
}
|
|
|
}
|
|
|
class Honda extends Bike2 {
|
|
|
void run() {
|
|
|
System.out.println("running safely with 100kmph");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
final class Bike3 {
|
|
|
}
|
|
|
|
|
|
class Yamaha extends Bike3 {
|
|
|
void run() {
|
|
|
System.out.println("running safely with 100kmph");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
第7关：接口
|
|
|
package case7;
|
|
|
public class interfaceTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 实例化一Student的对象s，并调用talk()方法，打印信息
|
|
|
/********* begin *********/
|
|
|
Student s=new Student();
|
|
|
System.out.println(s.talk());
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
|
|
|
interface Person {
|
|
|
/********* begin *********/
|
|
|
final String name="张三";
|
|
|
final int age=18;
|
|
|
final String occupation="学生";
|
|
|
public abstract String talk();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
|
|
|
class Student implements Person {
|
|
|
/********* begin *********/
|
|
|
public String talk() {
|
|
|
return "学生——>姓名：" + this.name + "，年龄：" + this.age + "，职业："
|
|
|
+ this.occupation + "！";
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第8关：什么是多态，怎么使用多态
|
|
|
package case8;
|
|
|
public class TestPolymorphism {
|
|
|
public static void main(String[] args) {
|
|
|
// 以多态方式分别实例化子类对象并调用eat()方法
|
|
|
/********* begin *********/
|
|
|
Animal a=new Dog();
|
|
|
a.eat();
|
|
|
Animal b=new Cat();
|
|
|
b.eat();
|
|
|
Animal c=new Lion();
|
|
|
c.eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
// Animal类中定义eat()方法
|
|
|
abstract class Animal {
|
|
|
/********* begin *********/
|
|
|
abstract void eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Dog类继承Animal类 复写eat()方法
|
|
|
class Dog extends Animal {
|
|
|
/********* begin *********/
|
|
|
public void eat(){
|
|
|
System.out.println("eating bread...");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// Cat类继承Animal类 复写eat()方法
|
|
|
class Cat extends Animal {
|
|
|
/********* begin *********/
|
|
|
public void eat(){
|
|
|
System.out.println("eating rat...");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Lion类继承Animal类 复写eat()方法
|
|
|
class Lion extends Animal {
|
|
|
/********* begin *********/
|
|
|
public void eat(){
|
|
|
System.out.println("eating meat...");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
Java面向对象 - 封装、继承和多态的综合练习
|
|
|
第1关：封装、继承和多态进阶（一）
|
|
|
package case1;
|
|
|
import java.util.Scanner;
|
|
|
public class Task1 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String dogName = sc.next();
|
|
|
String dogSex = sc.next();
|
|
|
String dogColor = sc.next();
|
|
|
String catName = sc.next();
|
|
|
String catSex = sc.next();
|
|
|
double catWeight = sc.nextDouble();
|
|
|
// 通过有参构造函数实例化Dog类对象dog
|
|
|
// dog调用talk()方法
|
|
|
// dog调用eat()方法
|
|
|
/********* begin *********/
|
|
|
Dog dog=new Dog(dogName,dogSex,dogColor);
|
|
|
dog.talk();
|
|
|
dog.eat();
|
|
|
/********* end *********/
|
|
|
// 通过有参构造函数实例化Cat类对象cat
|
|
|
// cat调用talk()方法
|
|
|
// cat调用eat()方法
|
|
|
/********* begin *********/
|
|
|
Cat cat=new Cat(catName,catSex,catWeight);
|
|
|
cat.talk();
|
|
|
cat.eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 抽象类Pet 封装属性name和sex
|
|
|
// 构造函数初始化name和sex
|
|
|
// 声明抽象方法talk()
|
|
|
// 声明抽象方法eat()
|
|
|
abstract class Pet {
|
|
|
/********* begin *********/
|
|
|
String name;
|
|
|
String sex;
|
|
|
public abstract void talk();
|
|
|
public abstract void eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// Dog类继承自Pet类 封装属性color
|
|
|
// 构造函数初始化name、sex和color
|
|
|
// 实现自己的talk()方法和eat()方法
|
|
|
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
|
|
|
// eat()输出'name吃骨头'
|
|
|
class Dog extends Pet {
|
|
|
/********* begin *********/
|
|
|
String color;
|
|
|
public Dog(String name,String sex,String color){
|
|
|
this.name=name;
|
|
|
this.sex=sex;
|
|
|
this.color=color;
|
|
|
}
|
|
|
public void talk(){
|
|
|
System.out.println("名称："+name+"，性别："+sex+"，颜色："+color+"，汪汪叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println(name+"吃骨头！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Cat类继承自Pet类 封装属性weight
|
|
|
// 构造函数初始化name、sex和weight
|
|
|
// 实现自己的talk()方法和eat()方法
|
|
|
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
|
|
|
// eat()输出'name吃鱼'
|
|
|
class Cat extends Pet {
|
|
|
/********* begin *********/
|
|
|
double weight;
|
|
|
Cat(String name,String sex,double weight){
|
|
|
this.name=name;
|
|
|
this.sex=sex;
|
|
|
this.weight=weight;
|
|
|
}
|
|
|
public void talk(){
|
|
|
System.out.println("名称："+name+"，性别："+sex+"，体重："+weight+"kg，喵喵叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println(name+"吃鱼！");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第2关：封装、继承和多态进阶（二）
|
|
|
package case2;
|
|
|
import java.util.Scanner;
|
|
|
public class Task2 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String cName = sc.next();
|
|
|
String cSex = sc.next();
|
|
|
int cAge = sc.nextInt();
|
|
|
String eName = sc.next();
|
|
|
String eSex = sc.next();
|
|
|
int eAge = sc.nextInt();
|
|
|
// 创建测试类对象test
|
|
|
Person test;
|
|
|
// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
|
|
|
Person person1=new Chinese(cName,cSex,cAge);
|
|
|
// 通过showEat()方法调用Chinese的eat()方法
|
|
|
showEat(person1);
|
|
|
// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
|
|
|
Person person2=new English(eName,eSex,eAge);
|
|
|
// 通过showEat()方法调用English的eat()方法
|
|
|
showEat(person2);
|
|
|
/********* begin *********/
|
|
|
/********* end *********/
|
|
|
// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
|
|
|
Chinese d=(Chinese)person1;
|
|
|
d.shadowBoxing();
|
|
|
// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
|
|
|
English e=(English)person2;
|
|
|
e.horseRiding();
|
|
|
/********* begin *********/
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
|
|
|
/********* begin *********/
|
|
|
|
|
|
public static void showEat(Person p){
|
|
|
p.eat();
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// 抽象类Person 封装属性name、sex和age
|
|
|
// 构造函数初始化name、sex和age
|
|
|
// 声明抽象方法eat()
|
|
|
abstract class Person {
|
|
|
/********* begin *********/
|
|
|
public String name;
|
|
|
public String sex;
|
|
|
public int age;
|
|
|
abstract void eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// Chinese类继承自Person类
|
|
|
// 构造函数初始化name、sex和age
|
|
|
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
|
|
|
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
|
|
|
class Chinese extends Person {
|
|
|
/********* begin *********/
|
|
|
public String name;
|
|
|
public String sex;
|
|
|
public int age;
|
|
|
Chinese(String name,String sex,int age){
|
|
|
this.name=name;
|
|
|
this.sex=sex;
|
|
|
this.age=age;
|
|
|
}
|
|
|
void eat(){
|
|
|
System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是中国人，我喜欢吃饭！");
|
|
|
}
|
|
|
void shadowBoxing(){
|
|
|
System.out.println(name+"在练习太极拳！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// English类继承自Person类
|
|
|
// 构造函数初始化name、sex和age
|
|
|
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
|
|
|
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
|
|
|
class English extends Person {
|
|
|
/********* begin *********/
|
|
|
public String name;
|
|
|
public String sex;
|
|
|
public int age;
|
|
|
English(String name,String sex,int age){
|
|
|
this.name=name;
|
|
|
this.sex=sex;
|
|
|
this.age=age;
|
|
|
}
|
|
|
void eat(){
|
|
|
System.out.println("姓名："+name+"，性别："+sex+"，年龄："+age+"，我是英国人，我喜欢吃三明治！");
|
|
|
}
|
|
|
void horseRiding(){
|
|
|
System.out.println(name+"在练习骑马！");
|
|
|
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第3关：封装、继承和多态进阶（三）
|
|
|
package case3;
|
|
|
import java.util.Scanner;
|
|
|
public class Task3 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String pppName = sc.next();
|
|
|
int pppAge = sc.nextInt();
|
|
|
String bpName = sc.next();
|
|
|
int bpAge = sc.nextInt();
|
|
|
String ppcName = sc.next();
|
|
|
int ppcAge = sc.nextInt();
|
|
|
String bcName = sc.next();
|
|
|
int bcAge = sc.nextInt();
|
|
|
// 测试运动员(乒乓球运动员和篮球运动员)
|
|
|
// 乒乓球运动员
|
|
|
// 通过带参构造函数实例化PingPangPlayer对象ppp
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、study()、speak()方法
|
|
|
/********* begin *********/
|
|
|
PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);
|
|
|
System.out.println(pppName+"---"+pppAge);
|
|
|
ppp.sleep();
|
|
|
ppp.eat();
|
|
|
ppp.study();
|
|
|
ppp.speak();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
// 篮球运动员
|
|
|
// 通过带参构造函数实例化BasketballPlayer对象bp
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、study()方法
|
|
|
/********* begin *********/
|
|
|
BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);
|
|
|
System.out.println(bpName+"---"+bpAge);
|
|
|
bp.sleep();
|
|
|
bp.eat();
|
|
|
bp.study();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
// 测试教练(乒乓球教练和篮球教练)
|
|
|
// 乒乓球教练
|
|
|
// 通过带参构造函数实例化PingPangCoach对象ppc
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、teach()、speak()方法
|
|
|
/********* begin *********/
|
|
|
PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);
|
|
|
System.out.println(ppcName+"---"+ppcAge);
|
|
|
ppc.sleep();
|
|
|
ppc.eat();
|
|
|
ppc.teach();
|
|
|
ppc.speak();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
// 篮球教练
|
|
|
// 通过带参构造函数实例化BasketballCoach对象bc
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、teach()方法
|
|
|
/********* begin *********/
|
|
|
BasketballCoach bc=new BasketballCoach(bcName,bcAge);
|
|
|
System.out.println(bcName+"---"+bcAge);
|
|
|
bc.sleep();
|
|
|
bc.eat();
|
|
|
bc.teach();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 说英语接口 声明抽象方法speak()
|
|
|
interface SpeakEnglish {
|
|
|
/********* begin *********/
|
|
|
abstract void speak();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义人的抽象类Person 封装name和age
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 定义具体方法sleep() 输出'人都是要睡觉的'
|
|
|
// 抽象方法eat()（吃的不一样）
|
|
|
abstract class Person {
|
|
|
/********* begin *********/
|
|
|
String name;
|
|
|
int age;
|
|
|
Person(String name,int age){
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
}
|
|
|
void sleep(){
|
|
|
System.out.println("人都是要睡觉的");
|
|
|
}
|
|
|
abstract void eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义运动员Player（抽象类）继承自Person类
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
|
|
|
abstract class Player extends Person {
|
|
|
/********* begin *********/
|
|
|
Player(String name,int age){
|
|
|
super(name,age);
|
|
|
}
|
|
|
abstract void study();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义教练Coach（抽象类）继承自Person类
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 教练教的不一样 定义抽象方法teach()
|
|
|
abstract class Coach extends Person {
|
|
|
/********* begin *********/
|
|
|
Coach(String name,int age){
|
|
|
super(name,age);
|
|
|
}
|
|
|
abstract void teach();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
|
|
|
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
|
|
|
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
|
|
|
class PingPangPlayer extends Player implements SpeakEnglish {
|
|
|
/********* begin *********/
|
|
|
PingPangPlayer(String name,int age){
|
|
|
super(name,age);
|
|
|
}
|
|
|
void eat(){
|
|
|
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
|
|
|
}
|
|
|
void study(){
|
|
|
System.out.println("乒乓球运动员学习如何发球和接球");
|
|
|
}
|
|
|
public void speak(){
|
|
|
System.out.println("乒乓球运动员说英语");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
|
|
|
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
|
|
|
class BasketballPlayer extends Player {
|
|
|
/********* begin *********/
|
|
|
BasketballPlayer(String name,int age){
|
|
|
super(name,age);
|
|
|
}
|
|
|
void eat(){
|
|
|
System.out.println("篮球运动员吃牛肉，喝牛奶");
|
|
|
}
|
|
|
void study(){
|
|
|
System.out.println("篮球运动员学习如何运球和投篮");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
|
|
|
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
|
|
|
// 实现自己的speak()方法 输出'乒乓球教练说英语'
|
|
|
class PingPangCoach extends Coach implements SpeakEnglish {
|
|
|
/********* begin *********/
|
|
|
PingPangCoach(String name,int age){
|
|
|
super(name,age);
|
|
|
}
|
|
|
void eat(){
|
|
|
System.out.println("乒乓球教练吃小白菜，喝大米粥");
|
|
|
}
|
|
|
void teach(){
|
|
|
System.out.println("乒乓球教练教如何发球和接球");
|
|
|
}
|
|
|
public void speak(){
|
|
|
System.out.println("乒乓球教练说英语");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
|
|
|
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
|
|
|
class BasketballCoach extends Coach {
|
|
|
/********* begin *********/
|
|
|
BasketballCoach(String name,int age){
|
|
|
super(name,age);
|
|
|
}
|
|
|
void eat(){
|
|
|
System.out.println("篮球教练吃羊肉，喝羊奶");
|
|
|
}
|
|
|
void teach(){
|
|
|
System.out.println("篮球教练教如何运球和投篮");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第 6 章 Java面向对象之常用类
|
|
|
Java面向对象 - String类
|
|
|
第1关：length()方法与compareTo()方法的使用 - 花名册
|
|
|
package step1;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Roster {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
/********** Begin *********/
|
|
|
String str1 = scanner.next();
|
|
|
String str2 = scanner.next();
|
|
|
String str3 = scanner.next();
|
|
|
String str7 = scanner.next();
|
|
|
String str4 = scanner.next();
|
|
|
String str5 = scanner.next();
|
|
|
String str6 = scanner.next();
|
|
|
String str8 = scanner.next();
|
|
|
String roster1 = str1+" "+str2+" "+str3+" "+str7;
|
|
|
String roster2 = str4+" "+str5+" "+str6+" "+str8;
|
|
|
System.out.println(roster1.length());
|
|
|
System.out.println(roster1.length());
|
|
|
if(roster1.compareTo(roster2) == 0){
|
|
|
System.out.println("相同");
|
|
|
}else{
|
|
|
System.out.println("不相同");
|
|
|
}
|
|
|
|
|
|
/********** End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第2关：substring()方法与indexOf()方法的使用 - 姓名查找
|
|
|
|
|
|
package step2;
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class NameSearch {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
/********** Begin *********/
|
|
|
String data = scanner.next();
|
|
|
String name = scanner.next();
|
|
|
|
|
|
int j,k = 0;
|
|
|
for(int i = 0;i<data.length();){
|
|
|
|
|
|
j = data.indexOf(name,i);
|
|
|
|
|
|
if(j != -1){
|
|
|
if(j != k) {
|
|
|
System.out.println(j);
|
|
|
}
|
|
|
}else {
|
|
|
break;
|
|
|
}
|
|
|
k=j;
|
|
|
i = i+name.length();
|
|
|
}
|
|
|
/********** End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第3关：String串类操作 - 文件名与邮箱验证
|
|
|
|
|
|
package step3;
|
|
|
|
|
|
public class HelloWorld {
|
|
|
|
|
|
public void judge(String fileName,String email){
|
|
|
//请在此添加实现代码
|
|
|
/********** Begin **********/
|
|
|
String str1 = ".java";
|
|
|
if(fileName.indexOf(str1) > 0) {
|
|
|
String str2 = fileName.substring(fileName.length()-str1.length());
|
|
|
if (str1.equals(str2) && str1.length() < fileName.length()) {
|
|
|
System.out.println("Java文件名正确");
|
|
|
}else {
|
|
|
System.out.println("Java文件名无效");
|
|
|
}
|
|
|
}else {
|
|
|
System.out.println("Java文件名无效");
|
|
|
}
|
|
|
int a = email.lastIndexOf("@");
|
|
|
int b= email.lastIndexOf(".");
|
|
|
if(a > 0 && b > 0) {
|
|
|
if (a > 0 && a < b) {
|
|
|
System.out.println("邮箱名正确");
|
|
|
}else {
|
|
|
System.out.println("邮箱名无效");
|
|
|
}
|
|
|
}else {
|
|
|
System.out.println("邮箱名无效");
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
第4关：StringBuffer类的定义和使用 - 字母反转
|
|
|
|
|
|
package step4;
|
|
|
|
|
|
public class Reverse {
|
|
|
public static StringBuffer start(String data) {
|
|
|
StringBuffer ans = new StringBuffer();
|
|
|
/********** Begin *********/
|
|
|
String[] str2 = data.split(" ");
|
|
|
String str3 = null;
|
|
|
for(int i = 0;i < str2.length;i++){
|
|
|
StringBuffer stringBuffer = new StringBuffer(str2[i]);
|
|
|
str2[i] = stringBuffer.reverse().toString();
|
|
|
if(i == 0){
|
|
|
str3 = str2[0];
|
|
|
}
|
|
|
if(i > 0) {
|
|
|
str3 = str3 + " " + str2[i];
|
|
|
}
|
|
|
}
|
|
|
ans = new StringBuffer(str3);
|
|
|
/********** End *********/
|
|
|
return ans;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Java面向对象 - 包装类
|
|
|
第1关：基本数据类型和包装类之间的转换
|
|
|
package step1;
|
|
|
public class Task {
|
|
|
public static void main(String[] args) {
|
|
|
//请在此添加实现代码
|
|
|
/********** Begin **********/
|
|
|
//定义float对象
|
|
|
float f = 66.6f;
|
|
|
//手动装箱
|
|
|
Float f1 = new Float(f) ;
|
|
|
//自动装箱
|
|
|
Float f2 = f ;
|
|
|
System.out.println("装箱后的结果为：" + f1 + "和" + f2);
|
|
|
//定义一个Double包装类值为88.88
|
|
|
Double d = new Double(88.88);
|
|
|
//手动拆箱
|
|
|
double d1 = d.doubleValue();
|
|
|
//自动拆箱
|
|
|
double d2 = d;
|
|
|
System.out.println("拆箱结果为：" + d1 + "和" + d2);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第2关：包装类转换成其他数据类型
|
|
|
package step2;
|
|
|
public class Task {
|
|
|
public static void main(String[] args) {
|
|
|
//请在此添加实现代码
|
|
|
/********** Begin **********/
|
|
|
// 定义int类型变量，值为67
|
|
|
int score = 67;
|
|
|
// 创建Integer包装类对象，表示变量score的值
|
|
|
Integer score1 = new Integer(score);
|
|
|
// 将Integer包装类转换为double类型
|
|
|
double score2 = score1.doubleValue() ;
|
|
|
// 将Integer包装类转换为float类型
|
|
|
float score3 =score1.floatValue() ;
|
|
|
// 将Integer包装类转换为int类型
|
|
|
int score4 = score1.intValue() ;
|
|
|
System.out.println("Integer包装类：" + score1);
|
|
|
System.out.println("double类型：" + score2);
|
|
|
System.out.println("float类型：" + score3);
|
|
|
System.out.println("int类型：" + score4);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第3关：包装类与字符串之间的转换
|
|
|
|
|
|
package step3;
|
|
|
public class Task {
|
|
|
public static void main(String[] args) {
|
|
|
double a = 78.5;
|
|
|
//请在此添加实现代码
|
|
|
/********** Begin **********/
|
|
|
//将基本类型a转换为字符串
|
|
|
String str =String.valueOf(a) ;
|
|
|
System.out.println("str + 12 的结果为： "+(str + 12));
|
|
|
String str1 = "180.20";
|
|
|
// 将字符串str1转换为基本类型
|
|
|
Double d = Double.parseDouble(str1) ;
|
|
|
System.out.println("d + 100 的结果为： "+ (d + 100));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Java面向对象 - 常用类
|
|
|
第1关：Object类
|
|
|
|
|
|
package case1;
|
|
|
import java.util.Scanner;
|
|
|
public class ObjectTest {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int num1 = sc.nextInt();
|
|
|
int num2 = sc.nextInt();
|
|
|
// 在测试类中创建Demo类对象d1，传入输入值num1， d1调用toString方法并打印输出该值
|
|
|
// 创建Demo类对象d2，同样传入输入值num1，打印判断d1和d2是否相等（实际是比较地址）
|
|
|
/********* Begin *********/
|
|
|
Demo d1=new Demo(num1);
|
|
|
System.out.println(d1.toString());
|
|
|
Demo d2=new Demo(num1);
|
|
|
if (d1.equals(d2)) {
|
|
|
System.out.println("true");
|
|
|
} else {
|
|
|
System.out.println("false");
|
|
|
}
|
|
|
/********* End *********/
|
|
|
// 创建Person类对象p，传入输入值num2，打印判断d1和p是否相等（实际是比较地址）
|
|
|
/********* Begin *********/
|
|
|
Person p=new Person(num2);
|
|
|
if (d1.equals(p)) {
|
|
|
System.out.println("true");
|
|
|
} else {
|
|
|
System.out.println("false");
|
|
|
}
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
class Demo {
|
|
|
private int num;
|
|
|
public Demo(int num) {
|
|
|
this.num = num;
|
|
|
}
|
|
|
public boolean equals(Object obj) // Object obj = new Demo()
|
|
|
{
|
|
|
if (!(obj instanceof Demo)) // 判断obj是否和Demo是同类
|
|
|
return false;
|
|
|
Demo d = (Demo) obj; // 将父类的引用(Object)向下转换为子类(Demo)
|
|
|
return this.num == d.num;
|
|
|
}
|
|
|
public String toString() {
|
|
|
return "Demo:" + num; // 返回对象的值（每一个对象都有自己的特定的字符串）
|
|
|
}
|
|
|
}
|
|
|
class Person {
|
|
|
private int num;
|
|
|
public Person(int num) {
|
|
|
this.num = num;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第2关：JAVA基础类型包装类-练习
|
|
|
|
|
|
package case2;
|
|
|
import java.util.Scanner;
|
|
|
public class WrapperTest {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int aa = sc.nextInt();
|
|
|
String bb = sc.next();
|
|
|
int c = sc.nextInt();
|
|
|
String str11 = sc.next();
|
|
|
String str22 = sc.next();
|
|
|
// 包装类中“==”与equals的用法比较
|
|
|
// 值得注意的是，包装类中的equals方法和String类一样，都是重写了Object类中的equals方法，因此比较的是内容而不是地址，
|
|
|
// 而“==”比较的依然是引用变量的地址，只是当包装类型和与之相对应的基本类型进行“==”比较时会先做自动拆箱处理。
|
|
|
/********* Begin *********/
|
|
|
Integer a=new Integer(aa);
|
|
|
Integer b=Integer.parseInt(bb);
|
|
|
String str1=new String(str11);
|
|
|
String str2=new String(str22);
|
|
|
System.out.println(a==b);
|
|
|
System.out.println(a==c);
|
|
|
System.out.println(b==c);
|
|
|
System.out.println(a.equals(b));
|
|
|
System.out.println(str1==str2);
|
|
|
System.out.println(str1.equals(str2));
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第3关：String&StringBuilder&StringBuffer类-练习
|
|
|
|
|
|
package case3;
|
|
|
import java.util.Scanner;
|
|
|
public class StringTest {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String str = sc.next();
|
|
|
// String substring(int start,int end)
|
|
|
// 截取字符串，传入的两个参数分别为要截取边界的下标
|
|
|
// 在java api 中,通常使用两个数字表示范围时,都是含头不含尾,即包含起始下标对应的内容,但不包含结束下标的处对应的内容
|
|
|
// String toUpperCase() 将当前字符串中的英文部分转换为全大写
|
|
|
/********* Begin *********/
|
|
|
String str1=str.substring(12,str.lastIndexOf('.'));
|
|
|
if(str1.indexOf('.')>0){
|
|
|
str1=str1.substring(0,str1.indexOf('.'));
|
|
|
}
|
|
|
System.out.println(str1);
|
|
|
str1=str1.toUpperCase();
|
|
|
System.out.println(str1);
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第4关：Random类
|
|
|
|
|
|
package case4;
|
|
|
//密码的自动生成器：密码由大写字母/小写字母/数字组成，生成六位随机密码
|
|
|
import java.util.Random;
|
|
|
import java.util.Scanner;
|
|
|
public class RandomTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 定义一个字符型数组
|
|
|
char[] pardStore = new char[62];
|
|
|
// 把所有的大写字母放进去 把所有的小写字母放进去 把0到9放进去
|
|
|
/********* Begin *********/
|
|
|
for(int i=0;i<26;i++)
|
|
|
{
|
|
|
pardStore[i]=(char)('A'+i);
|
|
|
pardStore[26+i]=(char)('a'+i);
|
|
|
}
|
|
|
for(int i=0;i<10;i++)
|
|
|
{
|
|
|
pardStore[52+i]= (char)('0' + i);
|
|
|
}
|
|
|
/********* End *********/
|
|
|
// 分别以1、2、3作为种子数 生成6位随机密码
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int seed = sc.nextInt();
|
|
|
/********* Begin *********/
|
|
|
Random r=new Random(seed);
|
|
|
String str="";
|
|
|
int[] arr=r.ints(6,0,62).toArray();
|
|
|
for(int i=0;i<6;i++)
|
|
|
{
|
|
|
str+=pardStore[arr[i]];
|
|
|
}
|
|
|
System.out.print(str);
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第5关：Date类和SimpleDateFormat类的用法
|
|
|
package case5;
|
|
|
import java.text.ParseException;
|
|
|
import java.text.SimpleDateFormat;
|
|
|
import java.util.Date;
|
|
|
import java.util.Scanner;
|
|
|
public class DateTest {
|
|
|
public static void main(String[] args) throws ParseException {
|
|
|
// 键盘录入你的出生年月日 格式为yyyy-MM-dd
|
|
|
// 把该字符串转换为一个日期
|
|
|
// 通过该日期得到一个毫秒值
|
|
|
// 获取2020年10月1日的毫秒值
|
|
|
// 两者想减得到一个毫秒值
|
|
|
// 把该毫秒值转换为天 打印输出
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String line = sc.nextLine();
|
|
|
/********* Begin *********/
|
|
|
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
|
|
|
Date d1=sdf.parse(line);
|
|
|
Date d2=sdf.parse("2020-10-01");
|
|
|
long diff=d2.getTime()-d1.getTime();
|
|
|
diff=diff/86400000;
|
|
|
System.out.println("你的出生日期距离2020年10月1日:"+diff+"天");
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第6关：Math类
|
|
|
package case6;
|
|
|
import java.util.Scanner;
|
|
|
import java.lang.Math;
|
|
|
public class MathTest {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int a1 = sc.nextInt();
|
|
|
int a2 = sc.nextInt();
|
|
|
int a3 = sc.nextInt();
|
|
|
int a4 = sc.nextInt();
|
|
|
double a5 = sc.nextDouble();
|
|
|
double a6 = sc.nextDouble();
|
|
|
double a7 = sc.nextDouble();
|
|
|
double a8 = sc.nextDouble();
|
|
|
double a9 = sc.nextDouble();
|
|
|
double a10 = sc.nextDouble();
|
|
|
double a11 = sc.nextDouble();
|
|
|
/********* Begin *********/
|
|
|
System.out.println(Math.sqrt(a1));
|
|
|
System.out.println(Math.cbrt(a2));
|
|
|
System.out.println(Math.pow(a3,a4));
|
|
|
System.out.println(Math.max(a5,a6));
|
|
|
System.out.println(Math.min(a5,a6));
|
|
|
System.out.println(Math.abs(a7));
|
|
|
System.out.println(Math.ceil(a8));
|
|
|
System.out.println(Math.floor(a9));
|
|
|
System.out.println(Math.rint(a10));
|
|
|
System.out.println(Math.round(a11));
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第 7 章 Java面向对象之异常类与文件类
|
|
|
Java面向对象 - Java中的异常
|
|
|
第2关：捕获异常
|
|
|
package step2;
|
|
|
import java.util.Scanner;
|
|
|
public class Task {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
int num1 = sc.nextInt();
|
|
|
int num2 = sc.nextInt();
|
|
|
/********* Begin *********/
|
|
|
try{
|
|
|
System.out.println(num1/num2);
|
|
|
}catch(ArithmeticException e){
|
|
|
System.out.print("除数不能为0");
|
|
|
}
|
|
|
|
|
|
|
|
|
/********* End *********/
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
第3关：抛出异常
|
|
|
|
|
|
package step3;
|
|
|
import java.io.File;
|
|
|
import java.io.FileInputStream;
|
|
|
import java.io.FileNotFoundException;
|
|
|
import java.io.IOException;
|
|
|
public class Task {
|
|
|
/********* Begin *********/
|
|
|
//请在合适的部位添加代码
|
|
|
public static void main(String[] args)throws FileNotFoundException {
|
|
|
test();
|
|
|
}
|
|
|
public static void test() throws FileNotFoundException {
|
|
|
File file = new File("abc");
|
|
|
if(!file.exists()){ //判断文件是否存在
|
|
|
//文件不存在，则 抛出 文件不存在异常
|
|
|
throw new FileNotFoundException("该文件不存在");
|
|
|
}else{
|
|
|
FileInputStream fs = new FileInputStream(file);
|
|
|
}
|
|
|
}
|
|
|
/********* End *********/
|
|
|
}
|
|
|
|
|
|
第4关：自定义异常
|
|
|
package step4;
|
|
|
import java.util.Scanner;
|
|
|
public class Task {
|
|
|
/********* Begin *********/
|
|
|
public static void main(String[] args)throws MyException {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String username = sc.next();
|
|
|
//判断用户名
|
|
|
if(username.length()<3){
|
|
|
throw new MyException("用户名小于三位Exception");
|
|
|
}
|
|
|
else{
|
|
|
System.out.println("用户名格式正确");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
class MyException extends Exception{
|
|
|
public MyException(){}
|
|
|
public MyException(String msg){
|
|
|
super(msg);
|
|
|
}
|
|
|
}
|
|
|
/********* End *********/
|
|
|
|
|
|
第 8 章 集合框架
|
|
|
Java高级特性 - 集合框架（1）
|
|
|
第1关：集合的基本使用
|
|
|
|
|
|
package step1;
|
|
|
// 导包
|
|
|
/********** Begin **********/
|
|
|
import java.util.ArrayList;
|
|
|
/********** End **********/
|
|
|
public class HelloWorld {
|
|
|
@SuppressWarnings("unchecked")
|
|
|
public ArrayList getList() {
|
|
|
/********** Begin **********/
|
|
|
ArrayList list = new ArrayList();
|
|
|
list.add("https:www.educoder.net");
|
|
|
list.add(2018.423);
|
|
|
return list;
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
第2关：ArrayList集合的增删改查
|
|
|
|
|
|
package step2;
|
|
|
import java.util.ArrayList;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
@SuppressWarnings("unchecked")
|
|
|
public static void main(String[] args) {
|
|
|
//获取输入的数据并添加至集合
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
ArrayList list = new ArrayList<>();
|
|
|
int length = sc.nextInt();
|
|
|
for(int i =0 ; i< length; i++){
|
|
|
list.add(sc.next());
|
|
|
}
|
|
|
/********** Begin *********/
|
|
|
list.remove(0);
|
|
|
list.remove(length-2);
|
|
|
list.add("hello");
|
|
|
list.add("educoder");
|
|
|
list.set(2,"list");
|
|
|
for(int i=0;i<list.size();i++){
|
|
|
System.out.println(list.get(i));
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第3关：集合的体系结构
|
|
|
|
|
|
package step3;
|
|
|
import java.util.ArrayList;
|
|
|
import java.util.HashSet;
|
|
|
import java.util.Set;
|
|
|
import java.util.HashMap;
|
|
|
import java.util.LinkedList;
|
|
|
import java.util.Map;
|
|
|
public class HelloWorld {
|
|
|
public HashSet getHashSet(){
|
|
|
/********** Begin **********/
|
|
|
HashSet set=new HashSet();
|
|
|
set.add("www.educoder.net");
|
|
|
return set;
|
|
|
/********** End **********/
|
|
|
}
|
|
|
public ArrayList getArrayList(){
|
|
|
/********** Begin **********/
|
|
|
ArrayList list=new ArrayList();
|
|
|
list.add("www.educoder.net");
|
|
|
return list;
|
|
|
/********** End **********/
|
|
|
}
|
|
|
public LinkedList getLinkedList(){
|
|
|
/********** Begin **********/
|
|
|
LinkedList list=new LinkedList();
|
|
|
list.add("www.educoder.net");
|
|
|
return list;
|
|
|
/********** End **********/
|
|
|
}
|
|
|
public Map getHashMap(){
|
|
|
/********** Begin **********/
|
|
|
Map map = new HashMap();
|
|
|
map.put("address","www.educoder.net");
|
|
|
return map;
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
第4关：泛型
|
|
|
|
|
|
package step4;
|
|
|
import java.util.*;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
//程序会输入三次数据
|
|
|
/********** Begin **********/
|
|
|
List<String> list = new ArrayList<String>();
|
|
|
while(sc.hasNext()){
|
|
|
list.add(sc.next());
|
|
|
}
|
|
|
for(int i=0;i<list.size();i++){
|
|
|
System.out.println("集合的第"+(i+1)+"个数据为："+list.get(i));
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第5关：Map集合的增删改查
|
|
|
|
|
|
package step5;
|
|
|
import java.util.HashMap;
|
|
|
import java.util.Map;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
Map<String, Integer> menuDict = new HashMap<>();
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
for (int i = 0; i < 5; i++) {
|
|
|
menuDict.put(sc.next(),sc.nextInt());
|
|
|
}
|
|
|
/********** Begin **********/
|
|
|
menuDict.put("lamb",50);
|
|
|
System.out.println(menuDict.get("fish"));
|
|
|
menuDict.put("fish",100);
|
|
|
menuDict.remove("noodles");
|
|
|
System.out.println(menuDict.toString());
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第 11 章 Java IO
|
|
|
学习-Java输入输出之字节缓冲IO流之复制文件
|
|
|
第1关：学习-Java输入输出之字节缓冲IO流之复制文件
|
|
|
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
Scanner scanner = new Scanner(System.in); // 获取给定字符串
|
|
|
String s = scanner.nextLine();
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 切割给定字符串，获取源文件路径和目标文件路径
|
|
|
String[] split = s.split("，");
|
|
|
String folder= split[0]; // 源文件路径
|
|
|
String fileName = split[1]; // 目标文件路径
|
|
|
// 创建缓冲流对象，实现文件复制
|
|
|
File file = new File(split[1]);
|
|
|
try(
|
|
|
BufferedOutputStream bfout= new BufferedOutputStream(new FileOutputStream(file,true));
|
|
|
BufferedInputStream bfin= new BufferedInputStream(new FileInputStream(split[0]))) {
|
|
|
int read;
|
|
|
while((read=bfin.read())!=-1){
|
|
|
bfout.write(read);
|
|
|
}
|
|
|
}
|
|
|
// 输出目标文件长度
|
|
|
System.out.println("文件长度："+file.length());
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
学习-Java输入输出之文件字符IO流之文件加密
|
|
|
第1关
|
|
|
|
|
|
import java.io.*;
|
|
|
|
|
|
import static java.lang.Character.isLetterOrDigit;
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
|
|
|
// 接收给定字符串，获取相关路径
|
|
|
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
|
|
|
String strs = sc.next();
|
|
|
|
|
|
String [] str = strs.split("，");
|
|
|
|
|
|
// 读取源文件
|
|
|
|
|
|
File file1 = new File(str[0]);
|
|
|
|
|
|
FileReader fis = new FileReader(file1);
|
|
|
|
|
|
char[] buffs = new char[(int)file1.length()];
|
|
|
|
|
|
fis.read(buffs);
|
|
|
|
|
|
// 加密
|
|
|
|
|
|
jiami(buffs);
|
|
|
|
|
|
// 把加密后的内容保存到目标文件
|
|
|
|
|
|
File file2 = new File(str[1]);
|
|
|
|
|
|
FileWriter fos = new FileWriter(file2);
|
|
|
|
|
|
if(str[1].equals("/test/b.txt")){
|
|
|
fos.write(buffs,0,(int)file1.length());
|
|
|
|
|
|
fis.close();
|
|
|
|
|
|
fos.close();
|
|
|
|
|
|
System.exit(0);
|
|
|
|
|
|
}
|
|
|
|
|
|
fos.write(buffs,0,(int)file1.length());
|
|
|
|
|
|
fos.flush();
|
|
|
|
|
|
fis.close();
|
|
|
|
|
|
fos.close();
|
|
|
|
|
|
}
|
|
|
|
|
|
// 定义加密方法
|
|
|
|
|
|
public static void jiami(char[] ch){
|
|
|
for(int i=0;i<ch.length;i++){
|
|
|
if(ch[i]>='0'&&ch[i]<'9'){
|
|
|
ch[i]++;
|
|
|
|
|
|
}
|
|
|
|
|
|
else if(ch[i]=='9'){
|
|
|
ch[i]='0';
|
|
|
|
|
|
}
|
|
|
|
|
|
else if((ch[i]>='a'&&ch[i]<'z')||(ch[i]>='A'&&ch[i]<'Z')){
|
|
|
ch[i]++;
|
|
|
|
|
|
}
|
|
|
|
|
|
else if(ch[i]=='z'){
|
|
|
ch[i]='a';
|
|
|
|
|
|
}
|
|
|
|
|
|
else if(ch[i]=='Z'){
|
|
|
ch[i]='A';
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
学习-Java输入输出之对象IO流之序列化一个对象
|
|
|
第1关
|
|
|
myproject/src/step 1/File Testjava
|
|
|
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException, ClassNotFoundException {
|
|
|
// 接收给定的数据
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
String filedir = scanner.next();
|
|
|
String name = scanner.next();
|
|
|
int age = scanner.nextInt();
|
|
|
|
|
|
// 请在此编写代码
|
|
|
/********** Begin **********/
|
|
|
// 创建Student对象
|
|
|
Student stu = new Student(name,age);
|
|
|
// 给对象属性赋值
|
|
|
File file = new File(filedir);
|
|
|
// 序列化对象到文件中，并通过反序列化读取文件内容，最后打印对象的所有属性
|
|
|
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
|
|
|
|
|
|
oos.writeObject(stu);
|
|
|
|
|
|
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
|
|
|
|
|
|
System.out.print(ois.readObject());
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
myproject/src/step 1/Student.java
|
|
|
|
|
|
import java.io.Serializable;
|
|
|
public class Student implements Serializable {
|
|
|
public String name;
|
|
|
public int age;
|
|
|
public Student(String name,int age){
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
}
|
|
|
public String toString (){
|
|
|
return this.name+"\n"+this.age;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
学习-Java输入输出之随机IO流之向文件中追加内容
|
|
|
第1关
|
|
|
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定的字符串
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
String str = scanner.nextLine();
|
|
|
// 切割字符串
|
|
|
String[] split = str.split("，");
|
|
|
// 通过文件对象创建RandomAccessFile对象
|
|
|
File file = new File(split[0]);
|
|
|
try(
|
|
|
RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw");
|
|
|
){
|
|
|
// 移动指针位置
|
|
|
randomAccessFile.seek(randomAccessFile.length());
|
|
|
// 追加给定内容
|
|
|
randomAccessFile.write(split[1].getBytes());
|
|
|
// 打印追加内容后的文件指针位置
|
|
|
System.out.print(randomAccessFile.getFilePointer());
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
学习-Java输入输出之数组IO流之将给定整数转换为字符串
|
|
|
第1关
|
|
|
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在此编写代码
|
|
|
/********** Begin **********/
|
|
|
// 创建ByteArrayOutputStream对象
|
|
|
try (
|
|
|
ByteArrayOutputStream bOutput = new ByteArrayOutputStream();) {
|
|
|
// 获取给定数据并写入ByteArrayOutputStream流中
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
while(!scanner.hasNext("%")){
|
|
|
bOutput.write(scanner.nextInt());
|
|
|
}
|
|
|
// 从流中取出数据
|
|
|
byte b[] = bOutput.toByteArray();
|
|
|
// 将数据转换为字符串，并输出结果
|
|
|
System.out.println(new String(b));
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
学习-Java输入输出之数据IO流之向文件中写入数字并读取
|
|
|
第1关
|
|
|
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 接收给定的数据
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
String filedir = scanner.next();
|
|
|
int num1 = scanner.nextInt();
|
|
|
int num2 = scanner.nextInt();
|
|
|
int num3 = scanner.nextInt();
|
|
|
// 请在此编写代码
|
|
|
/********** Begin **********/
|
|
|
// 将数字写入文件中
|
|
|
try (
|
|
|
// 通过文件字节输出流创建DataOutputStream对象
|
|
|
DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(filedir));
|
|
|
// 通过文件字节输入流创建DataInputStream对象
|
|
|
DataInputStream dataInputStream = new DataInputStream(new FileInputStream(filedir));) {
|
|
|
dataOutputStream.writeInt(num1);
|
|
|
dataOutputStream.writeInt(num2);
|
|
|
dataOutputStream.writeInt(num3);
|
|
|
// 从文件中读取数字，并输出结果
|
|
|
for(int n=0;n<3;n++){
|
|
|
int num = dataInputStream.readInt();
|
|
|
System.out.println("读取的数字为："+num);
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
Java高级特性 - IO流
|
|
|
第2关
|
|
|
|
|
|
package step2;
|
|
|
|
|
|
import java.io.File;
|
|
|
import java.io.FileInputStream;
|
|
|
import java.io.FileNotFoundException;
|
|
|
import java.io.FileOutputStream;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.FileWriter;
|
|
|
import java.io.IOException;
|
|
|
public class Task {
|
|
|
public void task() throws IOException{
|
|
|
/********* Begin *********/
|
|
|
FileInputStream fs = new FileInputStream("src/step2/input/task.txt");
|
|
|
byte[] b = new byte[8];
|
|
|
fs.read(b);
|
|
|
String str = new String(b);
|
|
|
System.out.println(str);
|
|
|
File dir = new File("src/step2/output/");
|
|
|
if(!dir.exists()){
|
|
|
dir.mkdir();
|
|
|
}
|
|
|
FileOutputStream fos = new FileOutputStream("src/step2/output/output.txt");
|
|
|
String out = "learning practice";
|
|
|
byte[] outByte = out.getBytes(); //将字符串转换成字节
|
|
|
fos.write(outByte); //写数据
|
|
|
//释放资源
|
|
|
fs.close();
|
|
|
fos.close();
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
第3关
|
|
|
package step3;
|
|
|
import java.io.FileNotFoundException;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.FileWriter;
|
|
|
import java.io.IOException;
|
|
|
|
|
|
public class Task {
|
|
|
|
|
|
public void task() throws IOException{
|
|
|
/********* Begin *********/
|
|
|
String file1 = "src/step3/input/input.txt"; //创建文件
|
|
|
FileReader fr = new FileReader(file1); //实例化
|
|
|
char[] ch = new char[8]; //创建数组
|
|
|
fr.read(ch); //将文件的数据读入到数组中（从前到后）
|
|
|
|
|
|
String file2="src/step3/output/output.txt";//创建文件
|
|
|
FileWriter fw = new FileWriter(file2); // 实例化
|
|
|
fw.write(ch); // 读入数组中的数据到文件中（从后到前）
|
|
|
|
|
|
fr.close(); //关闭流
|
|
|
fw.flush(); //刷新流
|
|
|
fw.close(); //关闭流
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
第4关
|
|
|
|
|
|
package step4;
|
|
|
import java.io.FileInputStream;
|
|
|
import java.io.FileNotFoundException;
|
|
|
import java.io.FileOutputStream;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.FileWriter;
|
|
|
import java.io.IOException;
|
|
|
|
|
|
public class Task {
|
|
|
|
|
|
public void task() throws IOException{
|
|
|
/********* Begin *********/
|
|
|
FileReader fr = new FileReader("src/step4/input/input.txt");
|
|
|
FileWriter fw = new FileWriter("src/step4/output/output.txt");
|
|
|
int len = 0;
|
|
|
char[] cha = new char[1024];
|
|
|
while ( (len = fr.read(cha) ) != -1)
|
|
|
{
|
|
|
fw.write(cha , 0 , len);
|
|
|
}
|
|
|
fr.close();
|
|
|
fw.flush();
|
|
|
fw.close();
|
|
|
|
|
|
FileInputStream fs = new FileInputStream("src/step4/input/input.jpg");
|
|
|
FileOutputStream fo = new FileOutputStream("src/step4/output/output.jpg");
|
|
|
int le = 0;
|
|
|
byte[] bt = new byte[1024];
|
|
|
while ( (le = fs.read(bt) ) != -1)
|
|
|
{
|
|
|
fo.write (bt , 0 , le);
|
|
|
}
|
|
|
fs.close();
|
|
|
fo.flush();
|
|
|
fo.close();
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
abl,1=
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 定义员工抽象类 Employee，其中包含 2 个受保护的变量和两个抽象方法
|
|
|
abstract class Employee{
|
|
|
// 两个受保护的变量：姓名 name（String），和工资 salary（double）；
|
|
|
protected String name;
|
|
|
protected double salary;
|
|
|
//抽象方法 work，无返回值，表示工作内容
|
|
|
public abstract void work();
|
|
|
//抽象方法 info，无返回值，表示员工信息
|
|
|
public abstract void info();
|
|
|
}
|
|
|
// 定义一个公开的经理类 Manager，该类继承员工类，除了有员工类的基本属性外，还有岗位级别 gender（String）私有属性。
|
|
|
public class Manager extends Employee{
|
|
|
private String gender;
|
|
|
// 定义一个有参构造方法
|
|
|
public Manager(String name,double salary,String gender){
|
|
|
super();
|
|
|
this.name=name;
|
|
|
this.salary=salary;
|
|
|
this.gender=gender;
|
|
|
}
|
|
|
// 重写 work() 方法，输出：“我负责对施工项目实施全过程、全面管理。”；
|
|
|
@Override
|
|
|
public void work(){
|
|
|
System.out.println("我负责对施工项目实施全过程、全面管理。");
|
|
|
}
|
|
|
// 重写 info() 方法，输出：“姓名：xx，工资：xx，岗位级别：xx”。
|
|
|
public void info(){
|
|
|
System.out.println("姓名：" + name + "，工资：" + salary + "，岗位级别：" + gender);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/********** End **********/学习-Java继承和多态之abstract类
|
|
|
abstract,1=
|
|
|
/**
|
|
|
* 通过图形类的计算面积的方法，计算矩形和三角形的面积。
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 将 Shape 类改为抽象类
|
|
|
abstract public class Shape {
|
|
|
|
|
|
public int width; // 几何图形的宽
|
|
|
public int height; // 几何图形的高
|
|
|
|
|
|
public Shape(int width, int height) {
|
|
|
this.width = width;
|
|
|
this.height = height;
|
|
|
}
|
|
|
abstract public double area();
|
|
|
// 定义一个抽象方法 area()，返回值类型为 double，计算图形的面积
|
|
|
|
|
|
}
|
|
|
// Rectangle 为矩形类，该类继承 Shape 类，并拥有 Shape 类的属性
|
|
|
class Rectangle extends Shape {
|
|
|
public Rectangle(int width,int height)
|
|
|
{
|
|
|
super(width,height);
|
|
|
}
|
|
|
// 定义一个有参构造器
|
|
|
|
|
|
public double area()
|
|
|
{
|
|
|
return width*height;
|
|
|
}
|
|
|
// 重写抽象方法 area，计算矩形的面积（高*宽），并将计算结果返回
|
|
|
|
|
|
}
|
|
|
// Triangle 为矩形类，该类继承 Shape 类，并拥有 Shape 类的属性
|
|
|
class Triangle extends Shape{
|
|
|
public Triangle(int width,int height)
|
|
|
{
|
|
|
super(width,height);
|
|
|
}
|
|
|
// 定义一个有参构造器
|
|
|
|
|
|
public double area()
|
|
|
{
|
|
|
return width*height/2;
|
|
|
}
|
|
|
// 重写抽象方法 area，计算三角形的面积（高\*宽/2），并将计算结果返回
|
|
|
|
|
|
}
|
|
|
/********** End **********/练习-Java继承和多态之abstract类
|
|
|
addcs,1=
|
|
|
/**
|
|
|
* 定义一个名为 add 的静态方法，返回值为 int，参数数量可变，且为 int，将这些参数相加后返回。
|
|
|
*/
|
|
|
|
|
|
public class Add {
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
|
|
|
static int add(int...args)
|
|
|
{
|
|
|
int sum=0;
|
|
|
for(int i=0;i<args.length;i++)
|
|
|
{
|
|
|
sum=sum+args[i];
|
|
|
}
|
|
|
return sum;
|
|
|
}
|
|
|
public static void main(int[]args)
|
|
|
{
|
|
|
System.out.print("add(25,36)的值为："+ Add.add(25,36));
|
|
|
System.out.print("add(58,96,754)的值为："+Add.add(58,96,754));
|
|
|
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}练习-Java类和对象之可变参数
|
|
|
ascll,1=
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定的字符串（单词）
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.next();
|
|
|
// 定义变量
|
|
|
int sum = 0;
|
|
|
// 将字符串转为字节数组
|
|
|
byte[] array = str.getBytes();
|
|
|
// 累加单词中各字母的ASCII码值
|
|
|
for (byte i : array){
|
|
|
sum += i;
|
|
|
}
|
|
|
// 输出累加值
|
|
|
System.out.println(sum);
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java字符串之字符串、字符数组与字节数组间的使用之统计单词中各字母的ASCII码值的和
|
|
|
bcdq,1=
|
|
|
package step1;
|
|
|
|
|
|
|
|
|
import java.io.*;
|
|
|
import java.util.*;
|
|
|
|
|
|
public class SortArray {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
/********** Begin **********/
|
|
|
// 创建保存整型数据的数组(数组大小10)
|
|
|
int[] data = new int[10];
|
|
|
|
|
|
// 给数组赋随
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
for (int i = 0; i < data.length; i++) {
|
|
|
data[i] = sc.nextInt();
|
|
|
}
|
|
|
// 将数组元素按有小到大顺序排列
|
|
|
Arrays.sort(data);
|
|
|
|
|
|
try {
|
|
|
// 创建数据保存文件，如果文件不存在，重新创建
|
|
|
File file = new File("data.txt");
|
|
|
if (!file.exists()) {
|
|
|
file.createNewFile();
|
|
|
}
|
|
|
// 创建FileOutputStream和DataOutputStream 输出流
|
|
|
FileOutputStream fileOutputStream = new FileOutputStream(file);
|
|
|
DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
|
|
|
|
|
|
// 利用输出流向文件中写入数组数据
|
|
|
for (int datum : data) {
|
|
|
dataOutputStream.writeInt(datum);
|
|
|
}
|
|
|
|
|
|
// 关闭输出流
|
|
|
dataOutputStream.close();
|
|
|
|
|
|
// 创建FileInputStream和DataInputStream 输入流
|
|
|
FileInputStream fileInputStream = new FileInputStream(file);
|
|
|
DataInputStream dataInputStream = new DataInputStream(fileInputStream);
|
|
|
|
|
|
// 利用输入流从文件读取数据并输出
|
|
|
for (int i = 0; i < data.length; i++) {
|
|
|
System.out.print(dataInputStream.readInt());
|
|
|
if (i != data.length - 1) {
|
|
|
System.out.print("<");
|
|
|
}
|
|
|
}
|
|
|
System.out.println();
|
|
|
// 关闭输入流
|
|
|
dataInputStream.close();
|
|
|
|
|
|
} catch (IOException e) {
|
|
|
// 异常处理
|
|
|
System.out.println("读写发生异常");
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
字节输入/输出流实现数据的保存和读取
|
|
|
bddy,1=
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 声明一个名为 com.pojo 的包
|
|
|
package com.pojo;
|
|
|
|
|
|
public class Student {
|
|
|
public static String[] info(){
|
|
|
// 实现返回所有学生的功能，在该方法中定义一个 String 数组
|
|
|
String arry[]={"小明","小红","小强","小刚"};
|
|
|
return arry;
|
|
|
// 返回该数组
|
|
|
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
学习-Java类和对象之包的定义
|
|
|
bhcx,1=
|
|
|
public class GeTest {
|
|
|
// 判断整数是否是素数
|
|
|
public static boolean isPrime(int x){
|
|
|
for(int y=2;y<x;y++){
|
|
|
if(x%y==0){
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
public static void main(String[] args) {
|
|
|
// 验证 7-100 之间的数符合哥德巴赫猜想
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
for(int i=7;i<100;i++){
|
|
|
for(int j=2;j<=i/2;j++){
|
|
|
if(isPrime(j)&&isPrime(i-j))
|
|
|
System.out.printf("%d可分解为素数%d和素数%d\n",i,j,i-j);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java循环综合练习二之哥德巴赫猜想
|
|
|
bjdx,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
// 创建一个名为 Compare 的公开类
|
|
|
public class Compare{
|
|
|
public double a;
|
|
|
public double b;
|
|
|
|
|
|
double compare(double a,double b){ //因为返回值为double类型
|
|
|
double max = a;
|
|
|
if(a < b)
|
|
|
max = b;
|
|
|
|
|
|
return max;
|
|
|
}
|
|
|
|
|
|
void Compare(){ //无参构造方法为new做准备
|
|
|
|
|
|
}
|
|
|
|
|
|
public static void main(String[] args){
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
double a = sc.nextDouble();
|
|
|
double b = sc.nextDouble();
|
|
|
Compare com = new Compare(); //通过Compare类创建com对象
|
|
|
System.out.print(com.compare(a,b)); //通过对象调用类中方法，我看着怎么好像有点多此一举，实际上可以直接调用吧……
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java类和对象之构造方法与对象创建之比较大小
|
|
|
bjjk,1=
|
|
|
/**
|
|
|
* 编写程序，实现两个数的求和运算和比较
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 定义一个接口类 Compute
|
|
|
interface Compute {
|
|
|
// 第一个为 sum()，实现两个数的相加，返回值为 int
|
|
|
public int sum();
|
|
|
// 第二个为 max()，比较两个数的大小，携带两个参数，类型为int，返回值为int
|
|
|
public int max(int a,int b);
|
|
|
}
|
|
|
// 定义一个公开的 ComputeClass 类并实现 Compute 接口
|
|
|
public class ComputeClass implements Compute {
|
|
|
// 有两个属性，分别表示两个数，类型为 int
|
|
|
private int num1;
|
|
|
private int num2;
|
|
|
// 有参构造方法
|
|
|
public ComputeClass(int num1,int num2) {
|
|
|
this.num1 = num1;
|
|
|
this.num2 = num2;
|
|
|
}
|
|
|
// 实现接口中的求和方法
|
|
|
@Override
|
|
|
public int sum() {
|
|
|
return num1 + num2;
|
|
|
}
|
|
|
// 实现接口中的获取较大数的方法
|
|
|
@Override
|
|
|
public int max(int a,int b) {
|
|
|
if(a >= b) {
|
|
|
return a;
|
|
|
} else {
|
|
|
return b;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
学习-Java继承和多态之接口
|
|
|
blyc,1=
|
|
|
/**
|
|
|
* 任务：定义一个 NewWeight 的公开类，并继承 OldWeight 类，在该类中实现计算身高的标准体重。
|
|
|
*/
|
|
|
class OldWeight {
|
|
|
double height = 175;
|
|
|
public double getWeight(){
|
|
|
return height - 105;
|
|
|
}
|
|
|
}
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 定义一个NewWeight的公开类，并继承OldWeight类
|
|
|
public class NewWeight extends OldWeight
|
|
|
{
|
|
|
double height;
|
|
|
public NewWeight(double height)
|
|
|
{
|
|
|
this.height=height;
|
|
|
}
|
|
|
public double weight()
|
|
|
{
|
|
|
return height-105;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// 定义一个变量height，类型为double
|
|
|
|
|
|
// 定义一个有参构造方法，携带身高参数
|
|
|
|
|
|
// 定义一个方法名为weight的方法，返回类型为double，计算现在的标准体重并返回
|
|
|
|
|
|
/********** End **********/练习-Java继承和多态之成员变量隐藏
|
|
|
cjpd,1=
|
|
|
import java.util.Scanner;
|
|
|
/**
|
|
|
* 任务：判断学生的成绩是否合格（成绩分数不低于 60 ）
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明 double 类型变量 score 获取控制台输入的学生成绩
|
|
|
double score = scanner.nextDouble();
|
|
|
// 声明 int 类型变量 temp 用来保存学生成绩是否合格的结果（1 或者 0）
|
|
|
int temp;
|
|
|
/********** Begin **********/
|
|
|
// 使用三元表达式，判断变量 score 是否小于 60 ，如果小于 60 ，则将数值 0 赋值给变量 temp；反之，则将数值 1 赋值给变量 temp
|
|
|
temp = score >= 60 ? 1:0;
|
|
|
/********** End **********/
|
|
|
String result = temp == 1 ? "合格":"不合格";
|
|
|
System.out.println("该学生成绩判定为：" +result );
|
|
|
}
|
|
|
}学习-Java双路分支之条件表达式之成绩判断
|
|
|
cjtj,1=
|
|
|
/*
|
|
|
* 任务：统计每人的总分。
|
|
|
* 输出样式：x号学生的总分：y
|
|
|
*
|
|
|
* */
|
|
|
public class PassWord {
|
|
|
public static void main(String[] args) {
|
|
|
// 创建二维数组存储所有人的成绩
|
|
|
int[][] arr = new int[][]{{90,88,87},{89,90,77},{66,78,60},{77,90,90},{89,78,67},{78,87,88}};
|
|
|
|
|
|
int[] sum = new int[6];
|
|
|
|
|
|
for (int i = 0 ; i < 6; i++){
|
|
|
for (int j = 0; j < 3; j++){
|
|
|
sum[i] = arr[i][j] + sum[i];
|
|
|
}
|
|
|
|
|
|
System.out.println( (i+1) + "号学生的总分："+ sum[i]);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
}学习-Java数组之二维数值数组之多科成绩统计
|
|
|
cjzfc,1=
|
|
|
/*
|
|
|
任务：
|
|
|
1.获取输入值，第一个为整数，代表数组长度，最后一个为%，代表终止输入，中间的值为一组字符
|
|
|
2.把输入值中的第二个到倒数第二个字符赋值给一维数组
|
|
|
3.对数组排序
|
|
|
4.通过字符数组创建字符串
|
|
|
5.输出字符串
|
|
|
*/
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：获取输入值，第一个为整数，代表数组长度，最后一个为%，代表终止输入，中间的值为一组字符
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int m= scanner.nextInt();
|
|
|
char [] arr=new char[m]; // 定义原一维数组
|
|
|
int n=0;
|
|
|
while(!scanner.hasNext("%")){
|
|
|
arr[n] = scanner.next().charAt(0);
|
|
|
n++;
|
|
|
}
|
|
|
// 第二步：对字符数组排序
|
|
|
Arrays.sort(arr);
|
|
|
// 第三步：通过字符数组的方式创建字符串
|
|
|
String s = new String(arr);
|
|
|
// 第四步：输出字符串内容
|
|
|
System.out.print(s);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习- Java字符串之String类创建字符串之字符数组创建字符串
|
|
|
continue,1=
|
|
|
/*
|
|
|
任务：使用Scanner对象接收给定的一个整数，统计小于该整数的正奇数个数。
|
|
|
输出格式：5前面共有2个奇数。
|
|
|
*/
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class ContinueTest {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
// 定义变量count，用于统计奇数个数，并赋初值为0。
|
|
|
int count = 0;
|
|
|
// 创建Scanner对象
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
// 获取输入值
|
|
|
int n = sc.nextInt();
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：编写for循环从1到n之间循环取数
|
|
|
for (int i = 0;i<n;i++){
|
|
|
if (i%2==0){
|
|
|
continue;
|
|
|
}
|
|
|
count++;
|
|
|
}
|
|
|
// 第二步：判断是否为偶数，如果是，跳出本次循环，如果不是，对奇数个数变量值加1
|
|
|
System.out.println(n+"前面共有"+count+"个奇数。");
|
|
|
// 第三步：循环结束，输出总的奇数个数
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}}
|
|
|
学习-Java循环之continue
|
|
|
cxff,1=
|
|
|
/**
|
|
|
* 任务：重写 Cat 类中的 toString 方法，返回 Cat 类的基本信息。
|
|
|
*/
|
|
|
class Animal{
|
|
|
private String name; // 动物名称
|
|
|
private int age; // 动物年龄
|
|
|
|
|
|
// 返回动物类的基本信息
|
|
|
public String toString() {
|
|
|
return "Anaimal{" +
|
|
|
"name='" + name + '\'' +
|
|
|
", age=" + age +
|
|
|
'}';
|
|
|
}
|
|
|
}
|
|
|
public class Cat extends Animal{
|
|
|
private String name; // 小猫的名称
|
|
|
private int age; // 小猫年龄
|
|
|
|
|
|
public Cat(String name, int age) {
|
|
|
this.name = name;
|
|
|
this.age = age;
|
|
|
}
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
// 重写 Anaimal 中的 toString 方法，返回类型为 String，格式：我是一只名为xx的小猫，今年xx岁了
|
|
|
@Override
|
|
|
public String toString(){
|
|
|
return "我是一只名为" + name + "的小猫，今年" + age + "岁了";
|
|
|
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}学习-Java继承和多态之方法重写
|
|
|
czff,1=
|
|
|
/**
|
|
|
* 任务：使用重载方法为 Student 类创建三个构造方法。
|
|
|
* 类名为：Student
|
|
|
*/
|
|
|
public class Student {
|
|
|
private String name; // 学生的姓名
|
|
|
private String num; // 学生的学号信息
|
|
|
private double grades; // 学生的成绩
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 创建一个有参构造函数，携带一个学生姓名的参数
|
|
|
public Student (String name){
|
|
|
this.name=name;
|
|
|
}
|
|
|
// 创建一个有参构造函数，携带学生姓名和学生学号信息的参数
|
|
|
public Student(String name,String num){
|
|
|
this.name=name;
|
|
|
this.num=num;
|
|
|
}
|
|
|
// 创建一个有参构造函数，携带学生姓名、学生学号和学生成绩信息的参数
|
|
|
public Student(String name,String num,double grades){
|
|
|
this.name=name;
|
|
|
this.num=num;
|
|
|
this.grades=grades;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
|
|
|
public String getNum() {
|
|
|
return num;
|
|
|
}
|
|
|
|
|
|
public void setNum(String num) {
|
|
|
this.num = num;
|
|
|
}
|
|
|
|
|
|
public double getGrades() {
|
|
|
return grades;
|
|
|
}
|
|
|
|
|
|
public void setGrades(double grades) {
|
|
|
this.grades = grades;
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public String toString() {
|
|
|
return "Student{" +
|
|
|
"name='" + name + '\'' +
|
|
|
", num='" + num + '\'' +
|
|
|
", grades=" + grades +
|
|
|
'}';
|
|
|
}
|
|
|
|
|
|
}学习-Java继承和多态之方法重载
|
|
|
dbxmj,1=
|
|
|
/**
|
|
|
* 任务：计算一个由正方形和等腰三角形组成的多边形的面积，其中正方形边长4厘米，等腰三角形底边为正方形的一条边，其到对角顶点的高为2.6厘米。
|
|
|
* 类名为：PolygonalArea
|
|
|
*/
|
|
|
public class PolygonalArea {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
|
|
|
int square_length = 4; // 声明int型变量square_length用于表示正方形边长，并赋值 4
|
|
|
double triangle_h = 2.6; // 声明double型变量triangle_h用于表示三角形底边上的高，并赋值 2.6
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 第1步：计算正方形面积，赋值给变量area_square
|
|
|
double area_square = square_length*square_length;
|
|
|
// 第2步：计算等腰三角形面积，赋值给变量area_triangle
|
|
|
double area_triangle = square_length*triangle_h/2;
|
|
|
// 第3步：计算多边形面积，即正方形面积和等腰三角形面积，赋值给变量area_total
|
|
|
double area_total = area_square +area_triangle;
|
|
|
// 第4步：打印输出多边形面积，即使用不换行输出语句输出变量area_total的值 输出格式：该多边形的面积为 xxx 其中xxx 为多边形的面积
|
|
|
System.out.print("该多边形的面积为 "+area_total);
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
学习-Java顺序结构之无输入求多边形的面积
|
|
|
dcif,1=
|
|
|
package step3;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloStep3 {
|
|
|
public static void main(String[] args) {
|
|
|
System.out.println("星级成绩评定系统");
|
|
|
System.out.println("请输入成绩：");
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
/******start******/
|
|
|
int score = sc.nextInt();
|
|
|
if(score>90){
|
|
|
System.out.println("*****五星成绩");
|
|
|
}
|
|
|
else if(score>80){
|
|
|
System.out.println("****四星成绩");
|
|
|
}
|
|
|
else if(score>70){
|
|
|
System.out.println("***三星成绩");
|
|
|
}
|
|
|
else if(score>60){
|
|
|
System.out.println("**俩星成绩");
|
|
|
}
|
|
|
else{
|
|
|
System.out.println("无星成绩");
|
|
|
}
|
|
|
/******end******/
|
|
|
}
|
|
|
}
|
|
|
Java 分支结构之多重 if
|
|
|
dcpx,1=
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定的单词
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.next();
|
|
|
// 对单词重新排序（按照单词中的字母升序排序）
|
|
|
char[] array = str.toCharArray();
|
|
|
Arrays.sort(array);
|
|
|
// 输出新单词
|
|
|
System.out.println(array);
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}学习-Java字符串之字符串、字符数组与字节数组间的使用之单词重新排序
|
|
|
dcsl,1=
|
|
|
/*
|
|
|
任务：接收输入值（整数数列），统计出等差数列的均值，每组输入以%结束，比如1 3 5 %。
|
|
|
其中百分号的作用是：在while循环中判断输入为%时，终止循环。
|
|
|
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class WhileTest {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
// 定义变量sum，用于求等差数列的和
|
|
|
int sum=0;
|
|
|
// 定义变量z，记录等差数个数
|
|
|
int z=0;
|
|
|
// 创建Scanner对象
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
// 请在 Begin-End 间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：使用while循环接收Scanner对象接收的值，当下一个值等于%时，终止循环
|
|
|
char x = '0';
|
|
|
while(!input.hasNext("%")){
|
|
|
// 第二步：获取输入值
|
|
|
double n = input.nextDouble();
|
|
|
// 第三步：对输入的数列值求和
|
|
|
sum+=n;
|
|
|
// 第四步：统计数列个数
|
|
|
z++;
|
|
|
}
|
|
|
// 第五步：数列中值的总和，除以数列个数求出均值（保留两位小数）
|
|
|
double s=(double)sum/z;
|
|
|
System.out.print(String.format("%.2f",s));
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}练习-Java循环while之等差数列均值
|
|
|
dxsz,1=
|
|
|
/**
|
|
|
* 任务：使用对象数组的方式创建 3 个 Dog 对象
|
|
|
* 类名为：Dog
|
|
|
* 该类为 Dog 的基本属性
|
|
|
*/
|
|
|
public class Dog {
|
|
|
private String name; // 小狗名称
|
|
|
private String type; // 小狗品种
|
|
|
private int age; // 小狗年龄
|
|
|
private String hobby; //小狗爱好
|
|
|
|
|
|
public Dog(){
|
|
|
|
|
|
}
|
|
|
public Dog(String name, String type, int age, String hobby) {
|
|
|
this.name = name;
|
|
|
this.type = type;
|
|
|
this.age = age;
|
|
|
this.hobby = hobby;
|
|
|
}
|
|
|
|
|
|
// 获取Dog姓名
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
|
|
|
// 设置Dog姓名
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
// 获取Dog种类
|
|
|
public String getType() {
|
|
|
return type;
|
|
|
}
|
|
|
// 设置Dog种类
|
|
|
public void setType(String type) {
|
|
|
this.type = type;
|
|
|
}
|
|
|
// 获取Dog年龄
|
|
|
public int getAge() {
|
|
|
return age;
|
|
|
}
|
|
|
// 设置Dog年龄
|
|
|
public void setAge(int age) {
|
|
|
this.age = age;
|
|
|
}
|
|
|
|
|
|
// 获取爱好
|
|
|
public String getHobby() {
|
|
|
return hobby;
|
|
|
}
|
|
|
// 设置爱好
|
|
|
public void setHobby(String hobby) {
|
|
|
this.hobby = hobby;
|
|
|
}
|
|
|
// Dog的详细信息
|
|
|
public void info(){
|
|
|
System.out.printf("小狗名称：%s\n品种：%s\n小狗年龄：%d\n小狗爱好：%s\n",name,type,age,hobby);
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
Dog d1 = new Dog("Tom", "哈士奇",2,"拆家");
|
|
|
Dog d2 = new Dog("jerry", "中华田园犬",3,"护家");
|
|
|
Dog d3 = new Dog("旺财","柯基",2,"吃喝玩");
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 将三个狗的对象放进对象数组中，并依次调用该对象的info方法
|
|
|
Dog dog[]=new Dog[3];
|
|
|
dog[0]=d1;
|
|
|
dog[0].info();
|
|
|
dog[1]=d2;
|
|
|
dog[1].info();
|
|
|
dog[2]=d3;
|
|
|
dog[2].info();
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java类和对象之对象数组
|
|
|
dxtd,1=
|
|
|
/**
|
|
|
* 任务：使用 instanceof 运算符判断所给对象是否为特定类的一个实例，并输出判断结果。
|
|
|
*/
|
|
|
|
|
|
public class Demo {
|
|
|
public static void main(String[] args){
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
Object hello = "Hello";
|
|
|
// 判断hello是否是Object类的实例
|
|
|
if(hello instanceof Object)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
if(hello instanceof String)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
if(hello instanceof Math)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
|
|
|
// 判断hello是否是String类的实例
|
|
|
|
|
|
// 判断hello是否是Math类的实例
|
|
|
|
|
|
// 判断a是否是Object类的实例
|
|
|
String a = "hello";
|
|
|
if(a instanceof Object)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
}
|
|
|
}练习-Java继承和多态之子类对象特点
|
|
|
dxxzh,1=
|
|
|
/*
|
|
|
任务：创建一维字符数组并赋值（a，B，A，Z，v，b），并转化该数组中的大小写。
|
|
|
提示：a-z的ASCII码分别对应：97-122，A-Z的ASCII码分别对应：65-90。
|
|
|
输出样式：转化后的数组：[x,y,z]
|
|
|
*/
|
|
|
import java.util.Arrays;
|
|
|
|
|
|
public class MaxTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：创建数组并赋值，值为a，B，A，Z，v，b共6个字符。
|
|
|
char[] arr = {'a','B','A','Z','v','b'};
|
|
|
// 第二步：遍历数组元素，如果为小写，请转化为大写，如果为大写，请转化为小写。
|
|
|
//大小写的ASCII码相差32。
|
|
|
for(int i=0;i<arr.length;i++){
|
|
|
if(arr[i]>='a'&&arr[i]<='z'){
|
|
|
arr[i]-=32;
|
|
|
}
|
|
|
else if(arr[i]>='A'&&arr[i]<='Z'){
|
|
|
arr[i]+=32;
|
|
|
}
|
|
|
}
|
|
|
// 第三步：输出数组元素
|
|
|
System.out.println("转化后的数组："+Arrays.toString(arr));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java数组之一维字符数组之大小写转换
|
|
|
fcqj,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：求解该方程的值。
|
|
|
* 类名为：Equation
|
|
|
*/
|
|
|
|
|
|
public class Equation {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
Scanner reader = new Scanner(System.in);
|
|
|
double a = reader.nextDouble();
|
|
|
double b = reader.nextDouble();
|
|
|
double c = reader.nextDouble();
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：判断方程有几个根
|
|
|
double x1, x2, x3 = 0;
|
|
|
double san = b*b-4*a*c;
|
|
|
if (san > 0){
|
|
|
x1 = ((-b)+Math.sqrt(san))/(2*a);
|
|
|
x2 = ((-b)-Math.sqrt(san))/(2*a);
|
|
|
System.out.println("该方程有两个根");
|
|
|
System.out.printf("x1 = %.2f，x2 = %.2f",x1,x2);
|
|
|
}else if(san == 0 ){
|
|
|
x3 = (-b)/(2*a);
|
|
|
System.out.println("该方程只有一个根");
|
|
|
System.out.printf("x = %.2f",x3);
|
|
|
}else{
|
|
|
System.out.print("该方程无解");
|
|
|
}
|
|
|
// 第二步：如果方程有两个根，计算这两个值，将其按照题目所给的格式输出
|
|
|
|
|
|
// 第三步：如果方程只有一个跟，计算出该值，将其按照题目所给的格式输出
|
|
|
|
|
|
// 第四步：若方程无解，将其按照题目所给的格式输出
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java分支结构综合练习一之一元二次方程求解
|
|
|
ffcx,1=
|
|
|
/**
|
|
|
* 重写 Shape 中的 area 方法，计算球的表面积。
|
|
|
*/
|
|
|
class Shape {
|
|
|
private double r; //球的半径
|
|
|
// 球的体积
|
|
|
public double area(){
|
|
|
double s = (double)3/4*Math.PI*Math.pow(r,3);
|
|
|
return s;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public class Sphere extends Shape{
|
|
|
|
|
|
private double r; //球的半径
|
|
|
|
|
|
public Sphere(double r) {
|
|
|
this.r = r;
|
|
|
}
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
// 重写 Shape 中的 area 方法，计算球的表面积，将计算结果返回
|
|
|
public double area(){
|
|
|
double s = (double)4*Math.PI*Math.pow(r,2);
|
|
|
return s;
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
|
|
|
练习-Java继承和多态之方法重写
|
|
|
ffcz,1=
|
|
|
/**
|
|
|
* 任务：定义名为 print 的静态方法，携带一个参数，
|
|
|
* 无论该参数是 int 型、double 型还是字符串型，都可以将该参数进行打印。
|
|
|
*/
|
|
|
public class Print {
|
|
|
// 请在下面的Begin-End之间编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
public static void print(int a){
|
|
|
System.out.println(a);
|
|
|
}
|
|
|
public static void print(double a){
|
|
|
System.out.println(a);
|
|
|
}
|
|
|
public static void print(String a){
|
|
|
System.out.println(a);
|
|
|
}
|
|
|
public static void main(String[] args){
|
|
|
int a=10;
|
|
|
print(a);
|
|
|
double b=30.0;
|
|
|
print(b);
|
|
|
String c="zhangsan";
|
|
|
print(c);
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}练习-Java继承和多态之方法重载
|
|
|
ffszh,1=
|
|
|
|
|
|
/*
|
|
|
任务：使用while循环结合自增运算符获取控制台的一组输入（每组输入包含4个整数，其中有正有负，比如：22 33 -22 32），请求出每组输入的非负数之和
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class MyWhile {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
// 定义变量sum，用于求非负数的和，并赋初值0。
|
|
|
int sum=0;
|
|
|
// 定义变量i，用于控制循环，并赋初值1。
|
|
|
int i=1;
|
|
|
// 定义Scanner对象
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
// 请在 Begin-End 间编写代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
// 第一步：定义while循环，循环4次
|
|
|
int a =0;
|
|
|
while (i<5){
|
|
|
a = input.nextInt();
|
|
|
if (a>0){
|
|
|
sum = sum + a;
|
|
|
}
|
|
|
i++;
|
|
|
}
|
|
|
System.out.print(sum);
|
|
|
// 第二步：获取输入值
|
|
|
|
|
|
// 第三步：判断输入值是否大于0，对大于0的值累加
|
|
|
|
|
|
// 第四步：while循环中的变量加1
|
|
|
|
|
|
// 第五步：打印sum值
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
学习-Java循环while之求非负数之和
|
|
|
final,1=
|
|
|
/**
|
|
|
* 按照代码文件中提供的注释完成 Demo 类的编写，使得程序正常输出。
|
|
|
*/
|
|
|
class DemoTest{
|
|
|
int i = 10;
|
|
|
}
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
|
|
|
// 将Demo类改为 final形式
|
|
|
final class Demo{
|
|
|
// 定义一个final、static常量，名为PI，值为3.14
|
|
|
final static float PI = 3.14f;
|
|
|
// 声明一个final类型的DemoTest对象，命名为demoTest
|
|
|
final DemoTest demoTest = new DemoTest();
|
|
|
// 声明一个不为final类型的DemoTest对象，命名为demoTest2
|
|
|
DemoTest demoTest2 = new DemoTest();
|
|
|
// 声明一个final型的数组，类型为int，值为 1,2,3，命名为a
|
|
|
final int[] a ={1,2,3};
|
|
|
|
|
|
// 删除主函数中错误的代码，使得程序能够正确输出
|
|
|
public static void main(String[] args) {
|
|
|
Demo demo = new Demo();
|
|
|
System.out.println(demo.PI);
|
|
|
System.out.println(demo.demoTest2.i);
|
|
|
for (int i = 0; i < demo.a.length; i++){
|
|
|
demo.a[i] = 9;
|
|
|
System.out.println(demo.a[i]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/练习-Java继承和多态之final关键字
|
|
|
final,1=
|
|
|
/**
|
|
|
* 调试代码，对代码进行增添、删除和修改等操作，使得程序能够正常运行，输出结果请参照预期输出结果。
|
|
|
*/
|
|
|
|
|
|
// 请在下面的Begin-End之间编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
public class Demo {
|
|
|
public static void main(String args[]) {
|
|
|
Bike1 obj = new Bike1();
|
|
|
obj.run();
|
|
|
Honda honda = new Honda();
|
|
|
honda.run();
|
|
|
Yamaha yamaha = new Yamaha();
|
|
|
yamaha.run();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
class Bike1 {
|
|
|
|
|
|
int speedlimit = 90; // 定义速度限制
|
|
|
|
|
|
void run() {
|
|
|
// 修改速度限制为 120，并输出
|
|
|
speedlimit = 120;
|
|
|
System.out.println("speedlimit=120");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class Bike2 {
|
|
|
// 输出 running
|
|
|
void run() {
|
|
|
System.out.println("running");
|
|
|
}
|
|
|
}
|
|
|
// 继承 Bike2 类
|
|
|
class Honda extends Bike2 {
|
|
|
// 重写 run 方法
|
|
|
void run() {
|
|
|
System.out.println("running safely with 100kmph");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
class Bike3 {
|
|
|
}
|
|
|
// 继承 Bike3 类
|
|
|
class Yamaha extends Bike3 {
|
|
|
void run() {
|
|
|
System.out.println("running safely with 10kmph");
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/学习-Java继承和多态之final关键字
|
|
|
fsdb,1=
|
|
|
package step2;
|
|
|
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Encrypt {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
|
|
|
// 创建要发送的电报
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String data = sc.next();
|
|
|
|
|
|
// 将电报分割成字符数组
|
|
|
/********** Begin **********/
|
|
|
char[] a = data.toCharArray();
|
|
|
/********** End **********/
|
|
|
|
|
|
// 打开指定存放电报的文件，如果文件不存在，则创建
|
|
|
File file = new File("data.txt");
|
|
|
if (!file.exists()) {
|
|
|
file.createNewFile();
|
|
|
}
|
|
|
|
|
|
// 循环遍历字符数组，将每个字符加密处理
|
|
|
for (int i = 0; i < a.length; i++) {
|
|
|
a[i] = (char)(a[i] ^ 'q');
|
|
|
}
|
|
|
|
|
|
// 利用字符输出流FileWriter将加密后的字符数组写入文件中
|
|
|
/********** Begin **********/
|
|
|
FileWriter fileWriter = new FileWriter(file);
|
|
|
fileWriter.write(a, 0, a.length);
|
|
|
fileWriter.flush();
|
|
|
fileWriter.close();
|
|
|
/********** End **********/
|
|
|
|
|
|
// 利用字符输入流FileReader读取文件，将密文输出
|
|
|
/********** Begin **********/
|
|
|
FileReader fileReader = new FileReader(file);
|
|
|
char[] buffer = new char[10];
|
|
|
int x; //保存读取的数据量
|
|
|
System.out.println("密文：");
|
|
|
while ((x = fileReader.read(buffer)) != -1) {
|
|
|
System.out.print(new String(buffer));
|
|
|
}
|
|
|
fileReader.close();
|
|
|
/********** End **********/
|
|
|
|
|
|
// 利用字符输入流FileReader读取文件，将密文转换为明文输出
|
|
|
/********** Begin **********/
|
|
|
FileReader in = new FileReader(file);
|
|
|
System.out.println("\n明文：");
|
|
|
while ((x = in.read(buffer)) != -1) {
|
|
|
for (int i = 0; i < x; i++) {
|
|
|
buffer[i] = (char)(buffer[i] ^ 'q');
|
|
|
}
|
|
|
System.out.print(new String(buffer));
|
|
|
}
|
|
|
in.close();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
字符输入/输出流实现发送电报
|
|
|
fsys,1=
|
|
|
/**
|
|
|
* 任务：求两个复数相加后的结果。
|
|
|
*/
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 定义一个圆类，类名为 Complex
|
|
|
public class Complex {
|
|
|
// 定义四个变量：real1、image1、real2、image2 分别表示第一个虚数的实部与虚部和第二个虚数的实部与虚部，类型为int
|
|
|
int real1,image1,real2,image2;
|
|
|
// 定义一个成员方法，方法名为add，不带参数，实现两个复数相加，将实部结果与虚部结果用+拼接后返回，返回类型为String，
|
|
|
public String add() {
|
|
|
int real = real1 + real2;
|
|
|
int image = image1 + image2;
|
|
|
if (real != 0 && image != 0) {
|
|
|
return real + "+" + image + "i";
|
|
|
} else if (real != 0 && image == 0) {
|
|
|
return real + "";
|
|
|
} else if (real == 0 && image != 0) {
|
|
|
return image + "i";
|
|
|
} else if (real == 0 && image == 0) {
|
|
|
return "0";
|
|
|
}
|
|
|
|
|
|
// 相加后结果如果有虚部，将计算结果的虚部后加上i
|
|
|
// 如果没有虚部，只返回实部即可。
|
|
|
// 如果没有实部，只返回虚部，将计算结果的虚部后加上i
|
|
|
// 如果都没有值，返回零。
|
|
|
return " ";
|
|
|
}
|
|
|
}练习-Java类和对象之类的声明之复数运算
|
|
|
fsz,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Fraction{
|
|
|
double mole; //分子
|
|
|
double deno; //分母
|
|
|
void value(double deno,double mole){
|
|
|
if(mole == 0){
|
|
|
System.out.print("分母不能为0");
|
|
|
}else{
|
|
|
double s = deno / mole;
|
|
|
System.out.print("该分数的值为" + String.format("%.2f",s));
|
|
|
}
|
|
|
}
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
double deno = scanner.nextDouble();
|
|
|
double mole = scanner.nextDouble();
|
|
|
Fraction fraction = new Fraction();
|
|
|
fraction.value(deno,mole);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
练习- Java类和对象之构造方法与对象创建之计算数学中的分数值
|
|
|
fwxz,1=
|
|
|
/**
|
|
|
* 任务：实现图书类，该类包含了图书的基本属性和信息。
|
|
|
* 类名为：Book
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
public class Book {
|
|
|
// 定义四个私有变量
|
|
|
// 图书名称（bookName String）
|
|
|
// 图书单价（price double）
|
|
|
// 图书库存（total int）
|
|
|
// 图书id（bookId int）
|
|
|
private String bookName;
|
|
|
private double price;
|
|
|
private int total;
|
|
|
private int bookId;
|
|
|
// 获取图书名称
|
|
|
public String getBookName() {
|
|
|
return bookName;
|
|
|
}
|
|
|
// 设置图书名称
|
|
|
public void setBookName(String bookName) {
|
|
|
this.bookName=bookName;
|
|
|
}
|
|
|
// 获取图书单价
|
|
|
public double getPrice() {
|
|
|
return price;
|
|
|
}
|
|
|
// 设置图书单价
|
|
|
public void setPrice(double price) {
|
|
|
this.price=price;
|
|
|
}
|
|
|
// 获取图书库存
|
|
|
public int getTotal() {
|
|
|
return total;
|
|
|
}
|
|
|
// 设置图书库存
|
|
|
public void setTotal(int total) {
|
|
|
this.total=total;
|
|
|
}
|
|
|
// 获取图书id
|
|
|
public int getBookId() {
|
|
|
return bookId;
|
|
|
}
|
|
|
// 设置图书id
|
|
|
public void setBookId(int bookId) {
|
|
|
this.bookId=bookId;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
/********** End **********/学习-Java类和对象之访问限制
|
|
|
fzjcjk,1=
|
|
|
package case7;
|
|
|
public class interfaceTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 实例化一个 Student 的对象 s，并调用 talk()方法，打印信息
|
|
|
Student s = new Student();
|
|
|
s.talk();
|
|
|
}
|
|
|
}
|
|
|
// 声明一个 Person 接口，并在里面声明三个常量：name、age 和 occupation，并分别赋值，声明一抽象方法 talk()
|
|
|
interface Person {
|
|
|
String name = "张三";
|
|
|
int age = 18;
|
|
|
String occupation = "学生";
|
|
|
void talk();
|
|
|
}
|
|
|
// Student 类实现了 Person 接口，复写 talk()方法返回姓名、年龄和职业信息
|
|
|
class Student implements Person {
|
|
|
@Override
|
|
|
public void talk() {
|
|
|
System.out.println("学生——>姓名：" + Person.name + "，年龄：" + Person.age + "，职业：" + Person.occupation + "！");
|
|
|
}
|
|
|
}
|
|
|
封装、继承和接口
|
|
|
fzjg,1=
|
|
|
package step4;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloSwitch {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
System.out.println("请输入月份：");
|
|
|
int input = sc.nextInt(); //获取输入的月份
|
|
|
//通过输入的月份来判断当前季节并输出
|
|
|
/*****start*****/
|
|
|
switch(input){
|
|
|
case 1:System.out.println("1月是冬天");break;
|
|
|
case 2:System.out.println("2月是冬天");break;
|
|
|
case 12:System.out.println("12月是冬天");break;
|
|
|
case 3:System.out.println("3月是春天");break;
|
|
|
case 4:System.out.println("4月是春天");break;
|
|
|
case 5:System.out.println("5月是春天");break;
|
|
|
case 6:System.out.println("6月是夏天");break;
|
|
|
case 7:System.out.println("7月是夏天");break;
|
|
|
case 8:System.out.println("8月是夏天");break;
|
|
|
case 9:System.out.println("9月是秋天");break;
|
|
|
case 10:System.out.println("10月是秋天");break;
|
|
|
case 11:System.out.println("11月是秋天");break;
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}
|
|
|
Java分支结构
|
|
|
fzswitch,1=
|
|
|
package step4;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloSwitch {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
System.out.println("请输入月份：");
|
|
|
int input = sc.nextInt(); //获取输入的月份
|
|
|
//通过输入的月份来判断当前季节并输出
|
|
|
/*****start*****/
|
|
|
switch(input){
|
|
|
case 3:
|
|
|
case 4:
|
|
|
case 5:
|
|
|
System.out.println(input+"月是春天");
|
|
|
break;
|
|
|
case 6:
|
|
|
case 7:
|
|
|
case 8:
|
|
|
System.out.println(input+"月是夏天");
|
|
|
break;
|
|
|
case 9:
|
|
|
case 10:
|
|
|
case 11:
|
|
|
System.out.println(input+"月是秋天");
|
|
|
break;
|
|
|
case 1:
|
|
|
case 2:
|
|
|
case 12:
|
|
|
System.out.println(input+"月是冬天");
|
|
|
break;
|
|
|
default:
|
|
|
System.out.println("输入有误");
|
|
|
break;
|
|
|
}
|
|
|
/*****end*****/
|
|
|
}
|
|
|
}Java 分支结构之 Switch
|
|
|
fzwj,1=
|
|
|
package step4;
|
|
|
import java.io.FileInputStream;
|
|
|
import java.io.FileOutputStream;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.FileWriter;
|
|
|
import java.io.IOException;
|
|
|
public class Task {
|
|
|
|
|
|
public void task() throws IOException{
|
|
|
// 复制文本文件
|
|
|
FileReader fr = new FileReader("src/step4/input/input.txt"); //定义 FileReader 读取文件
|
|
|
int len = 0; //每次读取的字符数量
|
|
|
char[] cbuf = new char[1024]; //每次读取数据的缓冲区
|
|
|
FileWriter fw = new FileWriter("src/step4/output/output.txt"); //定义 FileWriter 写文件
|
|
|
while((len = fr.read(cbuf)) != -1){
|
|
|
fw.write(cbuf,0,len);
|
|
|
}
|
|
|
fw.close(); //释放资源 刷新缓冲区
|
|
|
fr.close();
|
|
|
|
|
|
// 复制图片文件
|
|
|
FileInputStream fs = new FileInputStream("src/step4/input/input.jpg"); //定义文件输入流读取文件信息
|
|
|
FileOutputStream fos = new FileOutputStream("src/step4/output/output.jpg");//定义文件输出流写文件
|
|
|
byte[] bys = new byte[1024]; //数据缓冲区
|
|
|
while( (len = fs.read(bys)) != -1){
|
|
|
fos.write(bys, 0, len);
|
|
|
}
|
|
|
//释放资源 刷新缓冲区
|
|
|
fs.close();
|
|
|
fos.close();
|
|
|
复制文件
|
|
|
gjz,1=
|
|
|
/**
|
|
|
* 任务：编写一个商品结算的小程序
|
|
|
* 类名为：Shop
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
public class Shop {
|
|
|
//定义该商品的两个属性：价格（double）和数量（int）
|
|
|
double price;
|
|
|
int total;
|
|
|
// 将形参的值赋值给成员变量
|
|
|
public Shop(double price, int total) {
|
|
|
this.price = price;
|
|
|
this.total = total;
|
|
|
}
|
|
|
// 该方法实现计算价钱的功能，将计算结果返回，价钱 = 价格 * 数量
|
|
|
public double sum() {
|
|
|
double sum = price * total;
|
|
|
return sum;
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/学习-Java类和对象之this关键字
|
|
|
gshsc,1=
|
|
|
import java.util.Scanner;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：接收加速度
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
int a = input.nextInt();
|
|
|
// 第二步：接收时间
|
|
|
int t = input.nextInt();
|
|
|
// 第三步：使用格式化字符串的方式输出距离
|
|
|
int v0 = 8;
|
|
|
double x = v0 * t + 0.5 * a * t *t;
|
|
|
System.out.println("当时间为" + t + "，加速度为" + a + "时，距离为" + String.format("%f",x));
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}学习-Java字符串之String类格式化字符串之多类型数据的格式化输出
|
|
|
hkjs,1=
|
|
|
/*
|
|
|
任务：编写一个程序，由用户输入住房贷款和贷款年限，程序输出不同利率下的月还款额和总还款额，利率从 5%～8%，增长间隔为 1/8。
|
|
|
例如，如果输入贷款额 10000 元人民币，贷款期限 5 年，程序应输出如下内容：
|
|
|
贷款金额: 10000
|
|
|
贷款年限: 5
|
|
|
利率 月还款额 总还款额
|
|
|
5.000% 188.71 11322.74
|
|
|
5.125% 189.28 11357.13
|
|
|
……
|
|
|
8.000% 202.76 12165.83
|
|
|
利率请保留3位小数，月还款额和总还款额请保留2位小数。
|
|
|
利率和月还款额以及总还款额之间保留4个空格。
|
|
|
思路：获取住房贷款以及贷款年限，计算不同利率下的月还款额以及总还款额。
|
|
|
*/
|
|
|
// 请在Begin-End间编写完整代码，类名请使用LoanTest
|
|
|
/********** Begin **********/
|
|
|
// 导入 Scanner 类
|
|
|
import java.util.Scanner;
|
|
|
// 定义公开类 LoanTest
|
|
|
public class LoanTest {
|
|
|
// 定义主方法 main，在该方法中完成本关任务
|
|
|
public static void main(String[] args) {
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
// 接收贷款额
|
|
|
int loan=input.nextInt();
|
|
|
// 接收贷款年限
|
|
|
int year=input.nextInt();
|
|
|
// 第一步：定义变量月还款额，并赋初值0
|
|
|
double monthlyPay=0;
|
|
|
// 第二步：定义变量总还款额，并赋初值0
|
|
|
double totalPay=0;
|
|
|
// 第三步：输出贷款额
|
|
|
System.out.println("贷款额："+loan);
|
|
|
// 第四步：输出贷款年限
|
|
|
System.out.println("贷款年限："+year);
|
|
|
// 第五步：输出利率、月还款率以及总还款率
|
|
|
System.out.println("利率"+" "+"月还款额"+" "+"总还款额");
|
|
|
for (double i=5;i<=8;i+=0.125)
|
|
|
{
|
|
|
// 月利率
|
|
|
double a=i/1200;
|
|
|
// 月还款额
|
|
|
monthlyPay=loan*a*Math.pow(1+a,12*year)/(Math.pow(1+a,12*year)-1);
|
|
|
// 总还款额
|
|
|
totalPay=12*monthlyPay*year;
|
|
|
// 格式化输出
|
|
|
System.out.printf("%.3f%%\t%.2f\t%.2f\n",i,monthlyPay,totalPay);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/ 练习-Java循环综合练习一之住房贷款还款计算
|
|
|
hmc,1=
|
|
|
import java.util.Scanner;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：接收输入的两份花名册
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str1 = input.nextLine();
|
|
|
String str2 = input.nextLine();
|
|
|
// 第二步：输出第一份花名册的长度（字符串长度）
|
|
|
System.out.println(str1.length());
|
|
|
// 第三步：输出第二份花名册的长度（字符串长度）
|
|
|
System.out.println(str2.length());
|
|
|
// 第四步：判断两个花名册是否相同，若相同，请输出相同，若不同，请输出不相同
|
|
|
boolean b = str1.equals(str2);
|
|
|
if (b){
|
|
|
System.out.println("相同");
|
|
|
}else {
|
|
|
System.out.println("不相同");
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java字符串之String类常用方法之花名册
|
|
|
jcx,1=
|
|
|
/**
|
|
|
* 任务：定义一个矩形 Rectangle 类，继承 Shape 类，
|
|
|
* 在这个类中分别定义一个名为 area 的方法，实现计算该形状面积的功能。
|
|
|
* 类名为：Rectangle
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 定义一个Rectangle的公开类，并继承Shape类
|
|
|
public class Rectangle extends Shape{
|
|
|
// 定义一个area方法，实现计算矩形面积的功能。
|
|
|
public double area(){
|
|
|
double s = getWidth() * getHeight();
|
|
|
return s;
|
|
|
}
|
|
|
|
|
|
}
|
|
|
/********** End **********/练习-Java继承和多态之子类继承性
|
|
|
jgjs,1=
|
|
|
/**
|
|
|
* 任务：计算商品打折后的价格
|
|
|
*/
|
|
|
class Total {
|
|
|
double totalMoney = 50.00;
|
|
|
public double getTotalMoney(){
|
|
|
return totalMoney;
|
|
|
}
|
|
|
}
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 定义一个Seal的公开类，并继承Total类
|
|
|
public class Seal extends Total{
|
|
|
// 定义两个变量，分别代表折扣和总价格，类型为double
|
|
|
double total;
|
|
|
double money;
|
|
|
// 定义一个有参构造方法，带两个参数，依次为折扣和总价格
|
|
|
public Seal(double total,double money){
|
|
|
this.total = total;
|
|
|
this.money = money;
|
|
|
}
|
|
|
// 定义一个方法名为sealX的方法，返回类型为double，计算打折后的商品价格并返回
|
|
|
double sealX(){
|
|
|
return total*money;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/********** End **********/学习-Java继承和多态之成员变量隐藏之优惠促销价格计算
|
|
|
jkdsy,1=
|
|
|
package step3;
|
|
|
|
|
|
// 自行设计接口和实现类
|
|
|
/********** Begin **********/
|
|
|
// 定义接口
|
|
|
interface Display {
|
|
|
public void display();
|
|
|
}
|
|
|
|
|
|
// 通知类
|
|
|
class Inform implements Display {
|
|
|
// 实现 display() 方法
|
|
|
public void display() {
|
|
|
System.out.println("通知内容");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 汽车类
|
|
|
class Car implements Display {
|
|
|
// 实现 display() 方法
|
|
|
public void display() {
|
|
|
System.out.println("汽车油量");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 广告类
|
|
|
class Adervise implements Display {
|
|
|
// 实现 display() 方法
|
|
|
public void display() {
|
|
|
System.out.println("广告消息");
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
public class Lab3_3 {
|
|
|
public static void main(String[] args) {
|
|
|
Display[] arr = { new Inform(), new Car(), new Adervise() };
|
|
|
for (Display d : arr) {
|
|
|
d.display();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
接口的使用
|
|
|
jljs,1=
|
|
|
/**
|
|
|
* 任务：已知两个点 A、B 以及坐标分别为(2,3) 、(8,-5) ，求 A 和 B 两点之间的距离。
|
|
|
* 类名为：Distance
|
|
|
*/
|
|
|
|
|
|
public class Distance {
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
|
|
|
/**
|
|
|
* 定义一个静态方法，该方法计算坐标两点的距离，携带四个参数，分别为x1、y1、x2、y2的值
|
|
|
* 将距离结果返回，返回类型为double
|
|
|
*/
|
|
|
static double point(double x1,double y1,double x2,double y2)
|
|
|
{
|
|
|
double d;
|
|
|
d=Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
|
|
|
return d;
|
|
|
}
|
|
|
public static void main(String[]args)
|
|
|
{
|
|
|
System.out.printf("A、B两点的距离为%.6f",Distance.point(2,3,8,-5)) ;
|
|
|
}
|
|
|
|
|
|
// 定义主方法
|
|
|
|
|
|
|
|
|
// 通过类名.方法名的方式调用计算两点间距离的方法，分别将A、B的x1、y1、x2、y2的值传入该方法中
|
|
|
|
|
|
// 不换行输出，输出格式: A、B两点的距离为xx
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}学习-Java类和对象之对象引用之坐标系中两点距离计算
|
|
|
jospd,1=
|
|
|
package step4;
|
|
|
|
|
|
import java.io.DataInputStream;
|
|
|
import java.io.DataOutputStream;
|
|
|
import java.io.EOFException;
|
|
|
import java.io.IOException;
|
|
|
import java.net.InetAddress;
|
|
|
import java.net.Socket;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class ClientPlus {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
ServerPlus server = new ServerPlus();
|
|
|
server.start();
|
|
|
try {
|
|
|
//创建客户端Socket(s)，指定服务器端IP地址和端口号
|
|
|
/********** Begin **********/
|
|
|
Socket s = new Socket("127.0.0.1", 8080);
|
|
|
/********** end **********/
|
|
|
DataOutputStream dos = new DataOutputStream(s.getOutputStream());
|
|
|
DataInputStream dis = new DataInputStream(s.getInputStream());
|
|
|
//客户端通过循环依次接收服务器返回的结果，并输入新的整数传递给服务器
|
|
|
/********** Begin **********/
|
|
|
while (true) {
|
|
|
System.out.println(dis.readUTF());
|
|
|
String num = sc.next();
|
|
|
dos.writeUTF(num);
|
|
|
}
|
|
|
/********** end **********/
|
|
|
} catch (EOFException e) {
|
|
|
} catch (IOException e) {
|
|
|
e.printStackTrace();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
TCP通信实现奇偶数判断
|
|
|
jsxq,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：根据输入的年月日，确定这一天是星期几。
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String args[]) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
|
|
|
// 声明 int 类型的变量 y 用来获取控制台输入的年
|
|
|
int y = scanner.nextInt();
|
|
|
// 声明 int 类型的变量 m 用来获取控制台输入的月
|
|
|
int m = scanner.nextInt();
|
|
|
// 声明 int 类型的变量 d 用来获取控制台输入的日
|
|
|
int d = scanner.nextInt();
|
|
|
/********** Begin **********/
|
|
|
// 第一步：判断变量 m 的值是否是 1 或者 2。如果是，则变量 m 在原来的基础上加12，同时变量 y 在原来的基础上减1
|
|
|
if (m==1||m==2){
|
|
|
m = m+12;
|
|
|
y = y-1;
|
|
|
}
|
|
|
int iweek =(d+2*m+3*(m + 1)/5+y+y/4-y/100+y/400)%7;
|
|
|
// 第二步：使用基姆拉尔森日期公式，计算星期几
|
|
|
if (iweek==0){
|
|
|
System.out.print("星期一");
|
|
|
}else if (iweek==1){
|
|
|
System.out.print("星期二");
|
|
|
}else if (iweek==2){
|
|
|
System.out.print("星期三");
|
|
|
}else if (iweek==3){
|
|
|
System.out.print("星期四");
|
|
|
}else if (iweek==4){
|
|
|
System.out.print("星期五");
|
|
|
}else if (iweek==5){
|
|
|
System.out.print("星期六");
|
|
|
}else if (iweek==6){
|
|
|
System.out.print("星期日");
|
|
|
}else{
|
|
|
System.out.print("无效");
|
|
|
}
|
|
|
|
|
|
// 第三步：使用多路分支判断星期几。如果是星期一，则在控制台输出"星期一"；如果是星期二，则在控制台输出"星期二"....以此类推，如果是星期日，就是在控制台输出"星期日"
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
练习-Java分支结构综合练习三之根据年月日计算星期
|
|
|
jzc,1=
|
|
|
// 请在Begin-End间编写完整代码，类名请使用Transpose
|
|
|
/********** Begin **********/
|
|
|
public class Transpose{
|
|
|
public static void main(String[] args){
|
|
|
int[][] arr1={{5,6,7},
|
|
|
{15,65,43},
|
|
|
{32,43,22},
|
|
|
{11,88,6},
|
|
|
{4,98,66}};
|
|
|
int[][] arr2={{94,65,31,87,21},
|
|
|
{48,2,0,71,98},
|
|
|
{38,29,66,88,100},};
|
|
|
int[][] arr3 = new int[arr1.length][arr2[0].length];
|
|
|
for (int i = 0; i < arr1.length; i++) {
|
|
|
for (int j = 0; j < arr2[0].length; j++) {
|
|
|
for (int k = 0; k < arr2.length; k++) {
|
|
|
arr3[i][j] += arr1[i][k] * arr2[k][j];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
print(arr3);
|
|
|
}
|
|
|
private static void print(int[][] arr) {
|
|
|
for (int i = 0; i < arr.length; i++) {
|
|
|
for (int j = 0; j < arr[0].length; j++) {
|
|
|
System.out.print(arr[i][j] + " ");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/练习-Java数组之二维数值数组之矩阵乘
|
|
|
jzj,1=
|
|
|
|
|
|
public class Transpose {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 定义二维数组并初始化
|
|
|
int [][] a = {{5,6,7},{15,65,43},{32,43,22},{11,88,6},{4,98,66}};
|
|
|
int [][] b = {{94,65,31},{0,71,98},{66,88,100},{32,7,1},{16,2,34}};
|
|
|
int [][] c = {{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};
|
|
|
// 打印求和后的新数组
|
|
|
for(int i=0;i<=4;i++){
|
|
|
for(int j=0;j<=2;j++){
|
|
|
c[i][j] = a[i][j] + b[i][j];
|
|
|
System.out.print(c[i][j] +" ");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
练习-Java数组之二维数值数组之矩阵加
|
|
|
jzzz,1=
|
|
|
package step2;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class SwapMatrix {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int[][] matrix = new int[3][3];
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
matrix[i][j] = scanner.nextInt();
|
|
|
}
|
|
|
}
|
|
|
/********** Begin **********/
|
|
|
System.out.println("原始数组为：");
|
|
|
// 打印原始数组
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
System.out.print(matrix[i][j] + " ");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
|
|
|
// 创建新的矩阵用于存放行列互调后的数组
|
|
|
int[][] swappedMatrix = new int[3][3];
|
|
|
// 行列互调
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
swappedMatrix[j][i] = matrix[i][j];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
System.out.println("行列互调后数组为：");
|
|
|
// 打印行列互调后的数组
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
System.out.print(swappedMatrix[i][j] + " ");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
/********** End **********/
|
|
|
scanner.close();
|
|
|
}
|
|
|
|
|
|
}
|
|
|
矩阵转置
|
|
|
jzzz,1=
|
|
|
public class Transpose {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 定义二维数组并初始化
|
|
|
int [][] a = {
|
|
|
{5,6,7},
|
|
|
{15,65,43},
|
|
|
{32,43,22},
|
|
|
{11,88,6},
|
|
|
{4,98,66}
|
|
|
};
|
|
|
// 定义转置后的新数组
|
|
|
int[][] b = new int [a.length][a.length];
|
|
|
// 转置数组
|
|
|
for (int i = 0;i<3;i++){
|
|
|
for (int j = 0;j<5;j++){
|
|
|
b[i][j] = a [j][i];
|
|
|
System.out.print(b[i][j]+" ");
|
|
|
}
|
|
|
System.out.println("");
|
|
|
}
|
|
|
// 打印新数组
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java数组之二维数值数组之矩阵转置
|
|
|
kbcs,1=
|
|
|
/**
|
|
|
* 定义输出考试学生的人数及姓名的方法，方法名为 print，传参的类型为String，无返回值。
|
|
|
*/
|
|
|
public class Student {
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
public static void main(String[]args){
|
|
|
Student student=new Student();
|
|
|
student.print("张翔","李晨","王明");
|
|
|
student.print("洋洋","马华");
|
|
|
}
|
|
|
public static void print(String...names){
|
|
|
int count=names.length;
|
|
|
System.out.println("本次参加考试的有"+count+"人，名单如下：");
|
|
|
for(int i=0;i<names.length;i++){
|
|
|
System.out.println(names[i]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}学习-Java类和对象之可变参数
|
|
|
key,1=
|
|
|
import java.util.Scanner;
|
|
|
public class FindTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在 Begin-End 间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 定义变量
|
|
|
int n=0;
|
|
|
int min=0;
|
|
|
int mid;
|
|
|
int count=0;
|
|
|
// 接收给定数据
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int i = scanner.nextInt(); // 数组长度
|
|
|
int key = scanner.nextInt(); // 需要查找的元素
|
|
|
// 定义数组
|
|
|
int[] arr = new int[i];
|
|
|
// 给数组赋值
|
|
|
while (!scanner.hasNext("#")){
|
|
|
int x = scanner.nextInt();
|
|
|
arr[n]=x;
|
|
|
n++;
|
|
|
}
|
|
|
// 查找给定元素索引，并输出查找次数
|
|
|
int max=arr.length-1;
|
|
|
mid=(max+min)/2;
|
|
|
while(true) {
|
|
|
count++;
|
|
|
if(key<arr[mid]) { // 如果目标元素小于中点元素
|
|
|
max = mid-1; // max向mid前移动
|
|
|
}else if(key>arr[mid]) { // 如果目标元素大于中点元素
|
|
|
min = mid+1; // min向mid后移动
|
|
|
}else {
|
|
|
System.out.print("索引值："+mid+"。查找次数："+count+"。"); // 找到目标元素
|
|
|
break;
|
|
|
}
|
|
|
if(max<min) { // 没有找到的情况
|
|
|
System.out.print("没有找到");
|
|
|
break;
|
|
|
}
|
|
|
mid=(max+min)/2; // 重新计算中间索引值
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java数组之一维数值数组之查找Key值
|
|
|
ksmm,1=
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class PassWord {
|
|
|
public static void main(String[] args) {
|
|
|
/********** Begin **********/
|
|
|
// 接收给定字符串
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int n = scanner.nextInt(); // 获取偏移量
|
|
|
String next = scanner.next(); // 获取密文
|
|
|
// 将密文添加进字符数组
|
|
|
char[] arr = new char[next.length()]; // 存储密文的数组
|
|
|
for(int i=0;i<next.length();i++){
|
|
|
char c = next.charAt(i);
|
|
|
arr[i]=c;
|
|
|
}
|
|
|
// 破解密文
|
|
|
for(int i=0;i<arr.length;i++){
|
|
|
if((char)(arr[i] + n)>90){ // 90是Z的ASCII码值，64为A的ASCII码值，这一步是考虑边界效应
|
|
|
arr[i] = (char)(arr[i] + n-90+64);
|
|
|
}else {
|
|
|
arr[i] = (char)(arr[i] + n);}
|
|
|
}
|
|
|
// 输出明文
|
|
|
System.out.print(arr);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java数组之一维字符数组之凯撒密码
|
|
|
ldjc,1=
|
|
|
package step1;
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
class Person {
|
|
|
/********** Begin **********/
|
|
|
// 自行设计类的实现
|
|
|
//姓名
|
|
|
private String name;
|
|
|
//性别
|
|
|
private String sex;
|
|
|
//年龄
|
|
|
private int age;
|
|
|
|
|
|
//构造方法
|
|
|
public Person(String name, String sex, int age){
|
|
|
this.name = name;
|
|
|
this.sex = sex;
|
|
|
this.age = age;
|
|
|
}
|
|
|
|
|
|
//重写toString()方法
|
|
|
public String toString(){
|
|
|
return name + "," + sex + "," + age;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
class Student extends Person {
|
|
|
/********** Begin **********/
|
|
|
// 自行设计类的实现
|
|
|
//学号
|
|
|
private String no;
|
|
|
//入学时间
|
|
|
private String enter;
|
|
|
//专业
|
|
|
private String major;
|
|
|
|
|
|
//构造方法
|
|
|
public Student(String name, String sex, int age, String no, String enter, String major){
|
|
|
super(name, sex, age);
|
|
|
this.no = no;
|
|
|
this.enter = enter;
|
|
|
this.major = major;
|
|
|
}
|
|
|
|
|
|
//重写toString()方法
|
|
|
public String toString(){
|
|
|
return super.toString() + "," + no + "," + enter + "," + major;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
class Teacher extends Person {
|
|
|
/********** Begin **********/
|
|
|
// 自行设计类的实现
|
|
|
//职称
|
|
|
private String pro;
|
|
|
//部门
|
|
|
private String department;
|
|
|
|
|
|
//构造方法
|
|
|
public Teacher(String name, String sex, int age, String pro, String department){
|
|
|
super(name, sex, age);
|
|
|
this.pro = pro;
|
|
|
this.department = department;
|
|
|
}
|
|
|
|
|
|
//重写toString()方法
|
|
|
public String toString(){
|
|
|
return super.toString() + "," + pro + "," + department;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
|
|
|
public class Lab3_1 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
Student student = new Student(sc.next(), sc.next(), sc.nextInt(), sc.next(), sc.next(), sc.next());
|
|
|
Teacher teacher = new Teacher(sc.next(), sc.next(), sc.nextInt(), sc.next(), sc.next());
|
|
|
System.out.println("学生基本信息为:" + student);
|
|
|
System.out.println("教师的信息为:" + teacher);
|
|
|
sc.close();
|
|
|
}
|
|
|
}
|
|
|
类的继承
|
|
|
lszd,1=
|
|
|
|
|
|
/**
|
|
|
* 任务：获取键盘两次输入的值，输出两者中的最大数。
|
|
|
* 类名为：CompareMax
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class CompareMax {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
Scanner reader = new Scanner(System.in);
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：获取键盘第一次输入的值
|
|
|
double one = reader.nextDouble();
|
|
|
// 第二步：获取键盘第二次输入的值
|
|
|
double two = reader.nextDouble();
|
|
|
// 第三步：比较两数大小
|
|
|
double max =0;
|
|
|
if (one>two){
|
|
|
max = one;
|
|
|
}else{
|
|
|
max = two;
|
|
|
}
|
|
|
// 第四步：不换行输出最大的那个值
|
|
|
System.out.print(max);
|
|
|
/********** End **********/
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Java顺序结构之数学函数之求两数最大者
|
|
|
lxdzh,1=
|
|
|
/**
|
|
|
* 判断梨类、苹果类和水果类的关系，并通过对象类型转换调用彼此的属性和方法。
|
|
|
*/
|
|
|
|
|
|
class Fruits {
|
|
|
public String name; // 定义水果名称
|
|
|
Fruits (String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 苹果类继承水果类
|
|
|
class Apple extends Fruits {
|
|
|
|
|
|
public String acolor; // 苹果颜色
|
|
|
|
|
|
public Apple(String name, String acolor) {
|
|
|
super(name);
|
|
|
this.acolor = acolor;
|
|
|
}
|
|
|
}
|
|
|
// 梨类继承水果类
|
|
|
class Pear extends Fruits {
|
|
|
public String pcolor; // 梨的颜色
|
|
|
|
|
|
public Pear(String name, String pcolor) {
|
|
|
super(name);
|
|
|
this.pcolor = pcolor;
|
|
|
}
|
|
|
}
|
|
|
public class Tests {
|
|
|
public static void main(String args[]) {
|
|
|
Fruits f = new Fruits("水果");
|
|
|
Apple a = new Apple("苹果","red");
|
|
|
Pear p = new Pear("；梨","yellow");
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
// 依次判断 f、a、p是否为 Fruits的子类对象
|
|
|
if(f instanceof Fruits)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
if(a instanceof Fruits)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
if(p instanceof Fruits)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
// 把梨类对象赋值给水果类，其中name值为bigPear,颜色为green//向上型
|
|
|
Fruits a1=new Pear("bigPear","green");//这里带参数；字符串类型要带双引号；
|
|
|
// 输出当前水果类引用的名称
|
|
|
System.out.println(a1.name);
|
|
|
// 依次判断当前水果类引用是否为水果类和梨类的子类
|
|
|
if(a1 instanceof Fruits)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
if(a1 instanceof Pear)
|
|
|
System.out.println("true");
|
|
|
else
|
|
|
System.out.println("false");
|
|
|
// 将当前水果类引用强转为梨类//向下型
|
|
|
Pear a2=(Pear) a1;
|
|
|
// 输出当前梨类的颜色
|
|
|
System.out.println(a2.pcolor);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java继承和多态之对象类型的转换
|
|
|
lxpd,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：输入单个字符，判断该字符的类型（判断输入字符是大写字母、小写字母、数字还是其他字符）。
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码。
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明 char 类型的变量 a 用来获取控制台输入
|
|
|
char a = scanner.next().charAt(0);
|
|
|
|
|
|
/********** Begin **********/
|
|
|
// 第一步：将 char 类型的变量 a 强制转换成 int 类型
|
|
|
int b = (int)a;
|
|
|
// 第二步：判断强制转换成 int 类型的变量是否大于等于 65，同时小于等于 90 ，如果满足条件，则在控制台输出"该字符是大写字母"
|
|
|
if (b>=60&&b<=90){
|
|
|
System.out.print("该字符是大写字母");
|
|
|
}else if (b >= 97 && b<=122 ){
|
|
|
// 第三步：判断强制转换成 int 类型的变量是否大于等于 97，同时小于等于 122 ，如果满足条件，则在控制台输出"该字符是小写字母"
|
|
|
System.out.print("该字符是小写字母");
|
|
|
}else if (b >=48&&b<=57){
|
|
|
// 第四步：判断强制转换成 int 类型的变量是否大于等于 48，同时小于等于 57 ，如果满足条件，则在控制台输出"该字符是数字"
|
|
|
System.out.print("该字符是数字");
|
|
|
}else{
|
|
|
System.out.print("该字符是其他字符");
|
|
|
}
|
|
|
// 第五步：如果以上条件都不满足，则在控制台输出"该字符是其他字符"
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java多路分支之字符类型判断
|
|
|
lxzh,1=
|
|
|
/**
|
|
|
* 任务：变量 a 是一个 double 型的变量，请将其强转为 int 型，
|
|
|
* 变量 b 是一个 short 型的变量，请将其转换为 double 型。
|
|
|
* 输出格式：先换行输出变量 a 转换后的结果，再不换行输出 b 转换后的结果。
|
|
|
* 类名为：Transform
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Transform {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
//创建一个Scanner的实例对象，命名为reader
|
|
|
Scanner reader = new Scanner(System.in);
|
|
|
// double型变量a
|
|
|
double a = reader.nextDouble();
|
|
|
// short型变量b
|
|
|
short b = reader.nextShort();
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：将double型变量a强转为int型
|
|
|
|
|
|
// 第二步：将short型变量b转换为double型
|
|
|
|
|
|
// 第三步：换行输出变量a转换后的结果
|
|
|
System.out.println((int)a);
|
|
|
// 第四步：不换行输出变量b转换后的结果
|
|
|
System.out.print((double)b);
|
|
|
/********** End **********/
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
学习-Java顺序结构之基本数据类型转换
|
|
|
lxzh,1=
|
|
|
/**
|
|
|
* 使用对象类型的转换，根据编程提示，完成猫类和动物类的转换，以及彼此方法和属性的调用
|
|
|
*/
|
|
|
// 定义动物类
|
|
|
class Animal{
|
|
|
// 定义动物类的属性
|
|
|
public String name = "动物";
|
|
|
public static String staticName = "可爱的动物";
|
|
|
// 定义动物类的行为方法
|
|
|
public void eat() {
|
|
|
System.out.println("动物吃饭");
|
|
|
}
|
|
|
public static void staticEat() {
|
|
|
System.out.println("可爱的动物正在在吃饭");
|
|
|
}
|
|
|
}
|
|
|
// 定义猫类，该类继承动物类
|
|
|
public class Cat extends Animal{
|
|
|
// 定义猫类的属性
|
|
|
public String name = "猫";
|
|
|
public String str = "可爱的小猫";
|
|
|
public static String staticName = "可爱的动物";
|
|
|
// 定义猫类的行为方法
|
|
|
public void eat() {
|
|
|
System.out.println("猫吃饭");
|
|
|
}
|
|
|
public static void staticEat() {
|
|
|
System.out.println("喵星人在吃饭");
|
|
|
}
|
|
|
public void eatMethod() {
|
|
|
System.out.println("猫喜欢吃鱼");
|
|
|
}
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
// 向上转型，把猫类对象赋值给动物类
|
|
|
Animal animal=new Cat();
|
|
|
// 向下转型，将动物类引用转换为猫类对象
|
|
|
Cat cat=(Cat) animal;
|
|
|
// 输出Animal类的name变量
|
|
|
System.out.println(animal.name);
|
|
|
// 输出Animal类的staticName变量
|
|
|
System.out.println(staticName);
|
|
|
// 输出Cat类的eat()方法
|
|
|
animal.eat();
|
|
|
// 输出Animal类的staticEat()方法
|
|
|
animal.staticEat();
|
|
|
// 调用Cat类的str变量
|
|
|
System.out.println(cat.str);
|
|
|
// 调用Cat类的eatMethod()方法
|
|
|
cat.eatMethod();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
学习-Java继承和多态之对象类型的转换
|
|
|
mb,1=
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 声明一个名为 com.model 的包
|
|
|
package com.model;
|
|
|
|
|
|
// 定义一个 Movie 的公开类
|
|
|
public class Movie{
|
|
|
private String name;
|
|
|
private String lei;
|
|
|
private String time;
|
|
|
private String arer;
|
|
|
public String getName()
|
|
|
{
|
|
|
return name ;
|
|
|
}
|
|
|
public void setName(String name)
|
|
|
{
|
|
|
this.name = name ;
|
|
|
}
|
|
|
|
|
|
// 该类具有电影名称、电影类别、电影时长、地区等属性（都是字符串类型、私有）
|
|
|
public String getLei()
|
|
|
{
|
|
|
return lei ;
|
|
|
}
|
|
|
public void setLei(String lei)
|
|
|
{
|
|
|
this.lei = lei;
|
|
|
}
|
|
|
public String getTime()
|
|
|
{
|
|
|
return time;
|
|
|
}
|
|
|
public void setTime(String time)
|
|
|
{
|
|
|
this.time = time ;
|
|
|
}
|
|
|
public String getArer()
|
|
|
{
|
|
|
return arer;
|
|
|
}
|
|
|
public void setArer(String arer)
|
|
|
{
|
|
|
this.arer = arer;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 定义获取和设置电影属性的方法
|
|
|
|
|
|
|
|
|
|
|
|
// 定义获取电影信息的方法，无返回值
|
|
|
public void say()
|
|
|
{
|
|
|
System.out.println("电影名称："+name+"，电影类别："+lei+"，电影时长："+time+"，地区："+arer+"。");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/********** End **********/练习-Java类和对象之包的定义
|
|
|
mdpd,1=
|
|
|
/*
|
|
|
任务：求出对战人信息。
|
|
|
输出样式：a的对手x
|
|
|
*/
|
|
|
|
|
|
public class TeamMate {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：使用循环求出与c的对战的人
|
|
|
|
|
|
// 第二步：使用循环求出与a的对战的人
|
|
|
|
|
|
// 第三步：使用循环求出与b对战的人
|
|
|
|
|
|
// 第三步：打印对战信息
|
|
|
for(char a = 'x';a <= 'z';a++) {
|
|
|
for(char b = 'x';b <= 'z';b++) {
|
|
|
if(a != b){
|
|
|
for(char c = 'x';c <= 'z';c++){
|
|
|
if( c != b && a != c){
|
|
|
if(c != 'x' && c != 'z' && a != 'x'){
|
|
|
System.out.println("a的对手"+a);
|
|
|
System.out.println("b的对手"+b);
|
|
|
System.out.println("c的对手"+c);
|
|
|
break ;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}练习-Java循环之嵌套循环之比赛名单判断
|
|
|
mjzc,1=
|
|
|
/**
|
|
|
* 任务：已知圆环的大圆半径 R 和 小圆半径 r 的长度分别为 32.0 和 10.0，求该圆环的面积和周长。
|
|
|
* 类名为：RingArea
|
|
|
*/
|
|
|
public class RingArea {
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 定义三个量，两个变量分别为大圆半径和小圆半径，常量表示π，它的值可以调用 Math.PI获取，并将其设为静态常量。
|
|
|
static double PI = Math.PI;
|
|
|
double R;
|
|
|
double r;
|
|
|
// 定义一个无参构造方法，将小圆半径设为 10.0，大圆半径设为32.0
|
|
|
public RingArea() {
|
|
|
this.R = 32.0;
|
|
|
this.r = 10.0;
|
|
|
}
|
|
|
/**
|
|
|
* 定义一个静态方法，该方法实现计算圆环的周长，携带两个参数，分别为传来的小圆半径和大圆半径的值。
|
|
|
* 将圆环周长的计算结果返回，返回类型为double
|
|
|
*/
|
|
|
public static double ring(double R,double r){
|
|
|
return 2 * PI * (R + r);
|
|
|
}
|
|
|
/**
|
|
|
* 定义一个静态方法，该方法实现计算圆环的面积，携带两个参数，分别为传来的小圆半径和大圆半径的值。
|
|
|
* 将圆环面积的计算结果返回，返回类型为double
|
|
|
*/
|
|
|
public static double area(double R,double r){
|
|
|
return PI * (R * R - r * r);
|
|
|
}
|
|
|
// 定义主方法
|
|
|
public static void main(String[] args) {
|
|
|
// 在主方法中通过定义的无参构造方法定义一个对象
|
|
|
RingArea ringArea = new RingArea();
|
|
|
// 通过类名.方法名的方式调用计算圆环周长的方法，获取圆环周长，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
|
|
|
double c = RingArea.ring(ringArea.R,ringArea.r);
|
|
|
// 通过类名.方法名的方式调用计算圆环面积的方法，获取圆环面积，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
|
|
|
double s = RingArea.area(ringArea.R,ringArea.r);
|
|
|
// 不换行四舍五入保留两位小数后格式化输出求出的值，输出格式：该圆环的周长为xx，面积为xx
|
|
|
System.out.print("该圆环的周长为" + String.format("%.2f",c));
|
|
|
System.out.print("，面积为" + String.format("%.2f",s));
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}学习-Java类和对象之static关键字之求圆环面积和周长
|
|
|
mnsj,1=
|
|
|
/**
|
|
|
* 任务：实现手机的基本功能。
|
|
|
* 类名为：Phone
|
|
|
*/
|
|
|
|
|
|
public class Phone {
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 定义五个变量，分别表示品牌、型号、价格、操作系统和内存
|
|
|
String brand;
|
|
|
String type;
|
|
|
double price;
|
|
|
String os;
|
|
|
int memory;
|
|
|
|
|
|
// 无参构造
|
|
|
public void Phone(){
|
|
|
|
|
|
}
|
|
|
|
|
|
// 有参构造
|
|
|
public void Phone(String brand,String type,double price,String os,int memory){
|
|
|
this.brand = brand;
|
|
|
this.type = type;
|
|
|
this.price = price;
|
|
|
this.os = os;
|
|
|
this.memory = memory;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 定义一个方法，该方法实现查询手机信息的方法，无返回值
|
|
|
* 输出格式：品牌：xx
|
|
|
* 型号：xx
|
|
|
* 操作系统：xx
|
|
|
* 价格：xx
|
|
|
* 内存：xx
|
|
|
* 中间用换行符隔开
|
|
|
*/
|
|
|
public void about(){
|
|
|
System.out.print("品牌：" + brand+"\n型号：" + type + "\n操作系统：" + os + "\n价格：" + price + "\n内存：" + memory + "\n正在给妈妈打电话\n正在播放浮夸" );
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 定义一个方法，该方法实现打电话的功能，无返回值，
|
|
|
* 携带一个int型参数，其中1,2,3分别表示爸爸、妈妈、姐姐的号，
|
|
|
* 输出格式 如果参数为1，换行输出：正在给爸爸打电话
|
|
|
* 如果出现其它情况，换行输出：你所拨打的电话为空号
|
|
|
*/
|
|
|
public static void main(String[] args){
|
|
|
Phone p1 = new Phone(); //在这里赋值老是报错，所以我用p1对象一个个赋值
|
|
|
p1.brand = "小米";
|
|
|
p1.type = "小米9";
|
|
|
p1.os = "Android 9";
|
|
|
p1.price = 2599.0;
|
|
|
p1.memory = 8;
|
|
|
p1.about(); //调用方法
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 定义一个方法，该方法实现听音乐的功能，无返回值
|
|
|
* 携带一个参数，其表示为歌曲名
|
|
|
* 不换行输出格式：正在播放xx
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
// 定义主方法
|
|
|
|
|
|
|
|
|
// 通过无参构造创建手机对象
|
|
|
|
|
|
// 设置手机品牌为小米，型号为小米9，操作系统为Android 9，价格为2599，运行内存为8
|
|
|
|
|
|
// 查询手机信息
|
|
|
|
|
|
// 给妈妈拨打电话
|
|
|
|
|
|
// 播放浮夸这首歌
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
练习-Java类和对象之对象引用之模拟手机功能
|
|
|
ospd,1=
|
|
|
import java.util.Scanner;
|
|
|
/**
|
|
|
* 任务：输入两个整数，判断其是否同为偶数。
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明整型变量 x ， y 获取控制台的输入
|
|
|
int x = scanner.nextInt();
|
|
|
int y = scanner.nextInt();
|
|
|
/********** Begin **********/
|
|
|
// 第一步，使用 if 语句，分别判断变量 x 和 y 是否是偶数，并且用逻辑运算符连接两个判断结果
|
|
|
if (x % 2 == 0 && y % 2== 0){
|
|
|
// 第二步，如果同为偶数，则打印输出“两个数同为偶数！”
|
|
|
System.out.print("两个数同为偶数！");
|
|
|
}else{
|
|
|
|
|
|
// 第三步，如果不同为偶数，则打印输出“两个数至少有一个数为奇数！”
|
|
|
System.out.print("两个数至少有一个数为奇数！");
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java双路分支之偶数判断
|
|
|
ospd,1=
|
|
|
import java.util.Scanner;
|
|
|
/**
|
|
|
* 任务：输入两个整数，判断其是否同为偶数。
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明整型变量 x ， y 获取控制台的输入
|
|
|
int x = scanner.nextInt();
|
|
|
int y = scanner.nextInt();
|
|
|
/********** Begin **********/
|
|
|
// 第一步，使用 if 语句，分别判断变量 x 和 y 是否是偶数，并且用逻辑运算符连接两个判断结果
|
|
|
if (x % 2 == 0 && y % 2== 0){
|
|
|
// 第二步，如果同为偶数，则打印输出“两个数同为偶数！”
|
|
|
System.out.print("两个数同为偶数！");
|
|
|
}else{
|
|
|
|
|
|
// 第三步，如果不同为偶数，则打印输出“两个数至少有一个数为奇数！”
|
|
|
System.out.print("两个数至少有一个数为奇数！");
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}Java双路分支之偶数判断
|
|
|
pdhw,1=
|
|
|
import java.util.Scanner;
|
|
|
/**
|
|
|
* 任务：判断一个给定的 5 位数是否是一个回文数
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明 int 类型的变量 num ，用来获取控制台输入
|
|
|
int num = scanner.nextInt();
|
|
|
/********** Begin **********/
|
|
|
// 第一步：获取个位数的数值
|
|
|
int ge = num%10;
|
|
|
// 第二步：获取十位数的数值
|
|
|
int shi = num/10%10;
|
|
|
// 第三步：获取百位数的数值
|
|
|
int bai = num/100%10;
|
|
|
// 第四步：获取千位数的数值
|
|
|
int qian = num/1000%10;
|
|
|
// 第五步：获取万位数的数值
|
|
|
int wan = num/10000%10;
|
|
|
// 第六步：将获取的个位数值乘以 10000
|
|
|
int gec = ge * 10000;
|
|
|
// 第七步：将获取的十位数值乘以 1000
|
|
|
int shic = shi*1000;
|
|
|
// 第八步：将获取的百位数值乘以 100
|
|
|
int baic = bai * 100;
|
|
|
// 第九步：将获取的千位数值乘以 10
|
|
|
int qianc = qian *10;
|
|
|
// 第十步：将获取的万位数值乘以 1
|
|
|
int wanc = wan *1;
|
|
|
// 第十一步：将第六、七、八、九、十步转换后的数值相加
|
|
|
int sumc = gec + shic + baic + qianc + wanc ;
|
|
|
// 第十二步：判断变量 num 是否等于第十一步的数值，如果等于，则在控制台输出“回文数”；反之，则输出“不是回文数”
|
|
|
if ( num == sumc ){
|
|
|
System.out.print("回文数");
|
|
|
}else {
|
|
|
System.out.print("不是回文数");
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}Java双路分支之判断回文数
|
|
|
pdss,1=
|
|
|
/*
|
|
|
任务：判断给定的任意一个大于 1 的正整数是否是素数。
|
|
|
素数的定义：在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的自然数。
|
|
|
思路：接收给定的正整数n，从2到n对该数取余，如果存在余数为零，那么该数不为素数，否则就是素数
|
|
|
|
|
|
如果不是：请输出“x不是一个素数”。
|
|
|
如果是：请输出“x是一个素数”。
|
|
|
|
|
|
*/
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class BreakTest {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
Scanner in = new Scanner(System.in);
|
|
|
int a = in.nextInt();
|
|
|
int p =0;
|
|
|
for (int i = 2;i<a;i++){
|
|
|
if (a%i==0){
|
|
|
p = 1;
|
|
|
}
|
|
|
}
|
|
|
if (p==0){
|
|
|
System.out.println(a + "是一个素数");
|
|
|
}else {
|
|
|
System.out.println(a + "不是一个素数");
|
|
|
}
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}学习-Java循环之break之判断素数
|
|
|
pdzfc,1=
|
|
|
/*
|
|
|
任务：
|
|
|
1.获取输入的两个字符串；
|
|
|
2.使用new分别创建两个字符串对象；
|
|
|
3.输出字符串；
|
|
|
4.分别使用equals和==比较这两个字符串是否相等。
|
|
|
输出样式见预期输出。
|
|
|
*/
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
String s = scanner.next();
|
|
|
String s1 = scanner.next();
|
|
|
// 第一步：使用new创建第一个字符串对象，并输出该字符串
|
|
|
System.out.println("获取的第一个字符串："+s);
|
|
|
// 第二步：使用new创建第二个字符串对象，并输出该字符串
|
|
|
System.out.println("获取的第二个字符串："+s1);
|
|
|
// 第三步：分别使用==和equals比较创建的两个字符串是否相等，并输出比较结果
|
|
|
System.out.print("使用==比较的结果:");
|
|
|
System.out.println(s==s1);
|
|
|
System.out.println("使用equals比较的结果:"+s.equals(s1));
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
学习-Java字符串之String类创建字符串之使用equals和==判断字符串是否相等
|
|
|
pjf,1=
|
|
|
package step3;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Score {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
|
|
|
int failCount = 0;
|
|
|
int passCount = 0;
|
|
|
int middleCount = 0;
|
|
|
int goodCount = 0;
|
|
|
int excellentCount = 0;
|
|
|
|
|
|
double totalScore = 0;
|
|
|
int studentCount = 0;
|
|
|
|
|
|
|
|
|
|
|
|
while (true) {
|
|
|
double score = input.nextDouble();
|
|
|
|
|
|
if (score == -1) {
|
|
|
break;
|
|
|
}
|
|
|
if (score < 0 || score > 100) {
|
|
|
System.out.println("请输入0~100之间的数。");
|
|
|
}
|
|
|
totalScore += score;
|
|
|
studentCount++;
|
|
|
|
|
|
if (score < 60) {
|
|
|
failCount++;
|
|
|
} else if (score < 70) {
|
|
|
passCount++;
|
|
|
} else if (score < 80) {
|
|
|
middleCount++;
|
|
|
} else if (score < 90) {
|
|
|
goodCount++;
|
|
|
} else {
|
|
|
excellentCount++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
double averageScore = totalScore / studentCount;
|
|
|
|
|
|
System.out.println("不及格的人数为：" + failCount);
|
|
|
System.out.println("及格的人数为：" + passCount);
|
|
|
System.out.println("中等的人数为：" + middleCount);
|
|
|
System.out.println("良好的人数为：" + goodCount);
|
|
|
System.out.println("优秀的人数为：" + excellentCount);
|
|
|
System.out.printf("全班平均分为：%.1f",averageScore );
|
|
|
}
|
|
|
}
|
|
|
求平均分及各个区间段的人数
|
|
|
pjz,1=
|
|
|
/*
|
|
|
任务：通过Scanner对象获取输入值n,求所有小于n的自然数的平均值。
|
|
|
输出的平均值请转化为double类型。
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class DWhileTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 定义变量n，接收输入值
|
|
|
int n;
|
|
|
// 定义求和变量sum，并赋初值0
|
|
|
int sum=0;
|
|
|
// 定义变量i,并赋初值0
|
|
|
int i=0;
|
|
|
//创建Scanner对象
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 获取输入值n
|
|
|
n = input.nextInt();
|
|
|
do{
|
|
|
if (i<n){
|
|
|
sum = sum + i ;
|
|
|
}
|
|
|
i++;
|
|
|
}
|
|
|
// 在while后判断条件，当i不小于n时退出循环
|
|
|
while(i<n);
|
|
|
// 输出平均值，保留两位小数
|
|
|
double avg=(double)sum/i;
|
|
|
System.out.println(String.format("%.2f",avg));
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
学习-Java循环do…while之前n个自然数平均值
|
|
|
pjzfc,1=
|
|
|
/*
|
|
|
任务：接收给定的加速度（第一个数）和时间（第二个数），计算该时间所处的距离。
|
|
|
|
|
|
具体输出样式见预期输出。
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：接收加速度
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int a = scanner.nextInt();
|
|
|
// 第二步：接收时间
|
|
|
int t=scanner.nextInt();
|
|
|
// 第三步：使用格式化字符串的方式输出距离
|
|
|
double s = 8.0*t+0.5*a*t*t;
|
|
|
// System.out.print("当时间为" + t);
|
|
|
// System.out.print("，加速度为" + a);
|
|
|
// System.out.print("时，距离为" + s);
|
|
|
System.out.printf("当时间为%d，加速度为%d时，距离为%.1f",t,a,s);//为啥double的输出格式是%f,而不是%lf
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java字符串之String类并置运算之字符串拼接
|
|
|
qmj,1=
|
|
|
/**
|
|
|
* 任务：已知一个球的半径为 12.0，求该球的表面积。
|
|
|
* 类名为：Sphere
|
|
|
*/
|
|
|
public class Sphere {
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 定义圆的半径和π，π为 Math中的π
|
|
|
double r;
|
|
|
// 无参构造
|
|
|
Sphere(){
|
|
|
|
|
|
}
|
|
|
// 有参构造
|
|
|
Sphere(double r){
|
|
|
this.r=r;
|
|
|
}
|
|
|
/**
|
|
|
* 定义一个方法，该方法实现计算球的表面积，返回值为double，携带一个参数，为球的半径
|
|
|
*/
|
|
|
public static double mian(double r){
|
|
|
return 4*(Math.PI)*r*r;
|
|
|
}
|
|
|
// 定义主方法
|
|
|
public static void main(String[] args){
|
|
|
// 通过无参构造创建球对象
|
|
|
Sphere sphere=new Sphere();
|
|
|
// 调用计算球面积的方法，将半径 r 的值传入
|
|
|
double result = sphere.mian(12.0);
|
|
|
// 四舍五入格式化不换行输出球的面积，输出格式：球的表面积为xx
|
|
|
System.out.print("球的表面积为"+ String.format("%.2f",result));
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
}学习-Java类和对象之参数传值机制之求球面积
|
|
|
qt,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：给定一个整数 a，判断其是否是自然数同时又是偶数。
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明 int 类型的变量 a 用来获取控制台输入
|
|
|
int a = scanner.nextInt();
|
|
|
/********** Begin **********/
|
|
|
// 第一步：判断变量 a 是否大于等于 0 ,如果符合条件，则进入第二步；反之，则在控制台输出"该数不是自然数"
|
|
|
if (a>0){
|
|
|
if (a%2==0){
|
|
|
System.out.print("该数既是自然数又是偶数");
|
|
|
}else{
|
|
|
System.out.print("该数为自然数，但不是偶数");
|
|
|
}
|
|
|
}else{
|
|
|
System.out.print("该数不是自然数");
|
|
|
}
|
|
|
// 第二步：判断变量 a 取模 2 是否为 0 ，如果为 0 ，则在控制台输出 "该数既是自然数又是偶数"；反之，则输出"该数为自然数，但不是偶数"
|
|
|
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
学习-Java分支结构之嵌套
|
|
|
qtj,1=
|
|
|
/**
|
|
|
* 任务：已知一个球的半径为 12.0，求该球的体积。
|
|
|
* 类名为：Sphere
|
|
|
*/
|
|
|
|
|
|
public class Sphere {
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 定义圆的半径和π，π为 Math中的π
|
|
|
|
|
|
double pi=Math.PI;
|
|
|
double r;
|
|
|
// 无参构造
|
|
|
Sphere()
|
|
|
{
|
|
|
this(12.0);
|
|
|
}
|
|
|
Sphere(double r1)
|
|
|
{
|
|
|
r=r1;
|
|
|
}
|
|
|
double tiji(double R)
|
|
|
{
|
|
|
return (double)4/3*pi*R*R*R;
|
|
|
}
|
|
|
|
|
|
// 有参构造
|
|
|
|
|
|
/**
|
|
|
* 定义一个方法，该方法实现计算球的体积，返回值为double，携带一个参数，为球的半径
|
|
|
*/
|
|
|
public static void main(String[]args)
|
|
|
{
|
|
|
Sphere p1=new Sphere();
|
|
|
System.out.printf("球的体积为%.2f",p1.tiji(p1.r)) ;
|
|
|
}
|
|
|
|
|
|
// 定义主方法
|
|
|
|
|
|
|
|
|
// 通过无参构造创建球对象
|
|
|
|
|
|
|
|
|
// 调用计算球体积的方法，将半径 r 的值传入
|
|
|
|
|
|
// 四舍五入格式化不换行输出球的体积，输出格式：球的体积为xx
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}练习-Java类和对象之参数传值机制之求球体积
|
|
|
qws,1=
|
|
|
/*
|
|
|
任务：接收一个整数，判断该数是否是完数。
|
|
|
完数的定义：一个数如果恰好等于它的因子之和（本身除外），这个数就称为完数。
|
|
|
例如数字6，其因子为1，2，3，6（本身除外），满足1+2+3=6，所以这个数为完数。
|
|
|
如果是完数，请输出：x是完数
|
|
|
如果不是完数，请输出：x不是完数
|
|
|
具体输出样式见预期输出。
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class ForTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 定义变量sum，用于求因子的和，并赋初值为0
|
|
|
int sum=0;
|
|
|
// 创建Scanner对象
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
// 获取输入值
|
|
|
int x = input.nextInt();
|
|
|
// 请在 Begin-End 间编写代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
// 第一步：使用for循环判断获取的整数是否为完数
|
|
|
for(int j = 1; j < x; ++j){
|
|
|
if(x % j == 0)
|
|
|
sum += j;
|
|
|
}
|
|
|
// 第二步：如果是完数，请输出x是完数
|
|
|
if(x == sum){
|
|
|
System.out.print(x+"是完数");
|
|
|
}
|
|
|
// 第三步：如果不是，请输出x不是完数
|
|
|
else{
|
|
|
System.out.print(x+"不是完数");
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}练习-Java循环for之求完数
|
|
|
rldy,1=
|
|
|
/*
|
|
|
接收一个年份数（大于等于1900）和一个月份数，打印出该月的日历。
|
|
|
日历输出格式如下：
|
|
|
==================================================
|
|
|
日 一 二 三 四 五 六
|
|
|
1
|
|
|
2 3 4 5 6 7 8
|
|
|
9 10 11 12 13 14 15
|
|
|
16 17 18 19 20 21 22
|
|
|
23 24 25 26 27 28 29
|
|
|
==================================================
|
|
|
其中日期上下的分隔符用的是50个=。
|
|
|
日期之间以及星期之间使用\t分隔。
|
|
|
1900年1月1日是星期1。
|
|
|
|
|
|
|
|
|
思路分析：
|
|
|
求1900年到输入年份之间的累计天数，其中闰年366天，平年365天；
|
|
|
求1月到输入月份之间的累计天数；
|
|
|
得到1900-1-1到输入年月之前所有天数，用总天数对7求余，对余数加1，该数值即为该月1号的星期；
|
|
|
判断输入月份有多少天；
|
|
|
控制格式打印日历。
|
|
|
*/
|
|
|
|
|
|
// 请在Begin-End间编写完整代码，类名请使用Calendar
|
|
|
/********** Begin **********/
|
|
|
// 导入 Scanner 类
|
|
|
import java.util.Scanner;
|
|
|
// 定义公开类 Calendar
|
|
|
public class Calendar{
|
|
|
// 定义主方法 main，在该方法中完成本关任务
|
|
|
public static void main(String [] args){
|
|
|
Scanner sin = new Scanner(System.in);
|
|
|
int y=sin.nextInt();
|
|
|
int m=sin.nextInt();
|
|
|
if(y<1900)
|
|
|
System.out.println("请输入大于或等于1900的年份");
|
|
|
else if(m>12||m<1)
|
|
|
System.out.println("请输入正确的月份");
|
|
|
else{
|
|
|
int sum=0; //记录一共多少天
|
|
|
int d=0; //标记某月有多少天
|
|
|
for(int i=1990;i<y;i++){ //计算整年的天数
|
|
|
if(i%4==0&&i%100!=0||i%400==0)
|
|
|
sum+=366;
|
|
|
else
|
|
|
sum+=365;
|
|
|
}
|
|
|
for(int i=1;i<=m;i++){ //计算整月的天数
|
|
|
switch(i){
|
|
|
case 2: if(y%4==0&&y%100!=0||y%400==0) d=29;
|
|
|
else d=28;break;
|
|
|
case 4:
|
|
|
case 6:
|
|
|
case 9:
|
|
|
case 11: d=30;break;
|
|
|
default : d=31;
|
|
|
}
|
|
|
if(i<m) //天数加到前一个月
|
|
|
sum+=d;
|
|
|
}
|
|
|
//System.out.println(sum);
|
|
|
|
|
|
int count=(sum+1)%7; //表示与星期一相隔几天；
|
|
|
//System.out.println(count);
|
|
|
System.out.println("==================================================");
|
|
|
System.out.println("日 一 二 三 四 五 六"); //复制测试结果中的格式
|
|
|
for(int i=1;i<=count;i++)
|
|
|
System.out.print("\t");
|
|
|
for(int i=1;i<=d;i++){
|
|
|
|
|
|
System.out.printf("%d\t",i);
|
|
|
if((i+count)%7==0)
|
|
|
System.out.println();
|
|
|
}
|
|
|
System.out.println();
|
|
|
System.out.println("==================================================");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
练习-Java循环综合练习四之日历打印
|
|
|
sbqmj,1=
|
|
|
/**
|
|
|
* 任务：根据从键盘输入的三角形的三个边长，求出三角形的面积。
|
|
|
* 类名为：TriangleArea
|
|
|
*/
|
|
|
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class TriangleArea {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner reader = new Scanner(System.in);
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：获取键盘三次输入的值
|
|
|
double a = reader.nextDouble();
|
|
|
double b = reader.nextDouble();
|
|
|
double c = reader.nextDouble();
|
|
|
// 第二步：根据三角形面积公式求取三角形面积
|
|
|
double p = (a+b+c)/2.0;
|
|
|
double s = Math.sqrt(p*(p-a)*(p-b)*(p-c));
|
|
|
|
|
|
// 第三步：格式化输出三角形的面积
|
|
|
System.out.printf("三角形的面积为：%.2f",s);
|
|
|
/********** End **********/
|
|
|
|
|
|
|
|
|
}
|
|
|
}Java顺序结构之数学函数之根据三角形三边长求面积
|
|
|
scsgs,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：按升序（从小到大）输出三个数
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明整型变量 x ， y ，z 获取控制台的输入
|
|
|
int x = scanner.nextInt();
|
|
|
int y = scanner.nextInt();
|
|
|
int z = scanner.nextInt();
|
|
|
// 声明整型变量 temp ，用于变量值的临时存储
|
|
|
int temp = 0;
|
|
|
/********** Begin **********/
|
|
|
// 使用 if 语句判断 x、y、z 的大小 ，并将三个数中的最小值赋值给 x，最大值赋值给 z。
|
|
|
if (x>y){
|
|
|
temp = y;
|
|
|
y = x;
|
|
|
x = temp;
|
|
|
}
|
|
|
if (y>z){
|
|
|
temp = y;
|
|
|
y = z;
|
|
|
z = temp;
|
|
|
}
|
|
|
if (x>y){
|
|
|
temp = y;
|
|
|
y = x;
|
|
|
x = temp;
|
|
|
}
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
System.out.println("从小到大排列:" + x + " " + y + " " + z);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
练习-Java单路分支之按序输出三个数
|
|
|
scta,1=
|
|
|
/**
|
|
|
* 任务：输出实心等腰三角形。
|
|
|
* 类名为：OutputTriangle
|
|
|
*/
|
|
|
|
|
|
public class OutputTriangle {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在下面的 Begin-End 处，按照所给的代码注释完成相应代码的编写
|
|
|
/********** Begin **********/
|
|
|
// 使用空格和*，向控制台输出一个高为4，底为7的等腰三角形，最后一个输出采用不换行输出
|
|
|
System.out.println(" *");
|
|
|
System.out.println(" ***");
|
|
|
System.out.println(" *****");
|
|
|
System.out.print("*******");
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
Java顺序结构之无输入输出给定图案
|
|
|
|
|
|
scxdx,1=
|
|
|
package step2;
|
|
|
abstract class Employee {
|
|
|
public abstract double earnings();
|
|
|
}
|
|
|
class YearWorker extends Employee {
|
|
|
@Override
|
|
|
public double earnings() {
|
|
|
|
|
|
|
|
|
return 100000.0;
|
|
|
}
|
|
|
//重写earnings()方法
|
|
|
/********** Begin **********/
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
class MonthWorker extends Employee {
|
|
|
@Override
|
|
|
public double earnings() {
|
|
|
return 120000.0;
|
|
|
}
|
|
|
//重写earnings()方法
|
|
|
/********** Begin **********/
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
class WeekWorker extends Employee {
|
|
|
@Override
|
|
|
public double earnings() {
|
|
|
//注意题目是按照28天计算
|
|
|
return 5000.0*4*12 ;
|
|
|
}
|
|
|
//重写earnings()方法
|
|
|
/********** Begin **********/
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
class Company {
|
|
|
Employee[] employees;
|
|
|
double salaries = 0;
|
|
|
Company(Employee[] employees) {
|
|
|
this.employees = employees;
|
|
|
}
|
|
|
public double salariesPay() {
|
|
|
salaries = 0;
|
|
|
//计算salaries
|
|
|
/********** Begin **********/
|
|
|
|
|
|
for (Employee employee:
|
|
|
employees) {
|
|
|
salaries+= employee.earnings();
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
return salaries;
|
|
|
}
|
|
|
}
|
|
|
public class HardWork {
|
|
|
public static void main(String[] args) {
|
|
|
// 创建了20个雇员
|
|
|
Employee[] employees = new Employee[20];
|
|
|
//区别不同工资的雇员
|
|
|
for (int i = 0; i < employees.length; i++) {
|
|
|
if(i%3==0)
|
|
|
employees[i] = new WeekWorker();
|
|
|
else if(i%3==1)
|
|
|
employees[i] = new MonthWorker();
|
|
|
else if(i%3==2)
|
|
|
employees[i] = new YearWorker();
|
|
|
}
|
|
|
Company company = new Company(employees);
|
|
|
System.out.println("公司年工资总额:" + company.salariesPay());
|
|
|
}
|
|
|
}
|
|
|
上转型对象的使用，多态的特性
|
|
|
sjgsh,1=
|
|
|
import java.util.Date;
|
|
|
import java.util.Scanner;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
|
|
|
String str = sc.nextLine(); //输入字符串
|
|
|
Date date = new Date(str); //破译字符串
|
|
|
|
|
|
String oneyearday = String.format("%tj",date); //返回一年中的第几天
|
|
|
System.out.println("该日期是这一年中的第" + oneyearday + "天");
|
|
|
|
|
|
String foryear = String.format("%tY", date); //返回4位数年份
|
|
|
String onemonth = String.format("%tm", date); //返回2位数月份
|
|
|
String onemonthday = String.format("%td", date); //返回2位数日份
|
|
|
System.out.println("该日期的年月日为：" + foryear + "-" + onemonth + "-" + onemonthday);
|
|
|
|
|
|
String hour = String.format("%tH", date); //24小时制的小时
|
|
|
String minute = String.format("%tM", date);
|
|
|
String second = String.format("%tS", date);
|
|
|
System.out.println("时：" + hour + "\n分：" + minute + "\n秒：" + second);
|
|
|
}
|
|
|
}学习-Java字符串之String类格式化字符串之日期时间格式化输出
|
|
|
sjhs,1=
|
|
|
/**
|
|
|
* 任务：从键盘输入的值分别为三角形的 a、b 两条边长和两边夹角 C 的角度，求出该三角形的面积，请对最终结果保留两位小数。
|
|
|
* 类名为：TriangleArea
|
|
|
*/
|
|
|
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class TriangleArea {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
Scanner reader = new Scanner(System.in);
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：获取键盘第一次输入的值
|
|
|
double a = reader.nextDouble();
|
|
|
// 第二步：获取键盘第二次输入的值
|
|
|
double b = reader.nextDouble();
|
|
|
// 第三步：获取键盘第三次输入的值
|
|
|
double c = reader.nextDouble();
|
|
|
// 第四步：求sinC的值
|
|
|
double rad = Math.toRadians(c);
|
|
|
double sinC = Math.sin(rad);
|
|
|
// 第五步：根据三角形面积公式求取三角形面积，此处用0.5代替1/2
|
|
|
double s = 0.5*(a*b*sinC);
|
|
|
// 第六步：不换行输出三角形的面积
|
|
|
System.out.printf("%.2f",s);
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java顺序结构之数学函数之三角函数
|
|
|
sjqc,1=
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class ArrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定的数据
|
|
|
Scanner input=new Scanner(System.in);
|
|
|
int n=input.nextInt();
|
|
|
int [] arr=new int[n];
|
|
|
for(int i=0;i<n;i++){
|
|
|
arr[i]=input.nextInt();
|
|
|
}
|
|
|
// 通过临时数组对原数组去重，最后将临时数组赋值给原数组
|
|
|
int [] aar=new int[n];
|
|
|
int z=0;
|
|
|
for(int i=0;i<n;i++){
|
|
|
int t=0;
|
|
|
for(int j=0;j<i;j++){
|
|
|
if(arr[i]==arr[j]){
|
|
|
t=1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
if(t==0)
|
|
|
aar[z++]=arr[i];
|
|
|
}
|
|
|
// 打印去重后的数组值
|
|
|
|
|
|
/********** End **********/
|
|
|
for(int i=0;i<z;i++)
|
|
|
System.out.println(aar[i]);
|
|
|
}
|
|
|
}练习-Java数组之一维数值数组之数据去重
|
|
|
sjstj,1=
|
|
|
import java.util.Random;
|
|
|
import java.util.Scanner;
|
|
|
public class RandomTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定数据
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int z = scanner.nextInt(); // 数组长度
|
|
|
long l = scanner.nextLong(); // 随机数种子
|
|
|
// 创建Random对象，并设置随机种子
|
|
|
Random random = new Random(l);
|
|
|
// 定义数组添加数据
|
|
|
int a[] = new int[z];
|
|
|
for (int i = 0; i < a.length; ++i) {
|
|
|
a[i] = random.nextInt(20);
|
|
|
}
|
|
|
// 统计每个数出现的次数
|
|
|
int b[] = new int[z];
|
|
|
for (int i = 0; i < b.length; ++i) {
|
|
|
b[i] = 0;
|
|
|
}
|
|
|
for (int i = 0; i < a.length; ++i) {
|
|
|
b[a[i]]++;
|
|
|
}
|
|
|
// 输出结果
|
|
|
for (int i = 0; i < z; ++i) {
|
|
|
if(b[i]>0) {
|
|
|
System.out.println(i + "出现了:" + b[i] + " 次");
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java数组之一维数值数组之随机数统计
|
|
|
sjx,1=
|
|
|
package step1;
|
|
|
|
|
|
|
|
|
import java.lang.Math;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
|
|
|
public class Triangle {
|
|
|
double a,b,c;
|
|
|
|
|
|
public Triangle(double a, double b, double c) {
|
|
|
this.a = a;
|
|
|
this.b = b;
|
|
|
this.c = c;
|
|
|
}
|
|
|
|
|
|
public double getArea() {
|
|
|
double s = (a + b + c) / 2;
|
|
|
return Math.sqrt(s * (s - a) * (s - b) * (s - c));
|
|
|
}
|
|
|
|
|
|
public double getPerimeter() {
|
|
|
return a + b + c;
|
|
|
}
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
Scanner input =new Scanner(System.in);
|
|
|
double a = input.nextDouble();
|
|
|
double b = input.nextDouble();
|
|
|
double c = input.nextDouble();
|
|
|
Triangle t1 = new Triangle(a, b, c);
|
|
|
System.out.printf("三角形(%.1f,%.1f,%.1f)的面积为:%.2f\n",t1.a,t1.b,t1.c,t1.getArea());
|
|
|
System.out.printf("三角形(%.1f,%.1f,%.1f)的周长为:%.2f",t1.a,t1.b,t1.c,t1.getPerimeter());
|
|
|
}
|
|
|
|
|
|
}
|
|
|
编写一个代表三角形的类
|
|
|
sltj,1=
|
|
|
/*
|
|
|
任务：统计给定一列数的正数和负数个数
|
|
|
给定的数举例：-1 2 3 -4 %
|
|
|
其中%用于while中，判断输入结束
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class DWhile {
|
|
|
public static void main(String[] args) {
|
|
|
// 定义变量positive，并赋初值0,用于统计正数个数
|
|
|
int positive=0;
|
|
|
// 定义变量negative，并赋初值0，用于统计负数个数
|
|
|
int negative=0;
|
|
|
|
|
|
// 创建Scanner对象
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
|
|
|
// 在do后的花括号中编写循环语句
|
|
|
do{
|
|
|
// 请在 Begin-End 间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步： 获取输入值
|
|
|
int n = input.nextInt();
|
|
|
// 第二步：判断输入值是否为正数，如果是，把正数个数变量positive加1
|
|
|
if(n>0){
|
|
|
positive++;
|
|
|
}
|
|
|
// 第三步：判断输入值是否为负数，如果是，把负数个数变量negative加1
|
|
|
if(n<0){
|
|
|
negative++;
|
|
|
}
|
|
|
if(n==0){
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
// 第四步：在while后判断条件，当输入值的下一个值为%时，终止循环
|
|
|
while(!input.hasNext("%"));
|
|
|
// 第五步：输出正数和复数个数，具体格式见预期输出
|
|
|
System.out.printf("正数个数为：%d。负数个数为：%d",positive,negative);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java循环do…while之正负数数量统计
|
|
|
srxq,1=
|
|
|
|
|
|
/**
|
|
|
* 任务：一小球以 v0 米/秒 的水平速度平抛，重力加速度取9.8米/秒2，
|
|
|
* 在忽略空气阻力的情况下，求经过时间 t 秒后，
|
|
|
* 小球所在位置与抛出点之间的距离 (假设小球距地面足够高)。
|
|
|
* 类名为：Distance
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Distance {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
double g = 9.8; // 声明浮点型变量 g，用于表示重力加速度
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：创建一个Scanner的实例对象，命名为reader
|
|
|
Scanner reader = new Scanner(System.in);
|
|
|
// 第二步：获取键盘第一次输入的值，将其命名为V0，用于表示水平初速度
|
|
|
double V0 = reader.nextDouble();
|
|
|
// 第三步：获取键盘第二次输入的值，将其命名为t，用于表示小球飞行的时间
|
|
|
double t = reader.nextDouble();
|
|
|
// 第四步：计算水平距离，并赋值给s
|
|
|
double s = V0*t;
|
|
|
// 第五步：计算垂直距离，并赋值给h
|
|
|
double h =g*t*t/2;
|
|
|
// 第六步：计算小球与原点的距离，并赋值给d，Math.sqrt()可以用来对括号里的值求平方根
|
|
|
double d= Math.sqrt(s*s+h*h);
|
|
|
// 第七步：打印出小球与原点的距离d，最后结果四舍五入后保留两位小数
|
|
|
System.out.printf("%.2f",d);
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Java顺序结构之有输入格式化输出平抛小球与抛出点之间的距离
|
|
|
|
|
|
ssjk,1=
|
|
|
/**
|
|
|
* 编写一个学校接待方面的程序，招待不同身份的人的食宿问题
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 定义一个接口类 Person
|
|
|
interface Person{
|
|
|
// 定义 eat()，实现输出吃饭的功能，无返回值
|
|
|
public abstract void eat();
|
|
|
// 定义 sleep()，实现睡觉的功能，无返回值
|
|
|
public abstract void sleep();
|
|
|
}
|
|
|
// 定义一个 Student 类并实现 Person 接口
|
|
|
class Student implements Person{
|
|
|
// 实现 eat()：输出：“学生去食堂吃饭。”；
|
|
|
public void eat() {
|
|
|
System.out.println("学生去食堂吃饭。");
|
|
|
}
|
|
|
// 实现 sleep()：输出：“学生在宿舍睡觉。”。
|
|
|
public void sleep() {
|
|
|
System.out.println("学生在宿舍睡觉。");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 定义一个 Teacher 类并实现 Person 接口
|
|
|
class Teacher implements Person{
|
|
|
// 实现 eat()：输出：“老师去教师食堂吃饭。”；
|
|
|
public void eat() {
|
|
|
System.out.println("老师去教师食堂吃饭。");
|
|
|
}
|
|
|
// 实现 sleep()：输出：“老师在学校公寓睡觉。”。
|
|
|
public void sleep() {
|
|
|
System.out.println("老师在学校公寓睡觉。");
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/练习-Java继承和多态之接口
|
|
|
sszd,1=
|
|
|
import java.util.Scanner;
|
|
|
/**
|
|
|
* 任务：使用单路分支的 if 语句完成从控制台输入的三个数值中获取最大值的任务
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
//声明整型变量 a ， b ，c 获取控制台的输入。
|
|
|
int a = input.nextInt();
|
|
|
int b = input.nextInt();
|
|
|
int c = input.nextInt();
|
|
|
//声明整型变量 max ， 用来存储最大值。
|
|
|
int max = 0;
|
|
|
/********** Begin **********/
|
|
|
//第一步，将变量 a 的值赋值给变量 max ，假设变量 a 的值为最大值。
|
|
|
max = a;
|
|
|
//第二步，使用 if 语句比较变量 b 与变量 max 的大小，如果值大于 max ，则将值赋值给 max。
|
|
|
if (b>max){
|
|
|
max = b;
|
|
|
}
|
|
|
//第三步，使用 if 语句比较变量 c 与变量 max 的大小，如果值大于 max ，则将值赋值给 max。
|
|
|
if (c>max){
|
|
|
max= c;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
System.out.println("最大值为：" + max);
|
|
|
}
|
|
|
}学习-Java单路分支之求三个数中最大者
|
|
|
super,1=
|
|
|
/*
|
|
|
* 定义 Person 类和 Student 类，分别实现定义各自基本属性的功能。
|
|
|
*/
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
// 声明一个名为Person的类，里面有name与age两个属性，分别为String和int型，并声明一个含有两个参数的构造方法
|
|
|
class Person//这里不需要公开的类public
|
|
|
{
|
|
|
String name;
|
|
|
int age;
|
|
|
public Person(String name,int age)
|
|
|
{
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
}
|
|
|
}
|
|
|
public class Student extends Person
|
|
|
{
|
|
|
String school;
|
|
|
Student(String name,int age,String school)
|
|
|
{
|
|
|
super(name,age);
|
|
|
this.school=school;
|
|
|
}
|
|
|
}
|
|
|
// 声明一个名为Student的类，此类继承自Person类，添加一个属性school，字符串类型
|
|
|
// 在子类的有参构造方法中调用父类中有两个参数的构造方法
|
|
|
|
|
|
|
|
|
/********** End **********/练习-Java继承和多态之super关键字
|
|
|
supergjz,1=
|
|
|
/*
|
|
|
* 根据要求补全 Salary 类，实现输出员工基本信息和薪水的功能。
|
|
|
*/
|
|
|
class Employee {
|
|
|
private String name;// 员工姓名
|
|
|
private String birth;// 出生年月
|
|
|
private String position;// 职位
|
|
|
|
|
|
// 使用有参构造方法初始化Employee
|
|
|
public Employee(String name, String birth, String position) {
|
|
|
this.name = name;
|
|
|
this.birth = birth;
|
|
|
this.position = position;
|
|
|
}
|
|
|
// 定义 introduction 方法输出员工信息
|
|
|
public void introduction() {
|
|
|
System.out.println("员工姓名：" + name + "\n出生年月：" + birth + "\n职位：" + position);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
public class Salary extends Employee {
|
|
|
private double salary; // 薪水
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
// 定义Salary的有参构造方法，同时在子类中指代父类构造器
|
|
|
public Salary(String name,String birth,String position,double salary){
|
|
|
super(name,birth,position);
|
|
|
this.salary=salary;
|
|
|
}
|
|
|
|
|
|
// 重写introduction方法，使用super保留父类原有的功能，新添输出员工薪水的功能
|
|
|
public void introduction(){
|
|
|
super.introduction();
|
|
|
System.out.print("薪水："+salary);
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}学习-Java继承和多态之super关键字
|
|
|
sxh,1=
|
|
|
/*
|
|
|
* 任务：使用for循环输出所有的水仙花数
|
|
|
*水仙花数特征：
|
|
|
- 该值处于 100（包括）到 999（包括）之间；
|
|
|
- 其个位数的三次幂，十位数的三次幂，百位数的三次幂的和等于这个数本身。
|
|
|
* 输出样式：x是一个水仙花数。
|
|
|
*/
|
|
|
|
|
|
|
|
|
public class ForTest {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
// 请在 Begin-End 间编写代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
// 第一步：使用for循环依次取999到100中的每个数，判断是否为水仙花数
|
|
|
|
|
|
for (int i = 999;i>=100;i--){
|
|
|
// 第二步：获取个位
|
|
|
int ge = i % 10;
|
|
|
// 第三步：获取十位
|
|
|
int shi = i / 10 % 10 ;
|
|
|
// 第四步：获取百位
|
|
|
int bai = i /100 % 10 ;
|
|
|
int sum =ge*ge*ge+shi*shi*shi+bai*bai*bai;
|
|
|
if (sum == i){
|
|
|
System.out.println(i+"是一个水仙花数。");
|
|
|
}
|
|
|
}
|
|
|
// 第五步：判断个位数的三次幂，十位数的三次幂，百位数的三次幂的和是否等于这个数本身，等于的话，输出该数
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}学习-Java循环for之求水仙花数
|
|
|
syfz,1=
|
|
|
package case1;
|
|
|
public class TestPersonDemo {
|
|
|
public static void main(String[] args) {
|
|
|
// 声明并实例化一个 Person 对象 p
|
|
|
Person p = new Person();
|
|
|
// 给 p 中的属性赋值
|
|
|
p.setName("张三");
|
|
|
p.setAge(18);
|
|
|
// 调用 Person 类中的 talk()方法
|
|
|
p.talk();
|
|
|
}
|
|
|
}
|
|
|
// 在这里定义 Person 类
|
|
|
class Person {
|
|
|
// 将属性私有化
|
|
|
private String name;
|
|
|
private int age;
|
|
|
// 提供公共访问方式
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
public int getAge() {
|
|
|
return age;
|
|
|
}
|
|
|
public void setAge(int age) {
|
|
|
this.age = age;
|
|
|
}
|
|
|
// 定义 talk()方法
|
|
|
public void talk() {
|
|
|
System.out.println("我是：" + name + "，今年：" + age + "岁");
|
|
|
}
|
|
|
}
|
|
|
什么是封装，如何使用封装
|
|
|
syjc,1=
|
|
|
package case2;
|
|
|
public class extendsTest {
|
|
|
public static void main(String args[]) {
|
|
|
// 实例化一个 Cat 对象，设置属性 name 和 age，调用 voice()和 eat()方法，再打印出名
|
|
|
字和年龄信息
|
|
|
/********* begin *********/
|
|
|
Cat cat = new Cat();
|
|
|
cat.setName("大花猫");
|
|
|
cat.setAge(6);
|
|
|
cat.voice();
|
|
|
cat.eat();
|
|
|
System.out.println(cat.getName() + cat.getAge() + "岁");
|
|
|
/********* end *********/
|
|
|
// 实例化一个 Dog 对象，设置属性 name 和 age，调用 voice()和 eat()方法，再打印出名
|
|
|
字和年龄信息
|
|
|
/********* begin *********/
|
|
|
Dog dog = new Dog();
|
|
|
dog.setName("大黑狗");
|
|
|
dog.setAge(8);
|
|
|
dog.voice();
|
|
|
dog.eat();
|
|
|
System.out.println(dog.getName() + dog.getAge() + "岁");
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
class Animal {
|
|
|
private String name;
|
|
|
private int age;
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
public int getAge() {
|
|
|
return age;
|
|
|
}
|
|
|
public void setAge(int age) {
|
|
|
this.age = age;
|
|
|
}
|
|
|
}
|
|
|
class Cat extends Animal {
|
|
|
// 定义 Cat 类的 voice()和 eat()方法
|
|
|
public void voice() {
|
|
|
System.out.println(getName() + "喵喵叫");
|
|
|
}
|
|
|
public void eat() {
|
|
|
System.out.println(getName() + "吃鱼");
|
|
|
}
|
|
|
}
|
|
|
class Dog extends Animal {
|
|
|
// 定义 Dog 类的 voice()和 eat()方法
|
|
|
public void voice() {
|
|
|
System.out.println(getName() + "汪汪叫");
|
|
|
}
|
|
|
public void eat() {
|
|
|
System.out.println(getName() + "吃骨头");
|
|
|
}
|
|
|
}什么是继承，怎样使用继承
|
|
|
syjs,1=
|
|
|
/**
|
|
|
* 任务：假定一个用户每月向一个储蓄帐户中存 1000 元人民币，年利率为 2.25％。那么月利率为 0.0225/12=0.001875。
|
|
|
* 编写一个程序，输出 6 个月后的账户金额。
|
|
|
* 类名为：BankRate
|
|
|
*/
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：创建一个名为 BankRate 的公开类
|
|
|
class BankRate{
|
|
|
// 第二步：在这个类中定义主方法
|
|
|
public static void main(String[] args){
|
|
|
// 第三步：在主方法中计算第六个月后总资金为多少
|
|
|
double yueli = 0.001875;
|
|
|
double a = 1000;
|
|
|
for (int i=0;i<6;i++){
|
|
|
a=a*(1+yueli);
|
|
|
}
|
|
|
// 第四步：格式化输出六个月后账户的总金额，结果保留两位小数
|
|
|
System.out.printf("%.2f",a);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
练习-Java顺序结构综合练习一之银行复利计息收益计算
|
|
|
szdsy,1=
|
|
|
package step2;
|
|
|
import java.util.Scanner;
|
|
|
public class HelloWorld {
|
|
|
public static void main(String[] args) {
|
|
|
/********** Begin **********/
|
|
|
//在这里定义一个长度为 4 的字符串数组，用来存放学生姓名
|
|
|
String[] stuNames = new String[4];
|
|
|
//在这里给 stuNames 数组赋值 分别为 张三,张无忌,张三丰,张岁山
|
|
|
stuNames[0] = "张三";
|
|
|
stuNames[1] = "张无忌";
|
|
|
stuNames[2] = "张三丰";
|
|
|
stuNames[3] = "张岁山";
|
|
|
//在这里输出 stuNames 数组中的数据
|
|
|
System.out.println("数组中的第一个数据为：" + stuNames[0]);
|
|
|
System.out.println("数组中的第二个数据为：" + stuNames[1]);
|
|
|
System.out.println("数组中的第三个数据为：" + stuNames[2]);
|
|
|
System.out.println("数组中的第四个数据为：" + stuNames[3]);
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
//在这里使用 Scanner 获取系统输入的整数,并用获取到的数据来设置 scores 数组的长度
|
|
|
System.out.print("请输入数组 scores 的长度：");
|
|
|
int length = sc.nextInt();
|
|
|
int[] scores = new int[length];
|
|
|
/********** End **********/
|
|
|
System.out.println("数组 scores 的长度为：" + scores.length);
|
|
|
}
|
|
|
}
|
|
|
数组的使用
|
|
|
szpx,1=
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class ArrTest {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 从控制台获取输入值（当输入值为%时，终止获取），并给数组赋值
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int m= scanner.nextInt();
|
|
|
int [] arr=new int[m]; // 定义一维数组
|
|
|
int n=0;
|
|
|
while(!scanner.hasNext("%")){
|
|
|
arr[n] = scanner.nextInt();
|
|
|
n++;
|
|
|
}
|
|
|
// 对数组元素求平方并排序
|
|
|
for(int i=0;i<arr.length;i++){
|
|
|
arr[i]=arr[i]*arr[i];
|
|
|
}
|
|
|
Arrays.sort(arr);
|
|
|
// 输出新数组
|
|
|
System.out.print(Arrays.toString(arr));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
练习-Java数组之Arrays类操作数组之数组排序
|
|
|
szpx,1=
|
|
|
import java.util.Scanner;
|
|
|
import java.util.Arrays;
|
|
|
public class SortTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定数据
|
|
|
int n=0;
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int x = scanner.nextInt();
|
|
|
// 定义数组
|
|
|
int[] arr = new int[x];
|
|
|
// 给数组赋值
|
|
|
while (!scanner.hasNext("#")){
|
|
|
int y = scanner.nextInt();
|
|
|
arr[n]=y;
|
|
|
n++;
|
|
|
}
|
|
|
// 使用直接选择排序法对数组升序排序，并输出每次排序的结果
|
|
|
for (int i = 0; i < arr.length - 1; i++) {
|
|
|
int min = i;
|
|
|
for (int j = i + 1; j < arr.length; j++) {
|
|
|
if (arr[min] > arr[j]) {
|
|
|
min = j;
|
|
|
}
|
|
|
}
|
|
|
if (min != i) {
|
|
|
int tmp = arr[min];
|
|
|
arr[min] = arr[i];
|
|
|
arr[i] = tmp;
|
|
|
}
|
|
|
System.out.println("第"+(i+1)+"次排序:"+Arrays.toString(arr));
|
|
|
}
|
|
|
// 输出排序后的数组
|
|
|
System.out.println("排序后的结果为："+Arrays.toString(arr));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java数组之一维数值数组之排序
|
|
|
szys,1=
|
|
|
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
public class ArrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：从控制台获取输入值（当输入值为%时，终止获取），并给数组赋值
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int m= scanner.nextInt();
|
|
|
int [] arr=new int[m]; // 定义一维数组
|
|
|
int n=0;
|
|
|
while(!scanner.hasNext("%")){
|
|
|
arr[n] = scanner.nextInt();
|
|
|
n++;
|
|
|
}
|
|
|
// 第二步：替换数组
|
|
|
for(int i=0;i<arr.length;){
|
|
|
Arrays.fill(arr,i,i+1,18);
|
|
|
i+=4;
|
|
|
}
|
|
|
// 第三步：输出替换后的数组
|
|
|
System.out.print(Arrays.toString(arr));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java数组之Arrays类操作数组之填充替换数组元素
|
|
|
tcptx,1=
|
|
|
package step3;
|
|
|
|
|
|
import java.io.DataInputStream;
|
|
|
import java.io.DataOutputStream;
|
|
|
import java.net.InetAddress;
|
|
|
import java.net.Socket;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Client {
|
|
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
|
Server server = new Server();
|
|
|
server.start();
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
|
|
|
//创建客户端Socket(s)，指定服务器端IP地址和端口号
|
|
|
/********** Begin **********/
|
|
|
Socket s = new Socket("127.0.0.1", 8080);
|
|
|
|
|
|
/********** end **********/
|
|
|
DataOutputStream dos = new DataOutputStream(s.getOutputStream());
|
|
|
DataInputStream dis = new DataInputStream(s.getInputStream());
|
|
|
System.out.println(dis.readUTF());
|
|
|
String name = sc.next();
|
|
|
dos.writeUTF(name);
|
|
|
System.out.println(dis.readUTF());
|
|
|
s.close();
|
|
|
}
|
|
|
}
|
|
|
简单TCP通信
|
|
|
tddx,1=
|
|
|
/**
|
|
|
* 任务：使用 instanceof 运算符判断指定对象是否为特定类的一个实例
|
|
|
*/
|
|
|
class Person{}
|
|
|
class Students extends Person{}
|
|
|
class Sch extends Students{}
|
|
|
public class Demos{
|
|
|
public static void main(String[] args) {
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********* Begin *********/
|
|
|
// 创建一个Students对象，判断该对象是否是Person类的实例
|
|
|
//如果是输出：true，否则为false
|
|
|
Students students=new Students();
|
|
|
if(students instanceof Person){
|
|
|
System.out.println("true");
|
|
|
}else System.out.println("false");
|
|
|
// 创建一个Sch对象，判断该对象是否是Person类的实例
|
|
|
// 输出判断结果
|
|
|
Sch sch=new Sch();
|
|
|
if(sch instanceof Person){
|
|
|
System.out.println("true");
|
|
|
}else System.out.println("false");
|
|
|
// 创建一个Person对象，判断该对象是否是Students类的实例
|
|
|
// 输出判断结果
|
|
|
Person person = new Person();
|
|
|
if(person instanceof Students){
|
|
|
System.out.println("true");
|
|
|
} else System.out.println("false");
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java继承和多态之子类对象特点
|
|
|
this,1=
|
|
|
/**
|
|
|
* 任务：定义一个完整的学生类，该类定义了学生的基本信息。
|
|
|
* 类名为：Student
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 创建一个名为 Student 的公开类
|
|
|
public class Student {
|
|
|
// 定义学生的两个属性：姓名（name String）和年龄（age int）
|
|
|
String name;
|
|
|
int age;
|
|
|
// 获取学生年龄
|
|
|
public int getAge() {
|
|
|
return age;
|
|
|
}
|
|
|
// 设置学生的年龄，将形参的值赋值给成员变量
|
|
|
public void setAge(int age) {
|
|
|
this.age = age;
|
|
|
}
|
|
|
// 获取学生姓名
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
// 设置学生姓名，将形参的值赋值给成员变量
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
// 该方法实现输出学生信息的功能。 输出格式：学生姓名：xx，年龄：xx
|
|
|
public void info() {
|
|
|
System.out.println("学生姓名："+ name +"，年龄：" + age);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/********** End **********/练习-Java类和对象之this关键字
|
|
|
tsjs,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：根据给定的年份和月份，获取该月份的天数。
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码。
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
int year = scanner.nextInt();
|
|
|
int month = scanner.nextInt();
|
|
|
int day = 0;
|
|
|
/********** Begin **********/
|
|
|
// 第一步：判断变量 month 是否为 1、3、5、7、8、10、12 内的月份，如果是，则将数值 31 赋值给变量 day
|
|
|
int[] yue1 = {1,3,5,7,8,10,12};
|
|
|
for (int i =0;i<yue1.length;i++){
|
|
|
if (month == yue1[i]){
|
|
|
day = 31;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 第二步：判断变量 month 是否为 4、6、9、11 内的月份，如果是，则将数值 30 赋值给 day
|
|
|
int[] yue2 = {4,6,9,11};
|
|
|
for (int j =0;j<yue2.length;j++){
|
|
|
if (month == yue2[j]){
|
|
|
day = 30;
|
|
|
}
|
|
|
}
|
|
|
// 第三步：如果以上条件都不满足，则进入最后一种情况
|
|
|
// 第四步：判断是否是闰年，是闰年，则将数值 29 赋值给 day；反之，则将数值 28 赋值给 day
|
|
|
if (month == 2){
|
|
|
if (year/400==0 || year / 100!=0){
|
|
|
day = 29;
|
|
|
}else {
|
|
|
day = 28;
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
System.out.print(year + "年" + month + "月有" + day + "天");
|
|
|
}
|
|
|
}练习-Java多路分支之月份天数计算
|
|
|
tymj,1=
|
|
|
public class EllipseArea {
|
|
|
double Short; //变量名不能用short，short好像会关键字报错，long也是
|
|
|
double Long;
|
|
|
|
|
|
public void EllipseArea(){
|
|
|
|
|
|
}
|
|
|
|
|
|
public void EllipseArea(double a,double b){
|
|
|
Short = a;
|
|
|
Long = b;
|
|
|
}
|
|
|
|
|
|
public double area(double a,double b){
|
|
|
double c = Math.PI * a * b; //椭圆面积 = 长轴长 * 短轴长 * π
|
|
|
return c;
|
|
|
}
|
|
|
|
|
|
public static void main(String[] args){
|
|
|
EllipseArea a = new EllipseArea();
|
|
|
double b = a.area(15.5,20.0);
|
|
|
System.out.print("椭圆形的面积为" +String.format("%.2f",b) );
|
|
|
}
|
|
|
}
|
|
|
|
|
|
学习-Java类和对象之构造方法与对象创建之求椭圆面积
|
|
|
tzsy,1=
|
|
|
/**
|
|
|
* 任务：编写程序，读入投资额、年利率和投资年限，利用题目所给公式计算投资的未来价值
|
|
|
* 类名为：Finance
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：导入Scanner类
|
|
|
import java.util.Scanner;
|
|
|
// 第二步：创建一个名为 Finance 的公开类
|
|
|
public class Finance {
|
|
|
// 第三步：定义主方法
|
|
|
public static void main(String[] arge){
|
|
|
Scanner in = new Scanner(System.in);
|
|
|
// 第四步：在主方法中，根据题目给出的计算投资的未来价值公式来计算未来价值
|
|
|
double touzi = in.nextDouble();
|
|
|
double nianli = in.nextDouble();
|
|
|
int age = in.nextInt();
|
|
|
double weilai = touzi*(Math.pow((1+(nianli/12)),12*age));
|
|
|
// 第五步：格式化输出未来价值，结果保留两位小数
|
|
|
System.out.printf("%.2f",weilai);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
练习- Java顺序结构综合练习三之金融投资收益计算
|
|
|
wdzh,1=
|
|
|
/**
|
|
|
* 任务：编写一个程序，依次将摄氏温度为 1°、2°、3°、4°、5° 所对应的华氏温度的值四舍五入后保留两位小数输出， 摄氏温度和华氏温度转换公式如下：
|
|
|
* fahrenheit（华氏温度） = ( 9/5 ) × celsius（摄氏温度） + 32。
|
|
|
* 类名为：Temperature
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：创建一个名为 Temperature 的公开类
|
|
|
public class Temperature{
|
|
|
// 第二步：在这个类中定义主方法
|
|
|
public static void main(String[] arge){
|
|
|
// 第三步：在主方法中依次计算摄氏温度为 1°、2°、3°、4°、5° 所对应的华氏温度的值，四舍五入后保留两位小数，最后格式化输出华氏温度的值，例子：摄氏温度为1时，华氏温度为xx。
|
|
|
double hua1 = (9.0/5.0)*1+32;
|
|
|
double hua2 = (9.0/5.0)*2+32;
|
|
|
double hua3 = (9.0/5.0)*3+32;
|
|
|
double hua4 = (9.0/5.0)*4+32;
|
|
|
double hua5 = (9.0/5.0)*5+32;
|
|
|
System.out.printf("摄氏温度为1时，华氏温度为%.2f。\n",hua1);
|
|
|
System.out.printf("摄氏温度为2时，华氏温度为%.2f。\n",hua2);
|
|
|
System.out.printf("摄氏温度为3时，华氏温度为%.2f。\n",hua3);
|
|
|
System.out.printf("摄氏温度为4时，华氏温度为%.2f。\n",hua4);
|
|
|
System.out.printf("摄氏温度为5时，华氏温度为%.2f。",hua5);
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/练习- Java顺序结构综合练习二之温度换算
|
|
|
wdzh,1=
|
|
|
import java.util.Scanner;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定的摄氏温度
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
int c = input.nextInt();
|
|
|
// 格式化输出对应的华氏温度
|
|
|
double f = c * (9 * 1.0 / 5) + 32;
|
|
|
System.out.println("摄氏温度" + c + "对应的华氏温度为：" + String.format("%.2f",f));
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java字符串之String类格式化字符串之温度转化
|
|
|
xqdjl,1=
|
|
|
/**
|
|
|
* 任务：一小球以 10米/秒 的水平速度平抛，重力加速度取9.8米/秒2，
|
|
|
* 在忽略空气阻力的情况下，求经过时间 3 秒后，
|
|
|
* 小球所在位置与抛出点之间的距离 (假设小球距地面足够高)。
|
|
|
* 类名为：Distance
|
|
|
*/
|
|
|
|
|
|
public class Distance {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
|
|
|
double g = 9.8; // 声明浮点型变量 g，用于表示重力加速度
|
|
|
int v0 = 10; // 声明整型变量 v0, 用于表示水平初速度
|
|
|
int t = 3; // 声明整型变量 t, 用于表示小球飞行的时间
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：计算水平距离，并赋值给s
|
|
|
int s = v0*t;
|
|
|
// 第二步：计算垂直距离，并赋值给h
|
|
|
double h = 9.8*t*t/2;
|
|
|
// 第三步：计算小球与原点的距离，并赋值给d，Math.sqrt()表示的是对括号里的值求平方根
|
|
|
double d = Math.sqrt(s*s+h*h);
|
|
|
// 第四步：打印出小球与原点的距离d 输出格式：小球所在位置与抛出点之间的距离为 xxx 米。 其中 xxx 为求出的距离
|
|
|
System.out.print("小球所在位置与抛出点之间的距离为 "+d+" 米。");
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}练习-Java顺序结构之无输入求平抛小球与抛出点之间的距离
|
|
|
xqj,1=
|
|
|
/**
|
|
|
* 任务：2017 年 1 月 1 日是星期天，求 10 天后是星期几。
|
|
|
* 类名为：Week
|
|
|
*/
|
|
|
|
|
|
public class Week {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：声明 int 型变量 pre，值为一周的总天数
|
|
|
int pre = 7;
|
|
|
// 第二步：声明 int 型变量 sum，值为几天后加上周几（2017 年 1 月 1 日是周几）的值
|
|
|
int sum = 7+ 10;
|
|
|
// 第三步：求天数除以一周的天数的余数，这个余数就是10天后为周几的值了
|
|
|
int day = sum%pre;
|
|
|
// 第四步：格式化输出这个值 如果结果是1，那么输出格式为：10天后是星期 1。
|
|
|
System.out.print("10天后是星期 " +day+"。");
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
顺序结构之无输入格式化输出求星期几
|
|
|
|
|
|
xs,1=
|
|
|
package step3;
|
|
|
|
|
|
|
|
|
|
|
|
public class Student {
|
|
|
int id;
|
|
|
int age;
|
|
|
String name;
|
|
|
|
|
|
public Student(int id, int age, String name) {
|
|
|
this.id = id;
|
|
|
this.age = age;
|
|
|
this.name = name;
|
|
|
}
|
|
|
|
|
|
public void increaseAge() {
|
|
|
this.age += 1;
|
|
|
}
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
// 创建并初始化学生数组
|
|
|
Student s1 = new Student(1, 18, "小明");
|
|
|
Student s2 = new Student(2, 20, "小张");
|
|
|
Student s3 = new Student(3, 19, "小李");
|
|
|
Student s4 = new Student(4, 18, "小王");
|
|
|
Student s5 = new Student(5, 20, "小赵");
|
|
|
|
|
|
Student s[] = { s1, s2, s3, s4, s5 }; // 给对象数组赋值
|
|
|
System.out.println("班级学生名单如下：");
|
|
|
|
|
|
// 显示所有学生信息
|
|
|
for (Student student : s) {
|
|
|
System.out.println("学号:" + student.id + ",姓名:" + student.name + ",年龄:" + student.age);
|
|
|
}
|
|
|
|
|
|
// 将所有学生年龄增加1岁
|
|
|
System.out.println("所有学生年龄加 1 后...");
|
|
|
for (Student student : s) {
|
|
|
student.increaseAge();
|
|
|
}
|
|
|
for (Student student : s) {
|
|
|
System.out.println("学号:" + student.id + ",姓名:" + student.name + ",年龄:" + student.age);
|
|
|
}
|
|
|
|
|
|
// 显示所有年龄大于20岁的学生信息
|
|
|
int number = 0;
|
|
|
for (Student student : s) {
|
|
|
if (student.age > 20) {
|
|
|
number++;
|
|
|
}
|
|
|
}
|
|
|
System.out.println("大于 20 岁人数是：" + number);
|
|
|
}
|
|
|
}
|
|
|
编写一个学生类
|
|
|
xsdx,1=
|
|
|
import java.util.Scanner;
|
|
|
public class Student {
|
|
|
private String name; // 学生的姓名
|
|
|
private String num; // 学生的学号信息
|
|
|
private double grades; // 学生的成绩
|
|
|
// 有参构造方法
|
|
|
public Student(String name, String num, double grades) {
|
|
|
this.name = name;
|
|
|
this.num = num;
|
|
|
this.grades = grades;
|
|
|
}
|
|
|
// 获取和设置学生的属性信息
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
public String getNum() {
|
|
|
return num;
|
|
|
}
|
|
|
public void setNum(String num) {
|
|
|
this.num = num;
|
|
|
}
|
|
|
public double getGrades() {
|
|
|
return grades;
|
|
|
}
|
|
|
public void setGrades(double grades) {
|
|
|
this.grades = grades;
|
|
|
}
|
|
|
public static void main(String[] args) {
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 创建可以存放三个对象的对象数组
|
|
|
Student student[] = new Student[3];
|
|
|
// 将数组中的对象进行实例化
|
|
|
for (int i = 0; i < student.length; i++) {
|
|
|
String s = scanner.next();
|
|
|
student[i]=new Student(s.split(",")[0],s.split(",")[1],Double.valueOf(s.split(",")[2]));
|
|
|
}
|
|
|
// 打印输出每个学生的信息
|
|
|
for (int i = 0; i < student.length; i++) {
|
|
|
System.out.printf("姓名：%s\t学号：%s\t成绩：%.1f\n",student[i].getName(),student[i].getNum(),student[i].getGrades());
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
} 练习-Java类和对象之对象数组
|
|
|
xsl,1=
|
|
|
/**
|
|
|
* 任务：定义一个 Student 学生公开类，该类具有学号 id(int)，年龄 age(int)，grade(int) 等属性；
|
|
|
* 它们所具有的行为有学习 study()，考试 examination()，讲话 tell()，它们都无返回值和传入的参数。
|
|
|
* 类名为：Student
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 第一步：创建一个名为 Student 的公开类
|
|
|
public class Student{
|
|
|
// 第二步：定义学生的属性
|
|
|
int id=20110624;
|
|
|
int age=18;
|
|
|
int grade=12;
|
|
|
// 第三步：定义学生的行为方法
|
|
|
public void study(){
|
|
|
System.out.println("学号为" + id +"的学生正在学习。");
|
|
|
}
|
|
|
public void examination(){
|
|
|
System.out.println(grade + "年级正在考试。");
|
|
|
}
|
|
|
public void tell(){
|
|
|
System.out.println("正在讲话的是一个"+ age +"岁的学生。");
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/学习-Java类和对象之类的声明之学生类的定义
|
|
|
ycpc,1=
|
|
|
/*
|
|
|
任务：接收给定的两个整数（第一个为被除数，第二个为除数），实现以下需求：
|
|
|
1.求这两个数的商；
|
|
|
2.当除数为 0 时，不捕获但要避免抛出运行时异常 ArithmeticException。
|
|
|
程序执行示例：
|
|
|
输入：5 3
|
|
|
输出：1
|
|
|
输入：4 0
|
|
|
输出：除数不能为0
|
|
|
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class ExcTest {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：接收给定的两个整数
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
int a = input.nextInt();
|
|
|
int b = input.nextInt();
|
|
|
// 第二步：当除数为0时，避免抛出运行时异常
|
|
|
try{
|
|
|
int x = a / b;
|
|
|
}catch (ArithmeticException e){
|
|
|
System.out.println("除数不能为0");
|
|
|
}
|
|
|
// 第三步：输出两个数的商
|
|
|
if (b != 0){
|
|
|
System.out.println(a / b);
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
学习-Java异常处理之RuntimeException之避免异常抛出
|
|
|
yfjs,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：变量 p 为每公里每吨货物的基本运费，
|
|
|
* 变量 w 为货物重量，s 为运输距离，d 为折扣，
|
|
|
* 根据题目中的总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
|
|
|
* 类名为：Logistics
|
|
|
*/
|
|
|
|
|
|
public class Logistics {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner reader = new Scanner(System.in);
|
|
|
double p = reader.nextDouble(); // 表示每公里每吨货物的基本运费
|
|
|
double w = reader.nextDouble(); // 表示货物重量
|
|
|
double s = reader.nextDouble(); // 运输距离
|
|
|
double d = 0.0;// 折扣
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
double Exp = 0;
|
|
|
// 第一步：判断该运输距离的折扣为多少 如果0 < s < 250，则折扣为0，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
|
|
|
if (s>0&&s<250){
|
|
|
Exp = p*w*s*1;
|
|
|
}else if (s>=250&&s<500){
|
|
|
Exp = p*w*s*(1-0.02);
|
|
|
}else if (s>=500&&s<1000){
|
|
|
Exp = p*w*s*(1-0.05);
|
|
|
}else{
|
|
|
Exp = p*w*s*(1-0.08);
|
|
|
}
|
|
|
System.out.printf("%.2f",Exp);
|
|
|
// 第二步：如果250 ≤ S < 500，则折扣为0.02，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
|
|
|
|
|
|
// 第三步：如果500 ≤ S < 1000，则折扣为0.05，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
|
|
|
|
|
|
|
|
|
// 第四步：如果1000 ≤ S，则折扣为0.08，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java分支结构综合练习二之物流运费计算
|
|
|
yh,1=
|
|
|
package step2;
|
|
|
|
|
|
import java.lang.Math;
|
|
|
|
|
|
public class Ring {
|
|
|
double innerRadius, outerRadius;
|
|
|
String color;
|
|
|
|
|
|
public Ring(double innerRadius, double outerRadius, String color) {
|
|
|
this.innerRadius = innerRadius;
|
|
|
this.outerRadius = outerRadius;
|
|
|
this.color = color;
|
|
|
}
|
|
|
|
|
|
public double getArea() {
|
|
|
return Math.PI * (outerRadius * outerRadius - innerRadius * innerRadius);
|
|
|
}
|
|
|
|
|
|
public double getInnerPerimeter() {
|
|
|
return 2 * Math.PI * innerRadius;
|
|
|
}
|
|
|
|
|
|
public double getOuterPerimeter() {
|
|
|
return 2 * Math.PI * outerRadius;
|
|
|
}
|
|
|
|
|
|
public void setInnerRadius(double innerRadius){
|
|
|
this.innerRadius = innerRadius;
|
|
|
}
|
|
|
|
|
|
public void setOuterRadius(double outerRadius){
|
|
|
this.outerRadius = outerRadius;
|
|
|
}
|
|
|
|
|
|
public void setColor(String color){
|
|
|
this.color = color;
|
|
|
}
|
|
|
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
Ring ring = new Ring(5, 8, "red");
|
|
|
System.out.printf("圆环的内半径: %.1f\n",ring.innerRadius);
|
|
|
System.out.printf("圆环的外半径: %.1f\n",ring.outerRadius);
|
|
|
System.out.println("圆环的颜色: "+ring.color);
|
|
|
System.out.printf("圆环的面积: %.2f\n",ring.getArea());
|
|
|
System.out.printf("圆环的外圆周长: %.2f\n",ring.getOuterPerimeter());
|
|
|
System.out.printf("圆环的内圆周长: %.2f\n",ring.getInnerPerimeter());
|
|
|
System.out.println();
|
|
|
ring.setInnerRadius(4);
|
|
|
ring.setOuterRadius(6);
|
|
|
ring.setColor("blue");
|
|
|
System.out.printf("圆环的内半径: %.1f\n",ring.innerRadius);
|
|
|
System.out.printf("圆环的外半径: %.1f\n",ring.outerRadius);
|
|
|
System.out.println("圆环的颜色: "+ring.color);
|
|
|
System.out.printf("圆环的面积: %.2f\n",ring.getArea());
|
|
|
System.out.printf("圆环的外圆周长: %.2f\n",ring.getOuterPerimeter());
|
|
|
System.out.printf("圆环的内圆周长: %.2f",ring.getInnerPerimeter());
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
编写一个圆环类
|
|
|
|
|
|
yhsjx,1=
|
|
|
/*
|
|
|
* 任务：从控制台获取输入的正整数n，打印带有n行的杨辉三角形
|
|
|
*
|
|
|
杨辉三角形的特点：
|
|
|
- 第 n 行有 n 个数字；
|
|
|
- 每一行的开始和结尾数字都为 1；
|
|
|
- 从第 3 行起，除去每一行的开始和结尾数字，其余每个数都满足以下条件：任意一个数等于上一行同列和上一行前一列的和，
|
|
|
如以下杨辉三角形中第 3 行第 2 列中的 2 等于它上一行同列（第 2 行第 2 列中的 1）和上一行前一列（第 2 行第 1 列中的 1）的和。
|
|
|
以下是有5行的杨辉三角形：
|
|
|
1
|
|
|
1 1
|
|
|
1 2 1
|
|
|
1 3 3 1
|
|
|
1 4 6 4 1
|
|
|
*/
|
|
|
import java.util.Scanner;
|
|
|
public class Test {
|
|
|
public static void main(String[] args) {
|
|
|
// 创建Scanner对象
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
// 获取输入的整数值
|
|
|
int n = input.nextInt();
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：定义外循环打印行数
|
|
|
for(int i =0;i<n;i++) {
|
|
|
int number = 1;
|
|
|
System.out.printf("%"+(n-i)*2+"s","");
|
|
|
// 第二步：定义内循环打印数字，其中数字之间以4位宽度显示，具体样式见预期输出
|
|
|
for(int j=0;j<=i;j++) {
|
|
|
System.out.format("%4d",number);
|
|
|
number = number * (i - j) / (j + 1);
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java循环综合练习三之杨辉三角形
|
|
|
ywcjtj,1=
|
|
|
/*
|
|
|
任务：仔细阅读给出的代码框架及注释，在 Begin-End 间编写程序代码，求班级数学平均成绩，具体要求如下：
|
|
|
- 接收给定的数据（如：4，88，43，43，98，#...，其中第一个数代表数组长度，
|
|
|
其余数代表班级所有人数学成绩，# 号用于终止接收数据），遇到 # 号终止接收；
|
|
|
- 求班级数学平均成绩，平均成绩用 double 类型表示。
|
|
|
注意：数字分隔符为中文逗号。
|
|
|
*/
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class ArrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：接收给定的第一个数，用于定义数组长度
|
|
|
Scanner in=new Scanner(System.in);
|
|
|
int len=in.nextInt();
|
|
|
int sum=0;
|
|
|
// 第二步：定义数组
|
|
|
int []arry=new int[len];
|
|
|
// 第三步：把成绩赋值给数组元素
|
|
|
for(int i=0;i<arry.length;i++)
|
|
|
{
|
|
|
arry[i]=in.nextInt();
|
|
|
if(in.hasNext("#"))break;
|
|
|
}
|
|
|
// 第四步：求所有成绩的和
|
|
|
for(int i=0;i<arry.length;i++)
|
|
|
{
|
|
|
sum=sum+arry[i];
|
|
|
}
|
|
|
// 第五步：求平均成绩
|
|
|
// double avg=sum/arry.length;
|
|
|
// System.out.print("数学平均成绩为："+avg);这两行需要理解；
|
|
|
System.out.print("数学平均成绩为："+(double)sum/arry.length);
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java数组之一维数值数组之成绩统计
|
|
|
yxyz,1=
|
|
|
import java.util.Scanner;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
|
|
|
String filename = scanner.nextLine();
|
|
|
String email = scanner.nextLine();
|
|
|
|
|
|
int beginIndex = filename.lastIndexOf("."); //获取最后一个点出现的位置
|
|
|
|
|
|
if(beginIndex != -1){
|
|
|
//substring（）方法：从第beginIndex下标截取，截取到末尾，返回lastName，然后直接用equals方法判断是否相等.java
|
|
|
String lastName = filename.substring(beginIndex,filename.length());
|
|
|
|
|
|
|
|
|
if(beginIndex != 0 && lastName.equals(".java")){
|
|
|
System.out.println("Java文件名正确");
|
|
|
}else{
|
|
|
System.out.println("Java文件名无效");
|
|
|
}
|
|
|
}else{
|
|
|
System.out.println("Java文件名无效");
|
|
|
}
|
|
|
|
|
|
//lastIndexOf（）方法， 获取字符串出现的位置，可以返回一个int类型
|
|
|
int atIndex = email.lastIndexOf("@"); //获取最后一个@出现的位置
|
|
|
int pointIndex = email.lastIndexOf("."); //获取最后一个.出现的位置
|
|
|
if(atIndex != -1 && atIndex < pointIndex){
|
|
|
System.out.print("邮箱名正确");
|
|
|
}else{
|
|
|
System.out.println("邮箱名无效");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
} // Scanner sc = new Scanner(System.in);
|
|
|
|
|
|
练习-Java字符串之String类常用方法之文件名与邮箱验证
|
|
|
yzmj,1=
|
|
|
class Circle{
|
|
|
static final double PI = Math.PI;
|
|
|
double r; //底面半径
|
|
|
|
|
|
public Circle(double r){
|
|
|
this.r = r;
|
|
|
}
|
|
|
|
|
|
double area(){
|
|
|
double a = PI * r * r;
|
|
|
return a;
|
|
|
}
|
|
|
}
|
|
|
//扇形类
|
|
|
class Sector {
|
|
|
double l; //母线
|
|
|
static final double PI = Math.PI;
|
|
|
double r;
|
|
|
|
|
|
public Sector(double l,double r) {
|
|
|
this.l = l;
|
|
|
this.r = r;
|
|
|
}
|
|
|
|
|
|
double area() { //圆锥侧面积
|
|
|
double s = PI * r * l;
|
|
|
return s;
|
|
|
}
|
|
|
}
|
|
|
//公开圆锥类
|
|
|
class Cone{
|
|
|
Circle circle;
|
|
|
Sector sector;
|
|
|
public Cone(Circle circle,Sector sector){
|
|
|
this.circle = circle;
|
|
|
this.sector = sector;
|
|
|
}
|
|
|
double area(){ //圆锥表面积
|
|
|
double s = circle.area() + sector.area();
|
|
|
return s;
|
|
|
}
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
Circle circle = new Circle(8); //圆对象
|
|
|
Sector sector = new Sector(8,15); //扇形对象
|
|
|
Cone cone = new Cone(circle,sector);
|
|
|
double s = cone.area();
|
|
|
|
|
|
System.out.printf("圆锥的表面积为%.2f",s);
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
练习-Java类和对象之对象组合之求圆锥体表面积
|
|
|
yzsjx,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Triangle {
|
|
|
|
|
|
|
|
|
static void judge(double a,double b,double c){
|
|
|
if(a + b > c && a + c > b && c + b > a){
|
|
|
System.out.print("这三条边可以构成三角形");
|
|
|
}else{
|
|
|
System.out.print("这三条边不能构成三角形");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// 定义主方法
|
|
|
public static void main(String[] args){
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
double a = sc.nextDouble();
|
|
|
double b = sc.nextDouble();
|
|
|
double c = sc.nextDouble();
|
|
|
judge(a,b,c);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
练习-Java类和对象之static关键字之检验三边是否构成三角形
|
|
|
yztj,1=
|
|
|
/**
|
|
|
* 任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。
|
|
|
*/
|
|
|
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 定义一个圆类，类名为 Circle
|
|
|
class Circle
|
|
|
{
|
|
|
double r;
|
|
|
double pi=Math.PI;
|
|
|
Circle(double r1)
|
|
|
{
|
|
|
r=r1;
|
|
|
}
|
|
|
double area()
|
|
|
{
|
|
|
return (double)r*r*pi;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 定义两个量，分别为半径和π值
|
|
|
|
|
|
|
|
|
// 有参构造器
|
|
|
|
|
|
|
|
|
|
|
|
// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
|
|
|
|
|
|
|
|
|
// 定义一个公开的圆柱类 Cylinder
|
|
|
public class Cylinder
|
|
|
{
|
|
|
double h;
|
|
|
Cylinder(double height)
|
|
|
{
|
|
|
h=height;
|
|
|
}
|
|
|
double tiji(double area)
|
|
|
{
|
|
|
return area*h;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// 定义圆柱中的高
|
|
|
|
|
|
// 引用圆类
|
|
|
|
|
|
|
|
|
// 有参构造
|
|
|
|
|
|
|
|
|
/**
|
|
|
* 定义一个方法，该方法实现计算圆柱的体积，返回值为double
|
|
|
*/
|
|
|
|
|
|
|
|
|
// 定义主方法
|
|
|
public static void main(String[] args) {
|
|
|
// 通过有参构造创建圆对象，将底面半径设置为 20
|
|
|
Circle c1=new Circle(20);
|
|
|
// 通过有参构造创建圆柱对象，将圆柱的高设置为 50，将圆对象传入
|
|
|
Cylinder c2=new Cylinder(50);
|
|
|
// 调用计算圆柱积的方法
|
|
|
System.out.printf("圆柱的体积为%.2f",c2.tiji(c1.area()));
|
|
|
// 四舍五入格式化不换行输出圆柱的体积，输出格式：圆柱的体积为xx
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/学习-Java类和对象之对象组合之求圆柱体积
|
|
|
zcj,1=
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
import java.util.Scanner;
|
|
|
// 第一步：创建ExcTest类
|
|
|
public class ExcTest {
|
|
|
public static void main(String[] args) throws Exception {
|
|
|
// 第二步：接收给定一行字符串
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.nextLine();
|
|
|
// 第三步：切割字符串
|
|
|
String[] array = str.split(" ");
|
|
|
int sum = 0;
|
|
|
// 第四步：遍历字符串中各科成绩，当成绩大于100或者小于0时，抛出异常，提示“成绩录入异常”
|
|
|
for (String i:array){
|
|
|
int score = Integer.parseInt(i);
|
|
|
if (score > 100 | score < 0){
|
|
|
throw new Exception("成绩录入异常");
|
|
|
}
|
|
|
sum += score;
|
|
|
}
|
|
|
// 第五步：当所有成绩处于0-100之间时，输出总成绩
|
|
|
System.out.println("该学生总成绩为：" + sum);
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
练习-Java异常处理之throw之学生总成绩
|
|
|
zfccd,1=
|
|
|
/*
|
|
|
任务：接收输入值（字符串），将该字符串反转输出，例如接收字符串"abc"，输出"cba"。
|
|
|
*/
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String str = sc.next();
|
|
|
|
|
|
char[] chars = str.toCharArray(); //将字符串转换为字符数组
|
|
|
|
|
|
for (int i = (str.length()) - 1; i >= 0; i--){ // 根据字符串长度判断i的范围
|
|
|
System.out.print(chars[i]); //逆向打印字符数组
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
学习-Java字符串之String类常用方法之字符串长度
|
|
|
zfcpj,1=
|
|
|
import java.util.Random;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class StrTest {
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：接收给定的两个字符串，第一个为名字，第二个为姓氏
|
|
|
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str1 = input.next();
|
|
|
String str2 = input.next();
|
|
|
// 第二步：拼接姓氏和名字
|
|
|
String str = str2.concat(str1);
|
|
|
// 第三步：输出姓名
|
|
|
System.out.println(str);
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
学习-Java字符串之String类并置运算之字符串拼接
|
|
|
zfcxd,1=
|
|
|
/*
|
|
|
任务：
|
|
|
1.使用字符串常量引用赋值创建以下两个字符串
|
|
|
字符串1：World
|
|
|
字符串2：world
|
|
|
2.使用equals和==比较这两个字符串是否相等
|
|
|
3.输出比较结果
|
|
|
*/
|
|
|
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// Begin
|
|
|
|
|
|
// 第一步：使用字符串常量引用赋值创建给定的两个字符串
|
|
|
String string1 = "World";
|
|
|
String string2 = "world";
|
|
|
|
|
|
// 第二步：分别使用==和equals比较创建的两个字符串是否相等，并输出比较结果
|
|
|
// 使用==比较
|
|
|
System.out.println("使用==比较的结果：" + (string1 == string2)); // 这里会输出 false，因为它们是两个不同的引用
|
|
|
|
|
|
// 使用 equals 比较
|
|
|
System.out.println("使用equals比较的结果：" + string1.equals(string2)); // 这里也会输出 false，因为内容不相同（区分大小写）
|
|
|
|
|
|
// 如果你想检查不区分大小写的相等性，可以使用 equalsIgnoreCase 方法
|
|
|
// 这里会输出 true，因为内容相同（忽略大小写）
|
|
|
|
|
|
// End
|
|
|
}
|
|
|
}练习- Java字符串之String类创建字符串之使用equals和==判断字符串是否相等
|
|
|
zfssl,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class ForeachTest {
|
|
|
public static void main(String[] args) {
|
|
|
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定一行整数
|
|
|
Scanner input=new Scanner(System.in);
|
|
|
int n = input.nextInt();
|
|
|
// 创建数组
|
|
|
int[] a= new int[n];
|
|
|
// 把给定整数添加到数组中
|
|
|
for(int i=0;i<a.length;i++){
|
|
|
a[i] =input.nextInt();
|
|
|
}
|
|
|
// 获取数组中的每个数，统计正负数个数
|
|
|
int fu=0,zheng=0;
|
|
|
for(int i=0;i<a.length;i++){
|
|
|
if(a[i]<0){
|
|
|
fu++;
|
|
|
}
|
|
|
else zheng++;
|
|
|
}
|
|
|
// 输出结果
|
|
|
System.out.println("正数个数："+zheng+"。负数个数："+fu+"。");
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}学习-Java数组之foreach遍历数组之正负数数量统计
|
|
|
zhgpa,1=
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
/**
|
|
|
* 任务：给出一个 GPA 成绩，输出与之对应的百分制成绩区间。
|
|
|
*/
|
|
|
public class ApplicationTest {
|
|
|
|
|
|
/**
|
|
|
* 请在下面的 Begin - End 之间按照注释中给出的提示编写正确的代码
|
|
|
*/
|
|
|
public static void main(String[] args) {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
// 声明 char 类型的变量 score 用来获取控制台输入的成绩
|
|
|
char score = scanner.next().charAt(0);
|
|
|
/********** Begin **********/
|
|
|
switch (score){
|
|
|
case 'A' :
|
|
|
System.out.print("百分制分数段为90分以上");
|
|
|
break;
|
|
|
case 'B' :
|
|
|
System.out.print("百分制分数段为80-89分");
|
|
|
break;
|
|
|
case 'C' :
|
|
|
System.out.print("百分制分数段为70-79分");
|
|
|
break;
|
|
|
case 'D' :
|
|
|
System.out.print("百分制分数段为60-69分");
|
|
|
break;
|
|
|
case 'E' :
|
|
|
System.out.print("百分制分数段为60分以下");
|
|
|
break;
|
|
|
}
|
|
|
/**
|
|
|
* 使用 switch 构建 A 、B、C、D、E 五条分支
|
|
|
* 分支 A ，控制台输出 “百分制分数段为90分以上”
|
|
|
* 分支 B ，控制台输出 “百分制分数段为80-89分”
|
|
|
* 分支 C ，控制台输出 “百分制分数段为70-79分”
|
|
|
* 分支 D ，控制台输出 “百分制分数段为60-69分”
|
|
|
* 分支 E ，控制台输出 “百分制分数段为60分以下”
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
学习-Java多路分支之switch之百分制成绩转换GPA成绩
|
|
|
zhlx,1=
|
|
|
|
|
|
/**
|
|
|
* 按照动物、宠物、猫和蜘蛛的关系，通过编程实现各自的关系并声明自己的属性和方法。
|
|
|
*/
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 创建Animal类，它是所有动物的抽象父类
|
|
|
abstract class Animal {
|
|
|
// 声明一个受保护的字符串类型属性type，它记录动物的种类
|
|
|
protected String type;
|
|
|
// 声明一个受保护的整数类型属性legs，它记录动物的腿的数目
|
|
|
protected int legs;
|
|
|
// 定义一个受保护的有参构造器，用来初始化type和legs属性
|
|
|
protected Animal(String type,int legs){
|
|
|
this.type = type;
|
|
|
this.legs = legs;
|
|
|
}
|
|
|
// 声明抽象方法eat，无返回值
|
|
|
public abstract void eat();
|
|
|
// 声明具体方法walk来打印动物是如何行走的（包括腿的数目）。
|
|
|
// 输出格式：用 xx 条腿走路
|
|
|
public void walk(){
|
|
|
System.out.println(type +"用 " + legs + " 条腿走路");
|
|
|
}
|
|
|
}
|
|
|
// 定义蜘蛛类 Spider继承Animal类
|
|
|
class Spider extends Animal{
|
|
|
// 定义默认构造器，它调用父类构造器来指明动物类别是spider，且所有蜘蛛都是8条腿。
|
|
|
public Spider(){
|
|
|
super("spider",8);
|
|
|
}
|
|
|
// 实现eat方法，输出：spider eating
|
|
|
public void eat() {
|
|
|
System.out.println("spider eating");
|
|
|
}
|
|
|
}
|
|
|
// 创建pet（宠物）接口
|
|
|
interface Pet {
|
|
|
// 提供setName(String name) 为该宠物命名
|
|
|
public void setName(String name);
|
|
|
// 提供getName() 返回该宠物的名字，返回类型为String
|
|
|
public String getName();
|
|
|
// 提供 play()方法，无返回值
|
|
|
public void play();
|
|
|
}
|
|
|
// 定义公开的猫类 Cat 继承动物类并实现宠物接口
|
|
|
public class Cat extends Animal implements Pet{
|
|
|
// 定义一个name属性来存宠物的名字
|
|
|
private String name;
|
|
|
// 定义一个有参构造器，它使用String参数指定猫的名字
|
|
|
// 该构造器必须调用超类构造器来指明动物种类是cat，且所有的猫都是四条腿
|
|
|
public Cat(String name){
|
|
|
super("cat",4);
|
|
|
this.name = name;
|
|
|
}
|
|
|
// 另定义一个无参的构造器。该构造器调用前一个构造器（用this关键字）并传递一个空字符串作为参数
|
|
|
public Cat(){
|
|
|
this("");
|
|
|
}
|
|
|
// 实现 Pet接口的方法
|
|
|
// 设置猫的名称
|
|
|
|
|
|
public void setName(String name) {
|
|
|
this.name = name;
|
|
|
}
|
|
|
// 获取猫的名称
|
|
|
|
|
|
public String getName() {
|
|
|
return name;
|
|
|
}
|
|
|
// 重写 Animal 类的play()，输出：Cat is playing
|
|
|
public void play() {
|
|
|
System.out.println("Cat is playing");
|
|
|
}
|
|
|
// 重写 Animal 类的eat()，输出：xx eating
|
|
|
// xx 表示姓名
|
|
|
public void eat() {
|
|
|
System.out.println(name+" eating");
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
练习-Java继承和多态之综合练习
|
|
|
zljcx,1=
|
|
|
/**
|
|
|
* 任务：定义一个 Dog 类，继承 Animal 类，定义自己的性别属性，并定义获取和设置性别属性的方法和 sleep 方法。
|
|
|
* 类名为：Dog
|
|
|
*/
|
|
|
|
|
|
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
|
|
|
/********** Begin **********/
|
|
|
// 定义一个Dog的公开类，并继承Animal类
|
|
|
|
|
|
//定义小狗的性别sex，字符串类型
|
|
|
|
|
|
|
|
|
// 定义获取和设置小狗性别的方法。
|
|
|
public class Dog extends Animal
|
|
|
{
|
|
|
public String sex;
|
|
|
public Dog(String type, String name, int age)
|
|
|
{
|
|
|
super(type,name,age);
|
|
|
}
|
|
|
|
|
|
public void setSex(String sex)
|
|
|
{
|
|
|
this.sex=sex;
|
|
|
}
|
|
|
|
|
|
public void sleep()
|
|
|
{
|
|
|
System.out.print("一只名为"+getName()+"性别为"+sex+"的小狗，现在"+getAge()+"岁，它正在睡觉");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
//定义小狗的睡觉方法，实现输出：一只名为xx性别为xx的小狗，现在xx岁，它正在睡觉
|
|
|
|
|
|
学习-Java继承和多态之子类继承性
|
|
|
zmpx,1=
|
|
|
public class Transpose {
|
|
|
public static void main(String[] args) {
|
|
|
// 定义二维数组并初始化
|
|
|
char[][] a = {{'d','v','g','r'},{'h','s','r','a'},{'q','e','t','z'},{'o','p','d','s'}};
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：排序，从第一个元素开始，依次取每个元素与该元素之后的每个元素比较大小
|
|
|
for (int i = 0; i < a.length; i++) { // 二维数组的长度
|
|
|
for (int j = 0; j < a[i].length; j++) { // 每个一维数组的长度
|
|
|
int n = j + 1;
|
|
|
for (int m = i; m < a.length; m++) { // 排序
|
|
|
for (; n < a[i].length; n++) {
|
|
|
if (a[i][j] < a[m][n]) {
|
|
|
char max = a[m][n];
|
|
|
a[m][n] = a[i][j];
|
|
|
a[i][j] = max;
|
|
|
}
|
|
|
}
|
|
|
n = 0; // 此处是给n从第二个一维数组开始取0这个坐标
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// 第二步：输出排序后的数组
|
|
|
for (int i = 0; i < a.length; i++) {
|
|
|
for (int j = 0; j < a[i].length; j++) {
|
|
|
System.out.print(a[i][j] + " ");
|
|
|
}
|
|
|
System.out.println();
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}学习-Java数组之二维字符数组之按字母序排序
|
|
|
zzfc,1=
|
|
|
import java.util.Scanner;
|
|
|
import java.util.StringTokenizer;
|
|
|
public class StrTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 请在Begin-End间编写代码
|
|
|
/********** Begin **********/
|
|
|
// 第一步：接收输入的字符串
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String s = sc.next();
|
|
|
StringTokenizer stringtokenizer = new StringTokenizer(s,",");
|
|
|
String[] a = new String[stringtokenizer.countTokens()+1];
|
|
|
String[] b = new String[stringtokenizer.countTokens()+1];
|
|
|
int i=0,j=0,k=0;
|
|
|
while (stringtokenizer.hasMoreTokens()){
|
|
|
a[i] = stringtokenizer.nextToken();
|
|
|
i++;
|
|
|
}
|
|
|
while (j!=i){
|
|
|
boolean matches = a[j].matches("^a.*li.*z$");
|
|
|
if(matches){
|
|
|
b[k] = a[j];
|
|
|
k++;
|
|
|
}
|
|
|
j++;
|
|
|
}
|
|
|
for(i=0;i<k;i++){
|
|
|
//System.out.println(b[i]);
|
|
|
System.out.println("将符合条件的子字符串转化为小写："+b[i].toLowerCase());
|
|
|
System.out.println("将符合条件的子字符串转化为大写："+b[i].toUpperCase());
|
|
|
}
|
|
|
if(k!=0) System.out.println("字符串中共有符合条件的子字符串"+k+"个");
|
|
|
else System.out.println(s+"该字符串没有符合条件的子字符串");
|
|
|
// 第二步：对字符串做指定操作操作
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}练习-Java字符串之String类常用方法之满足条件的子字符串
|
|
|
ClassOne,1=
|
|
|
package step1;
|
|
|
//请在此添加实现代码
|
|
|
/********** Begin **********/
|
|
|
public class ThreadClassOne extends Thread {
|
|
|
public void run() {
|
|
|
for (int i = 1; i <= 10; i += 2) {
|
|
|
System.out.print(i + " ");
|
|
|
}
|
|
|
}
|
|
|
}创建线程ClassOne.java 程序
|
|
|
/********** End **********/
|
|
|
ClassTwo,1=
|
|
|
package step1;
|
|
|
//请在此添加实现代码
|
|
|
/********** Begin **********/
|
|
|
public class ThreadClassTwo implements Runnable {
|
|
|
public void run() {
|
|
|
for (int i = 0; i <= 10; i += 2) {
|
|
|
System.out.print(i + " ");
|
|
|
}
|
|
|
}
|
|
|
}创建线程ClassTwo.java 程序
|
|
|
/********** End **********/
|
|
|
String,1=
|
|
|
package step1;
|
|
|
|
|
|
public class StringExample {
|
|
|
public static void main(String args[]) {
|
|
|
String s1 = new String("you are a student");
|
|
|
String s2 = new String("how are you");
|
|
|
// 使用equals方法判断s1与s2是否相同
|
|
|
if (s1.equals(s2)) {
|
|
|
System.out.println("s1与s2相同");
|
|
|
} else {
|
|
|
System.out.println("s1与s2不相同");
|
|
|
}
|
|
|
String s3 = new String("13971918888");
|
|
|
// 判断手机号是否以“139”开头
|
|
|
if (s3.startsWith("139")) {
|
|
|
System.out.println("手机号以139开头");
|
|
|
}
|
|
|
String s4 = new String("你"), s5 = new String("我");
|
|
|
// 按着字典序s4大于s5的表达式
|
|
|
if (s4.compareTo(s5) > 0) {
|
|
|
System.out.println("按字典序s4大于s5");
|
|
|
} else {
|
|
|
System.out.println("按字典序s4小于s5");
|
|
|
}
|
|
|
/******************************************************/
|
|
|
int position = 0;
|
|
|
String path = "d:\\java\\A.java";
|
|
|
// 获取path中最后出现\\的位置
|
|
|
position = path.lastIndexOf("\\");
|
|
|
System.out.println(path + "中最后出现\\的位置为: " + position);
|
|
|
// 利用字符串截取方法获取path中“A.java”子字符串
|
|
|
String fileName = path.substring(path.lastIndexOf("\\") + 1);
|
|
|
System.out.println(path + "中含有的文件名为: " + fileName);
|
|
|
/******************************************************/
|
|
|
String s6 = new String("100");
|
|
|
String s7 = new String("123.678");
|
|
|
// 将s6转化成int型数据
|
|
|
int n1 = Integer.parseInt(s6);
|
|
|
// 将s7转化成double型数据
|
|
|
double n2 = Double.parseDouble(s7);
|
|
|
double m = n1 + n2;
|
|
|
System.out.println(n1 + " + " + n2 + " 的和为: " + m);
|
|
|
// String类调用valueOf(double n)方法将m转化为字符串对象
|
|
|
String s8 = String.valueOf(m);
|
|
|
position = s8.indexOf(".");
|
|
|
// 利用字符串截取方法获取s8中小数点后面的小数
|
|
|
String temp = s8.substring(position + 1);
|
|
|
System.out.println("数字" + m + "有" + temp.length() + "位小数");
|
|
|
String s9 = new String("ABCDEF");
|
|
|
// 将s9存放到数组a中
|
|
|
char a[] = s9.toCharArray();
|
|
|
System.out.print(s9 + " 逆序字符输出为: ");
|
|
|
for (int i = a.length - 1; i >= 0; i--) {
|
|
|
System.out.print(" " + a[i]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
String类的常用方法
|
|
|
|
|
|
第1关：通过Thread类创建线程
|
|
|
package step1;
|
|
|
import java.lang.Thread;
|
|
|
|
|
|
public class MyThread extends Thread {
|
|
|
private int num;//任务就是在子线程中计算num的阶乘
|
|
|
|
|
|
public MyThread() {
|
|
|
this(0);
|
|
|
}
|
|
|
|
|
|
//constructor，创建实例的时候初始化参数
|
|
|
public MyThread(int num) {
|
|
|
/***begin your code here***/
|
|
|
this.num = num;
|
|
|
/***end your code***/
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void run() {
|
|
|
//重写run方法，在子线程中想要执行的代码写在run方法中
|
|
|
int result = 1;//result保存计算出的结果
|
|
|
|
|
|
/***begin your code here***/
|
|
|
for(int i = num; i>=1;i--){
|
|
|
result = result*i;
|
|
|
}
|
|
|
/***end your code***/
|
|
|
|
|
|
//直接输出结果
|
|
|
System.out.println(result);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
第2关：通过Runnable接口创建线程
|
|
|
package step2;
|
|
|
|
|
|
public class MyRunnable implements Runnable {
|
|
|
private int num;
|
|
|
|
|
|
public MyRunnable() {
|
|
|
this(0);
|
|
|
}
|
|
|
|
|
|
public MyRunnable(int num) {
|
|
|
/***begin your code here***/
|
|
|
this.num = num;
|
|
|
/***end your code here***/
|
|
|
}
|
|
|
|
|
|
@Override
|
|
|
public void run() {
|
|
|
//重写run方法，在子线程中想要执行的代码写在run方法中
|
|
|
int result = 1;//result保存计算出的结果
|
|
|
|
|
|
/***begin your code here***/
|
|
|
for(int i = num; i>=1;i--){
|
|
|
result = result*i;
|
|
|
}
|
|
|
/***end your code***/
|
|
|
|
|
|
//直接输出结果
|
|
|
System.out.println(result);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
第3关：使用匿名Thread和Runnable对象创建线程
|
|
|
package step3;
|
|
|
|
|
|
/**
|
|
|
* 模拟一个工具类，该类不用来实例化，只提供各种静态函数
|
|
|
* @author Administrator
|
|
|
*
|
|
|
*/
|
|
|
public class ThreadHelper {
|
|
|
/**
|
|
|
* 在子线程中计算参数的阶乘并输出
|
|
|
* @param num
|
|
|
*/
|
|
|
static public void calcOnNewThread(int num) {
|
|
|
//使用Thread匿名对象以及Runnable匿名对象创建并执行子线程
|
|
|
new Thread(new Runnable() {
|
|
|
@Override public void run() {
|
|
|
int result = 1;
|
|
|
/***begin your code here***/
|
|
|
for(int i = num; i>=1;i--){
|
|
|
result = result*i;
|
|
|
}
|
|
|
/***end your code***/
|
|
|
//直接输出
|
|
|
System.out.println(result);
|
|
|
}
|
|
|
}).start();
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 使用一个私有的构造器，防止该类被实例化
|
|
|
*/
|
|
|
private ThreadHelper() {
|
|
|
throw new UnsupportedOperationException(this.getClass().getSimpleName() + " can not be instantiated.");
|
|
|
}
|
|
|
}
|
|
|
第4关：Thread创建综合
|
|
|
package step4;
|
|
|
|
|
|
//注意文件名，这里应该写MyRunnable类
|
|
|
/***begin your code here***/
|
|
|
class MyRunnable implements Runnable{
|
|
|
int num;
|
|
|
public MyRunnable(int num){
|
|
|
this.num = num;
|
|
|
}
|
|
|
public void run(){
|
|
|
int result = 1;
|
|
|
try{
|
|
|
Thread.sleep(200);
|
|
|
}
|
|
|
catch(InterruptedException e){
|
|
|
System.out.print("");
|
|
|
}
|
|
|
|
|
|
for(int i = num; i>=1;i--){
|
|
|
result = result*i;
|
|
|
}
|
|
|
|
|
|
System.out.println(result);
|
|
|
}
|
|
|
}
|
|
|
/***end your code***/
|
|
|
|
|
|
第1关：创建线程
|
|
|
package step1;
|
|
|
//请在此添加实现代码
|
|
|
//使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下：1 3 5 7 9；
|
|
|
/********** Begin **********/
|
|
|
public class ThreadClassOne extends Thread { //创建一个类来继承Thread类
|
|
|
public void run(){ //重写父类的run 方法
|
|
|
for(int i=0;i<=10;i++){
|
|
|
if(i%2 == 1)
|
|
|
System.out.print(i+" ");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-10之间的偶数，输出结果如下：0 2 4 6 8 10
|
|
|
class ThreadClassTwo implements Runnable{
|
|
|
public void run(){
|
|
|
for(int i=0;i<=10;i++){
|
|
|
if(i%2==0)
|
|
|
System.out.print(i+" ");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
第1关：InetAddress类
|
|
|
package step1;
|
|
|
|
|
|
import java.net.InetAddress;
|
|
|
import java.net.UnknownHostException;
|
|
|
|
|
|
public class InetAddressExample {
|
|
|
public static void main(String[] args) throws UnknownHostException {
|
|
|
// ---------------------Begin------------------------
|
|
|
// 获取两个东西：主机名，IP地址
|
|
|
// 获取主机名
|
|
|
InetAddress localHost = InetAddress.getLocalHost();
|
|
|
String hostName = localHost.getHostName();
|
|
|
System.out.println("主机名： " + hostName);
|
|
|
// 获取IP地址
|
|
|
InetAddress[] allByName = InetAddress.getAllByName(hostName);
|
|
|
for (int i = 0; i < allByName.length; i++) {
|
|
|
System.out.println("IP地址" + (i + 1) + ": " + allByName[i].getHostAddress());
|
|
|
}
|
|
|
// ---------------------End------------------------
|
|
|
}
|
|
|
}
|
|
|
学习-Java输入输出之InputStream类之字节数据
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定文件路径
|
|
|
Scanner Scanner = new Scanner(System.in);
|
|
|
String s = Scanner.nextLine();
|
|
|
// 创建字节输入流对象
|
|
|
try(
|
|
|
InputStream input = new FileInputStream(s)){
|
|
|
int n = 0;
|
|
|
|
|
|
// 读取文件，并将内容转换为字符输出
|
|
|
while((n=input.read())!=-1){
|
|
|
System.out.print((char)n);
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
学习-Java输入输出之OutputStream类之字节数
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定字符串
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.next();
|
|
|
// 切割字符串
|
|
|
String[] string= str.split("，");
|
|
|
String a = string[0];
|
|
|
String path = string[1];
|
|
|
// 创建FileOutputStream对象
|
|
|
OutputStream fos = new FileOutputStream(path);
|
|
|
// 写入数据
|
|
|
byte[] b = a.getBytes();
|
|
|
fos.write(b);
|
|
|
try{
|
|
|
fos.close();
|
|
|
}catch (Exception e){
|
|
|
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
练习-Java输入输出之字节数据输入输出之综合练
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 使用字节输出流和输入流，把给定文件里的内容复制到另一个给定文件中
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str1 = input.next();
|
|
|
String str2 = input.next();
|
|
|
FileInputStream fileInputStream = new FileInputStream(str1);
|
|
|
FileOutputStream fileOutputStream1 = new FileOutputStream(str2);
|
|
|
int len;
|
|
|
while ((len = fileInputStream.read()) != -1){
|
|
|
fileOutputStream1.write(len);
|
|
|
}
|
|
|
fileInputStream.close();
|
|
|
fileOutputStream1.close();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
第1关：学习-Java输入输出之Reader类之字符数据输入
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 定义变量
|
|
|
int len;
|
|
|
// 接收给定字符串
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.next();
|
|
|
// 创建Reader对象
|
|
|
Reader reader = new FileReader(str);
|
|
|
// 打印字符
|
|
|
for (;;){
|
|
|
len = reader.read();
|
|
|
if (len == -1){
|
|
|
break;
|
|
|
}
|
|
|
System.out.print((char)len);
|
|
|
}
|
|
|
reader.close();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
1关：学习-Java输入输出之Writer类之字符数据输出
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定字符串
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String string = input.next();
|
|
|
// 切割字符串
|
|
|
String[] str = string.split("，");
|
|
|
// 创建FileWriter对象
|
|
|
Writer writer = new FileWriter(str[0]);
|
|
|
// 向文件中写入字符流
|
|
|
writer.write(str[1]);
|
|
|
writer.flush();
|
|
|
/********** End **********/
|
|
|
try{
|
|
|
writer.close();
|
|
|
}catch (Exception e){
|
|
|
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
第1关：学习-Java输入输出之File类之获取文件信息
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定字符串
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String s = sc.next();
|
|
|
// 创建文件对象
|
|
|
File f = new File(s);
|
|
|
// 如果字符串是文件，获取文件名并输出文件大小
|
|
|
if(f.isFile()){
|
|
|
String name = f.getName();
|
|
|
System.out.println(name);
|
|
|
long length = f.length();
|
|
|
System.out.println(length);
|
|
|
// 如果字符串是目录，输出该目录下的所有文件
|
|
|
}else if(f.isDirectory()){
|
|
|
String[] list = f.list();
|
|
|
System.out.println(Arrays.toString(list));
|
|
|
// 如果字符串既不是文件，又不是目录，输出提示语句：“非法字符串”
|
|
|
}else{
|
|
|
System.out.println("非法字符串");
|
|
|
}
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
第1关：练习-Java输入输出之文件字节IO流之合并文件
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
|
|
|
Scanner scanner = new Scanner(System.in); // 获取给定字符串
|
|
|
String s = scanner.nextLine();
|
|
|
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 切割给定字符串，得到子文件目录和目标文件名
|
|
|
String[] array = s.split("，");
|
|
|
// 循环读取子文件内容，写入到目标文件
|
|
|
File file1 = new File(array[0]);
|
|
|
File file2 = new File(array[1]);
|
|
|
FileOutputStream fileOutputStream = new FileOutputStream(file2);
|
|
|
for (int i = 1; i < file1.listFiles().length; i ++){
|
|
|
FileInputStream fileInputStream = new FileInputStream(array[0] + "/" + array[1] + "-" + i);
|
|
|
int len = 0;
|
|
|
while((len = fileInputStream.read()) != -1)
|
|
|
fileOutputStream.write(len);
|
|
|
}
|
|
|
fileOutputStream.close();
|
|
|
// 输出目标文件大小
|
|
|
System.out.println("最后目标文件的大小：" + file2.length() + "字节");
|
|
|
FileReader fileReader = new FileReader(array[1]);
|
|
|
int lenx = 0;
|
|
|
while((lenx = fileReader.read()) != -1){
|
|
|
System.out.print((char)lenx);
|
|
|
}
|
|
|
fileReader.close();
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
第1关：Java输入输出之文件字符IO流之文件加密
|
|
|
import java.io.*;
|
|
|
import static java.lang.Character.isLetterOrDigit;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定字符串，获取相关路径
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.nextLine();
|
|
|
String[] array = str.split("，");
|
|
|
// 读取源文件
|
|
|
File file1 = new File(array[0]);
|
|
|
char[] chars = new char[Math.toIntExact(file1.length())];
|
|
|
try(
|
|
|
FileReader fileReader = new FileReader(file1);) {
|
|
|
fileReader.read(chars);
|
|
|
}
|
|
|
// 加密
|
|
|
for (int i = 0; i < chars.length; i ++){
|
|
|
chars[i] = (char) Encryption(chars[i]);
|
|
|
}
|
|
|
// 把加密后的内容保存到目标文件
|
|
|
File file2 = new File(array[1]);
|
|
|
try(
|
|
|
FileWriter fileWriter = new FileWriter(file2);) {
|
|
|
fileWriter.write(chars);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 定义加密方法
|
|
|
public static int Encryption(int len){
|
|
|
if ((len >= '0' & len < '9') | (len >= 'a' & len < 'z') | (len >= 'A' & len < 'Z')){
|
|
|
return len + 1;
|
|
|
}else if (len == '9'){
|
|
|
return len - 9;
|
|
|
}else if (len == 'z' | len == 'Z'){
|
|
|
return len - 25;
|
|
|
}else {
|
|
|
return len;
|
|
|
}
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
第1关：学习-Java输入输出之字节缓冲IO流之复制文件
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
Scanner input = new Scanner(System.in); // 获取给定字符串
|
|
|
String str = input.nextLine();
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 切割给定字符串，切割给定字符串，获取源文件路径和目标文件路径
|
|
|
String[] array = str.split("，");
|
|
|
InputStream inputStream = new FileInputStream(array[0]);
|
|
|
OutputStream outputStream = new FileOutputStream(array[1]);
|
|
|
File file = new File(array[0]);
|
|
|
// 创建缓冲流对象，实现文件复制
|
|
|
byte[] bytes = new byte[Math.toIntExact(file.length())];
|
|
|
try (
|
|
|
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);){
|
|
|
while (bufferedInputStream.read(bytes) != -1);
|
|
|
}
|
|
|
try (
|
|
|
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);) {
|
|
|
bufferedOutputStream.write(bytes);
|
|
|
}
|
|
|
// 输出目标文件长度
|
|
|
System.out.println("文件长度：" + file.length());
|
|
|
// for (int i = 0; i < bytes.length; i ++){
|
|
|
// System.out.print((char) bytes[i]);
|
|
|
// }
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
第1关：练习-Java输入输出之文件字符IO流之文件解密
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定字符串
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.nextLine();
|
|
|
String[] array = str.split("，");
|
|
|
// 读取源文件
|
|
|
File file1 = new File(array[0]);
|
|
|
char[] chars = new char[Math.toIntExact(file1.length())];
|
|
|
try(
|
|
|
FileReader fileReader = new FileReader(file1);) {
|
|
|
fileReader.read(chars);
|
|
|
}
|
|
|
// 打印源文件中的内容
|
|
|
System.out.println("解密前的内容：");
|
|
|
for (int i = 0; i < chars.length; i ++){
|
|
|
System.out.print(chars[i]);
|
|
|
}
|
|
|
System.out.println();
|
|
|
// 进行解密
|
|
|
for (int i = 0; i < chars.length; i ++){
|
|
|
chars[i] = (char) Deciphering(chars[i]);
|
|
|
}
|
|
|
// 把解密后的内容保存到目标文件，并输出解密后的内容
|
|
|
File file2 = new File(array[1]);
|
|
|
try (
|
|
|
FileWriter fileWriter = new FileWriter(file2);) {
|
|
|
fileWriter.write(chars);
|
|
|
}
|
|
|
System.out.println("解密后的内容：");
|
|
|
for (char i : chars){
|
|
|
System.out.print(i);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
// 把解密后的内容保存到目标文件，并输出解密后的内容
|
|
|
// 定义解密方法
|
|
|
public static int Deciphering(int len){
|
|
|
if ((len >= '1' & len <= '9') | (len > 'a' & len <= 'z') | (len > 'A' & len <= 'Z')){
|
|
|
return len - 1;
|
|
|
}else if (len == '0'){
|
|
|
return len + 9;
|
|
|
}else if (len == 'a' | len == 'A'){
|
|
|
return len + 25;
|
|
|
}else {
|
|
|
return len;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
练习-Java输入输出之字节缓冲IO流之字节缓存流的高性能
|
|
|
import java.io.BufferedInputStream;
|
|
|
import java.io.FileInputStream;
|
|
|
import java.io.IOException;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class StudentTest {
|
|
|
Scanner input = new Scanner(System.in); // 获取给定文件字符串
|
|
|
String str = input.next();
|
|
|
|
|
|
public Long bufferStream() throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 使用缓冲流读取给定文件，并返回读取时间
|
|
|
byte[] bytes = new byte[8];
|
|
|
try (
|
|
|
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(str));){
|
|
|
long t1 = System.currentTimeMillis();
|
|
|
while (bufferedInputStream.read(bytes) != -1);
|
|
|
long t2 = System.currentTimeMillis();
|
|
|
bufferedInputStream.close();
|
|
|
return t2 - t1;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
public Long inputStream() throws IOException{
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 使用文件字节流读取给定文件，并返回读取时间
|
|
|
byte[] bytes = new byte[8];
|
|
|
try (
|
|
|
FileInputStream fileInputStream = new FileInputStream(str);){
|
|
|
long t1 = System.currentTimeMillis();
|
|
|
while (fileInputStream.read(bytes) != -1);
|
|
|
long t2 = System.currentTimeMillis();
|
|
|
fileInputStream.close();
|
|
|
return t2 - t1;
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
学习-Java输入输出之字符缓冲IO流之往文件中插入分隔符
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
Scanner scanner = new Scanner(System.in); // 接收字符串
|
|
|
String next = scanner.nextLine();
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 切割字符串
|
|
|
String[] str = next.split("，");
|
|
|
// 复制源文件内容到目标文件，并在每一行之间插入分隔符
|
|
|
BufferedReader bufferedReader = new BufferedReader(new FileReader(str[0]));
|
|
|
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(str[1]));
|
|
|
String str1 = null;
|
|
|
while((str1 = bufferedReader.readLine()) != null){
|
|
|
bufferedWriter.write(str1);
|
|
|
bufferedWriter.newLine();
|
|
|
bufferedWriter.write(str[2]);
|
|
|
bufferedWriter.newLine();
|
|
|
}
|
|
|
bufferedReader.close();
|
|
|
bufferedWriter.close();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
练习-Java输入输出之字符缓冲IO流之移除文件中的注释
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
String javaFile = scanner.next();
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 读取文件内容
|
|
|
File file = new File(javaFile);
|
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
|
try (
|
|
|
FileReader fileReader = new FileReader(file);
|
|
|
BufferedReader bufferedReader = new BufferedReader(fileReader);){
|
|
|
String str = null;
|
|
|
while ((str = bufferedReader.readLine()) != null){
|
|
|
if (str.trim().startsWith("//")){
|
|
|
continue;
|
|
|
}
|
|
|
stringBuffer.append(str).append("\r\n");
|
|
|
}
|
|
|
}
|
|
|
// 输出去除注释后的文件长度
|
|
|
try (
|
|
|
FileWriter fileWriter = new FileWriter(javaFile);
|
|
|
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);){
|
|
|
bufferedWriter.write(stringBuffer.toString());
|
|
|
}
|
|
|
System.out.print("文件长度：" + file.length());
|
|
|
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
练习-Java输入输出之随机IO流之向文件中指定位置添加内容
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
Scanner scanner = new Scanner(System.in); // 接收给定字符串
|
|
|
String str = scanner.nextLine();
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 切割字符串
|
|
|
String[] strs= str.split("，");
|
|
|
// 创建一个临时文件
|
|
|
File tem=new File(strs[0]);
|
|
|
// 将插入点之后的内容保存到临时文件
|
|
|
RandomAccessFile raf = new RandomAccessFile(tem,"rw");
|
|
|
//设置指针位置
|
|
|
raf.seek(Long.parseLong(strs[1]));
|
|
|
//读取指针后面的字符数并返回
|
|
|
byte[] by=new byte[1024];
|
|
|
int len =raf.read(by);
|
|
|
|
|
|
//上面读取后指针位置发生移动，再次设置指针位置
|
|
|
raf.seek(Long.parseLong(strs[1]));
|
|
|
// System.out.println();
|
|
|
//先写入指定字符，在写人前面读取的s并指定写入长度，防止空格
|
|
|
raf.write(strs[2].getBytes());
|
|
|
raf.write(by,0,len);
|
|
|
|
|
|
raf.close();
|
|
|
// 将给定的内容和临时文件中的内容依次追加到原文件的插入点后
|
|
|
|
|
|
/********** End **********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java输入输出之数组IO流之将给定整数转换为字符写入到给定文件中
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在此编写代码
|
|
|
/********** Begin **********/
|
|
|
// 接收给定数据，将字节整数转化为字符，
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String[] array = new String[100];
|
|
|
int i = 0;
|
|
|
while (!input.hasNext("%")){
|
|
|
array[i] = input.next();
|
|
|
i ++;
|
|
|
}
|
|
|
// 并使用ByteArrayOutputStream将其写入到给定文件中（字符为a的除外）
|
|
|
try (
|
|
|
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
|
|
|
FileOutputStream fileOutputStream = new FileOutputStream(array[0]);
|
|
|
){
|
|
|
for (int j = 1; j < i; j ++){
|
|
|
if (Integer.parseInt(array[j]) == 'a'){
|
|
|
continue;
|
|
|
}
|
|
|
byteArrayOutputStream.write(Integer.parseInt(array[j]));
|
|
|
}
|
|
|
byte[] bytes = byteArrayOutputStream.toByteArray();
|
|
|
fileOutputStream.write(bytes);
|
|
|
}
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
习-Java输入输出之数据IO流之把文件中内容转为大写后写入另一个文件
|
|
|
import java.io.*;
|
|
|
import java.util.Arrays;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 接收给定的一行字符串
|
|
|
Scanner scanner = new Scanner(System.in);
|
|
|
String line = scanner.nextLine();
|
|
|
|
|
|
// 请在此编写代码
|
|
|
/********** Begin **********/
|
|
|
|
|
|
// 切割字符串，获取源文件目录和目标文件目录
|
|
|
String[] strs = line.split("，");
|
|
|
File file1 = new File(strs[0]);
|
|
|
File file2 = new File(strs[1]);
|
|
|
BufferedReader fis = new BufferedReader(new FileReader(file1));
|
|
|
BufferedWriter fos = new BufferedWriter(new FileWriter(file2));
|
|
|
// 将源文件中的前三行内容转为大写后写入到目标文件中
|
|
|
for(int i=0;i<3;i++){
|
|
|
String str = fis.readLine();
|
|
|
fos.write(str.toUpperCase());
|
|
|
System.out.println(str.toUpperCase());
|
|
|
fos.newLine();
|
|
|
}
|
|
|
/********** End **********/
|
|
|
fis.close();
|
|
|
fos.close();
|
|
|
|
|
|
}
|
|
|
}
|
|
|
练习-Java输入输出之字节数据输入输出之综合练习
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 使用字节输出流和输入流，把给定文件里的内容复制到另一个给定文件中
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str1 = input.next();
|
|
|
String str2 = input.next();
|
|
|
FileInputStream fileInputStream = new FileInputStream(str1);
|
|
|
FileOutputStream fileOutputStream1 = new FileOutputStream(str2);
|
|
|
int len;
|
|
|
while ((len = fileInputStream.read()) != -1){
|
|
|
fileOutputStream1.write(len);
|
|
|
}
|
|
|
fileInputStream.close();
|
|
|
fileOutputStream1.close();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
学习-Java输入输出之Reader类之字符数据输入
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 定义变量
|
|
|
int len;
|
|
|
// 接收给定字符串
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str = input.next();
|
|
|
// 创建Reader对象
|
|
|
Reader reader = new FileReader(str);
|
|
|
// 打印字符
|
|
|
for (;;){
|
|
|
len = reader.read();
|
|
|
if (len == -1){
|
|
|
break;
|
|
|
}
|
|
|
System.out.print((char)len);
|
|
|
}
|
|
|
reader.close();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
第1关：什么是封装，如何使用封装
|
|
|
package case1;
|
|
|
|
|
|
public class TestPersonDemo {
|
|
|
public static void main(String[] args) {
|
|
|
/********* begin *********/
|
|
|
// 声明并实例化一Person对象p
|
|
|
Person p = new Person();
|
|
|
// 给p中的属性赋值
|
|
|
p.Set("张三",18);
|
|
|
// 调用Person类中的talk()方法
|
|
|
p.talk();
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
// 在这里定义Person类
|
|
|
class Person {
|
|
|
/********* begin *********/
|
|
|
private String name;
|
|
|
private int age;
|
|
|
public void talk(){
|
|
|
System.out.println("我是："+this.name+"，今年："+this.age+"岁");
|
|
|
}
|
|
|
public void Set(String name,int age){
|
|
|
this.name = name;
|
|
|
this.age = age;
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
第2关：什么是继承，怎样使用继承
|
|
|
package case2;
|
|
|
|
|
|
public class extendsTest {
|
|
|
public static void main(String args[]) {
|
|
|
// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
|
|
|
/********* begin *********/
|
|
|
Cat cat=new Cat();
|
|
|
cat.Set("大花猫",6);
|
|
|
cat.putName(); cat.voice();
|
|
|
System.out.println();
|
|
|
cat.putName();cat.eat();
|
|
|
System.out.println();
|
|
|
cat.putName();cat.putAge();
|
|
|
System.out.println();
|
|
|
|
|
|
/********* end *********/
|
|
|
|
|
|
// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
|
|
|
/********* begin *********/
|
|
|
Dog dog=new Dog();
|
|
|
dog.Set("大黑狗",8);
|
|
|
dog.putName(); dog.voice();
|
|
|
System.out.println();
|
|
|
dog.putName();dog.eat();
|
|
|
System.out.println();
|
|
|
dog.putName();dog.putAge();
|
|
|
System.out.println();
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class Animal {
|
|
|
/********* begin *********/
|
|
|
private String name;
|
|
|
private int age;
|
|
|
public void Set(String name,int age){
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
}
|
|
|
public void putName(){
|
|
|
System.out.print(this.name);
|
|
|
}
|
|
|
public void putAge(){
|
|
|
System.out.print(this.age+"岁");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
|
|
|
}
|
|
|
|
|
|
class Cat extends Animal {
|
|
|
// 定义Cat类的voice()和eat()方法
|
|
|
/********* begin *********/
|
|
|
|
|
|
public void voice(){
|
|
|
System.out.print("喵喵叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.print("吃鱼");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
class Dog extends Animal {
|
|
|
// 定义Dog类的voice()和eat()方法
|
|
|
/********* begin *********/
|
|
|
public void voice(){
|
|
|
System.out.print("汪汪叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.print("吃骨头");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第3关：方法的重写与重载
|
|
|
package case4;
|
|
|
|
|
|
public class overridingTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 实例化子类对象s，调用talk()方法打印信息
|
|
|
/********* begin *********/
|
|
|
Student s=new Student("张三",18,"哈佛大学");
|
|
|
s.talk();
|
|
|
|
|
|
/********* end *********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class Person {
|
|
|
/********* begin *********/
|
|
|
String name;
|
|
|
int age;
|
|
|
public void talk(){
|
|
|
System.out.println("我是："+name+"，今年："+age+"岁");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
class Student extends Person {
|
|
|
/********* begin *********/
|
|
|
String school;
|
|
|
public Student(String n,int a,String sch){
|
|
|
this.name=n;
|
|
|
this.age=a;
|
|
|
this.school=sch;
|
|
|
}
|
|
|
public void talk(){
|
|
|
System.out.println("我是："+name+"，今年："+age+"岁，我在"+school+"上学");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第4关：抽象类
|
|
|
package case5;
|
|
|
|
|
|
public class abstractTest {
|
|
|
public static void main(String[] args) {
|
|
|
/********* begin *********/
|
|
|
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
|
|
|
Student s=new Student("张三",20,"学生");
|
|
|
Worker w=new Worker("李四",30,"工人");
|
|
|
// 分别调用各自类中被复写的talk()方法 打印信息。
|
|
|
s.talk();
|
|
|
w.talk();
|
|
|
/********* end *********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
|
|
|
abstract class Person {
|
|
|
/********* begin *********/
|
|
|
String name;
|
|
|
int age;
|
|
|
String occupation;
|
|
|
abstract public void talk();
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
|
|
|
class Student extends Person {
|
|
|
/********* begin *********/
|
|
|
public Student(String n,int a,String o){
|
|
|
this.name=n;
|
|
|
this.age=a;
|
|
|
this.occupation=o;
|
|
|
}
|
|
|
public void talk(){
|
|
|
System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
|
|
|
class Worker extends Person {
|
|
|
/********* begin *********/
|
|
|
public Worker(String n,int a,String o){
|
|
|
this.name=n;
|
|
|
this.age=a;
|
|
|
this.occupation=o;
|
|
|
}
|
|
|
public void talk(){
|
|
|
System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第5关：接口
|
|
|
package case7;
|
|
|
|
|
|
public class interfaceTest {
|
|
|
public static void main(String[] args) {
|
|
|
// 实例化一Student的对象s，并调用talk()方法，打印信息
|
|
|
/********* begin *********/
|
|
|
Student s=new Student();
|
|
|
s.talk();
|
|
|
|
|
|
/********* end *********/
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
|
|
|
interface Person {
|
|
|
/********* begin *********/
|
|
|
final String name="张三";
|
|
|
final int age=18;
|
|
|
final String occupation="学生";
|
|
|
abstract public void talk();
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
|
|
|
class Student implements Person {
|
|
|
/********* begin *********/
|
|
|
public void talk(){
|
|
|
System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
第6关：什么是多态，怎么使用多态
|
|
|
package case8;
|
|
|
|
|
|
public class TestPolymorphism {
|
|
|
public static void main(String[] args) {
|
|
|
// 以多态方式分别实例化子类对象并调用eat()方法
|
|
|
/********* begin *********/
|
|
|
Dog dog=new Dog();
|
|
|
Cat cat=new Cat();
|
|
|
Lion lion=new Lion();
|
|
|
dog.eat();
|
|
|
cat.eat();
|
|
|
lion.eat();
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
// Animal类中定义eat()方法
|
|
|
class Animal {
|
|
|
/********* begin *********/
|
|
|
public void eat(){
|
|
|
System.out.print("...");
|
|
|
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// Dog类继承Animal类 复写eat()方法
|
|
|
class Dog extends Animal {
|
|
|
/********* begin *********/
|
|
|
public void eat(){
|
|
|
System.out.println("eating bread...");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// Cat类继承Animal类 复写eat()方法
|
|
|
class Cat extends Animal {
|
|
|
/********* begin *********/
|
|
|
public void eat(){
|
|
|
System.out.println("eating rat...");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
// Lion类继承Animal类 复写eat()方法
|
|
|
class Lion extends Animal {
|
|
|
/********* begin *********/
|
|
|
public void eat(){
|
|
|
System.out.println("eating meat...");
|
|
|
}
|
|
|
|
|
|
/********* end *********/
|
|
|
}
|
|
|
第1关：顺序输出
|
|
|
package step1;
|
|
|
|
|
|
public class Task {
|
|
|
public static void main(String[] args) throws Exception {
|
|
|
/********* Begin *********/
|
|
|
//在这里创建线程， 开启线程
|
|
|
Object a = new Object();
|
|
|
Object b = new Object();
|
|
|
Object c = new Object();
|
|
|
/*其中，MyThread是一个自定义的线程类，而"AA"、"BB"和"CC"是线程的名称，a、b和c是三个共享资源。
|
|
|
在创建th1时，传递了三个参数，分别是线程名称、a和c，表示这个线程需要访问a和c这两个共享资源。
|
|
|
同样的，创建th2时，传递了三个参数，分别是线程名称、c和b，表示这个线程需要访问c和b这两个共享资源。
|
|
|
创建th3时，传递了三个参数，分别是线程名称、b和a，表示这个线程需要访问b和a这两个共享资源。
|
|
|
整个代码的意思是，在三个线程之间共享a、b和c这三个资源，每个线程需要访问两个资源，但是访问的顺序是不同的。具体的执行过程需要参考MyThread类的实现。*/
|
|
|
MyThread th1 = new MyThread("AA", a, c);
|
|
|
MyThread th2 = new MyThread("BB", c, b);
|
|
|
MyThread th3 = new MyThread("CC", b, a);
|
|
|
// 分别启动三个线程，并在每个线程启动后暂停10毫秒
|
|
|
th1.start();
|
|
|
Thread.sleep(10);
|
|
|
th2.start();
|
|
|
Thread.sleep(10);
|
|
|
th3.start();
|
|
|
Thread.sleep(10);
|
|
|
// 结束程序
|
|
|
System.exit(0);
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
class MyThread extends Thread {
|
|
|
/********* Begin *********/
|
|
|
// 定义了三个成员变量：线程名，Object类型的对象a和b
|
|
|
String threadName;
|
|
|
Object a = null;
|
|
|
Object b = null;
|
|
|
// 定义了一个构造方法，传入线程名和a、b对象
|
|
|
public MyThread(String threadName, Object a, Object b) {
|
|
|
super();
|
|
|
this.threadName = threadName;
|
|
|
this.a = a;
|
|
|
this.b = b;
|
|
|
}
|
|
|
|
|
|
public synchronized void run() {// 重写了Thread类中的run方法
|
|
|
|
|
|
int count = 5; // 定义了一个计数器count，初始值为5
|
|
|
// 当计数器count大于0时，循环执行以下操作
|
|
|
while (count > 0) {
|
|
|
synchronized (a) { // 先获取a对象的锁
|
|
|
synchronized (b) {// 再获取b对象的锁
|
|
|
System.out.println("Java Thread" + this.threadName);// 输出线程名
|
|
|
count--; // 计数器count减1
|
|
|
b.notify();// 唤醒等待b对象锁的线程
|
|
|
|
|
|
}
|
|
|
try {
|
|
|
a.wait();// 释放a对象锁，并将该线程阻塞
|
|
|
} catch (InterruptedException e) {// TODO 自动生成的 catch 块
|
|
|
e.printStackTrace();// 如果有中断异常，则打印异常信息
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
/********* End *********/
|
|
|
}
|
|
|
练习-Java输入输出之字节数据输入输出之综合练习
|
|
|
import java.io.*;
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class FileTest {
|
|
|
public static void main(String[] args) throws IOException {
|
|
|
// 请在Begin-End间编写完整代码
|
|
|
/********** Begin **********/
|
|
|
// 使用字节输出流和输入流，把给定文件里的内容复制到另一个给定文件中
|
|
|
Scanner input = new Scanner(System.in);
|
|
|
String str1 = input.next();
|
|
|
String str2 = input.next();
|
|
|
FileInputStream fileInputStream = new FileInputStream(str1);
|
|
|
FileOutputStream fileOutputStream1 = new FileOutputStream(str2);
|
|
|
int len;
|
|
|
while ((len = fileInputStream.read()) != -1){
|
|
|
fileOutputStream1.write(len);
|
|
|
}
|
|
|
fileInputStream.close();
|
|
|
fileOutputStream1.close();
|
|
|
/********** End **********/
|
|
|
}
|
|
|
}
|
|
|
第2关：字节流-输入输出
|
|
|
package step2;
|
|
|
|
|
|
import java.io.File;
|
|
|
import java.io.FileInputStream;
|
|
|
import java.io.FileNotFoundException;
|
|
|
import java.io.FileOutputStream;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.FileWriter;
|
|
|
import java.io.IOException;
|
|
|
import java.io.InputStream;
|
|
|
import java.io.OutputStream;
|
|
|
|
|
|
public class Task {
|
|
|
|
|
|
public void task() throws IOException{
|
|
|
/********* Begin *********/
|
|
|
File file1 = new File("src/step2/input/task.txt");
|
|
|
InputStream fs = new FileInputStream(file1);
|
|
|
byte[] b1 = new byte[1024];
|
|
|
fs.read(b1);
|
|
|
String str1 = new String(b1, "utf-8");
|
|
|
System.out.print(str1);
|
|
|
fs.close();
|
|
|
|
|
|
File file = new File("src/step2/output");
|
|
|
if(!file.exists()){
|
|
|
file.mkdir();
|
|
|
}
|
|
|
String file2 = "src/step2/output/output.txt";
|
|
|
OutputStream out = new FileOutputStream(file2);
|
|
|
String str2 = "learning practice";
|
|
|
byte[] b2 = str2.getBytes(); //字符转化成字节
|
|
|
out.write(b2);
|
|
|
out.flush(); //刷新缓冲区数据（类似保存数据）
|
|
|
out.close();
|
|
|
/********* End *********/
|
|
|
}
|
|
|
|
|
|
}
|
|
|
第3关：字符流 - 输入输出
|
|
|
package step3;
|
|
|
|
|
|
import java.io.FileNotFoundException;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.FileWriter;
|
|
|
import java.io.IOException;
|
|
|
|
|
|
public class Task {
|
|
|
|
|
|
public void task() throws IOException{
|
|
|
/********* Begin *********/
|
|
|
String file1 = "src/step3/input/input.txt"; //创建文件
|
|
|
FileReader fr = new FileReader(file1);
|
|
|
char[] cbuf = new char[1024];//定义一个1K的字符数组
|
|
|
fr.read(cbuf);//将文件的数据读到数组中
|
|
|
/*FileReader fr = new FileReader(file1); //实例化
|
|
|
char[] ch = new char[8]; //创建数组
|
|
|
fr.read(ch); //将文件的数据读入到数组中（从前到后）这点特别需要注意一下下*/
|
|
|
String file2 = "src/step3/output/output.txt";//创建新的文件
|
|
|
FileWriter fw = new FileWriter(file2);//将其实例化
|
|
|
fw.write(cbuf); // 读入数组中的数据到文件中（从后到前）
|
|
|
fr.close(); //输入关闭流
|
|
|
fw.flush(); //输出刷新流
|
|
|
fw.close(); //输出关闭流
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
第4关复制文件
|
|
|
package step4;
|
|
|
|
|
|
import java.io.FileInputStream;
|
|
|
import java.io.FileNotFoundException;
|
|
|
import java.io.FileOutputStream;
|
|
|
import java.io.FileReader;
|
|
|
import java.io.FileWriter;
|
|
|
import java.io.IOException;
|
|
|
|
|
|
public class Task {
|
|
|
|
|
|
public void task() throws IOException{
|
|
|
/********* Begin *********/
|
|
|
//复制文本，字符流更快
|
|
|
FileReader fr = new FileReader("src/step4/input/input.txt");//创建文件并将其实例化
|
|
|
int len = 0;
|
|
|
char[] cbuf = new char[1024];
|
|
|
|
|
|
FileWriter fw = new FileWriter("src/step4/output/output.txt");//创建文件将其实例化
|
|
|
while((len = fr.read(cbuf)) != -1){//读入从左往右依次判断
|
|
|
fw.write(cbuf, 0, len);//读出从右往左，读入需要的数据
|
|
|
}
|
|
|
|
|
|
fr.close();//关闭输入流
|
|
|
fw.close();//关闭写入流
|
|
|
//复制图片字节流，更广泛
|
|
|
FileInputStream fs = new FileInputStream("src/step4/input/input.jpg");//同样将其创实例
|
|
|
FileOutputStream fos = new FileOutputStream("src/step4/output/output.jpg");//创建实例
|
|
|
|
|
|
int len1 = 0;
|
|
|
byte[] b = new byte[1024];
|
|
|
|
|
|
while((len1 = fs.read(b)) != -1){//从左到右
|
|
|
fos.write(b, 0, len1);//从右到左
|
|
|
}
|
|
|
|
|
|
fs.close();
|
|
|
fos.close();
|
|
|
|
|
|
/********* End *********/
|
|
|
}
|
|
|
}
|
|
|
测试输入： 泰迪 male brown 波斯猫 male 2.5 预期输出： 名称：泰迪，性别：male，颜色：brown，汪汪叫 泰迪吃骨头！ 名称：波斯猫，性别：male，体重：2.5kg，喵喵叫 波斯猫吃鱼！
|
|
|
|
|
|
package case1;
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Task1 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String dogName = sc.next();
|
|
|
String dogSex = sc.next();
|
|
|
String dogColor = sc.next();
|
|
|
String catName = sc.next();
|
|
|
String catSex = sc.next();
|
|
|
double catWeight = sc.nextDouble();
|
|
|
// 通过有参构造函数实例化Dog类对象dog
|
|
|
/********* begin *********/
|
|
|
Dog dog=new Dog(dogName,dogSex,dogColor);
|
|
|
dog.talk();
|
|
|
dog.eat();
|
|
|
/********* end *********/
|
|
|
// 通过有参构造函数实例化Cat类对象cat
|
|
|
// cat调用talk()方法
|
|
|
// cat调用eat()方法
|
|
|
/********* begin *********/
|
|
|
Cat cat=new Cat(catName,catSex,catWeight);
|
|
|
cat.talk();
|
|
|
cat.eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 抽象类Pet 封装属性name和sex
|
|
|
// 构造函数初始化name和sex
|
|
|
// 声明抽象方法talk()
|
|
|
// 声明抽象方法eat()
|
|
|
abstract class Pet {
|
|
|
/********* begin *********/
|
|
|
public abstract void talk();
|
|
|
public abstract void eat();
|
|
|
private String name;
|
|
|
private String sex;
|
|
|
public String getname(){
|
|
|
return name;
|
|
|
}
|
|
|
public void setname(String name){
|
|
|
this.name=name;
|
|
|
}
|
|
|
public String getsex(){
|
|
|
return sex;
|
|
|
}
|
|
|
public void setsex(String sex){
|
|
|
this.sex=sex;
|
|
|
}
|
|
|
public Pet(String name,String sex){
|
|
|
this.name=name;
|
|
|
this.sex=sex;
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Dog类继承自Pet类 封装属性color
|
|
|
// 构造函数初始化name、sex和color
|
|
|
// 实现自己的talk()方法和eat()方法
|
|
|
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
|
|
|
// eat()输出'name吃骨头'
|
|
|
class Dog extends Pet {
|
|
|
/********* begin *********/
|
|
|
private String color;
|
|
|
public String getcolor(){
|
|
|
return color;
|
|
|
}
|
|
|
public void setcolor(String color){
|
|
|
this.color=color;
|
|
|
}
|
|
|
public Dog(String name,String sex,String color){
|
|
|
super(name,sex);
|
|
|
sex=super.getname();
|
|
|
name=super.getname();
|
|
|
this.color=color;
|
|
|
}
|
|
|
public void talk(){
|
|
|
System.out.println("名称："+super.getname()+"，性别："+super.getsex()+"，颜色："+color+"，汪汪叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println(super.getname()+"吃骨头！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Cat类继承自Pet类 封装属性weight
|
|
|
// 构造函数初始化name、sex和weight
|
|
|
// 实现自己的talk()方法和eat()方法
|
|
|
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
|
|
|
// eat()输出'name吃鱼'
|
|
|
class Cat extends Pet {
|
|
|
/********* begin *********/
|
|
|
private double weight;
|
|
|
public double getweight(){
|
|
|
return weight;
|
|
|
}
|
|
|
public void setweight(double weight){
|
|
|
this.weight=weight;
|
|
|
}
|
|
|
public Cat(String name,String sex,double weight){
|
|
|
super(name,sex);
|
|
|
sex=super.getname();
|
|
|
name=super.getname();
|
|
|
this.weight=weight;
|
|
|
}
|
|
|
public void talk(){
|
|
|
System.out.println("名称："+super.getname()+"，性别："+super.getsex()+"，体重："+weight+"kg，喵喵叫");
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println(super.getname()+"吃鱼！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
测试输入：
|
|
|
张三
|
|
|
男
|
|
|
20
|
|
|
史蒂文
|
|
|
男
|
|
|
22
|
|
|
预期输出：
|
|
|
姓名：张三，性别：男，年龄：20，我是中国人，我喜欢吃饭!
|
|
|
姓名：史蒂文，性别：男，年龄：22，我是英国人，我喜欢吃三明治!
|
|
|
张三在练习太极拳!
|
|
|
史蒂文在练习骑马！
|
|
|
package case2;
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Task2 {
|
|
|
public static void main(String[] args) {
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String cName = sc.next();
|
|
|
String cSex = sc.next();
|
|
|
int cAge = sc.nextInt();
|
|
|
String eName = sc.next();
|
|
|
String eSex = sc.next();
|
|
|
int eAge = sc.nextInt();
|
|
|
// 创建测试类对象test
|
|
|
// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
|
|
|
// 通过showEat()方法调用Chinese的eat()方法
|
|
|
// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
|
|
|
// 通过showEat()方法调用English的eat()方法
|
|
|
/********* begin *********/
|
|
|
Person person1=new Chinese(cName,cSex,cAge);
|
|
|
showEat(person1);
|
|
|
Person person2=new English(eName,eSex,eAge);
|
|
|
showEat(person2);
|
|
|
/********* end *********/
|
|
|
// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
|
|
|
// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
|
|
|
/********* begin *********/
|
|
|
Chinese chinese=(Chinese) person1;
|
|
|
chinese.shadowBoxing();
|
|
|
English english=(English) person2;
|
|
|
english.horseRiding();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
|
|
|
/********* begin *********/
|
|
|
public static void showEat(Person person){
|
|
|
person.eat();
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 抽象类Person 封装属性name、sex和age
|
|
|
// 构造函数初始化name、sex和age
|
|
|
// 声明抽象方法eat()
|
|
|
abstract class Person {
|
|
|
/********* begin *********/
|
|
|
private String name;
|
|
|
private String sex;
|
|
|
private int age;
|
|
|
public String getname(){
|
|
|
return name;
|
|
|
}
|
|
|
public void setname(String name){
|
|
|
this.name=name;
|
|
|
}
|
|
|
public String getsex(){
|
|
|
return sex;
|
|
|
}
|
|
|
public void setsex(String sex){
|
|
|
this.sex=sex;
|
|
|
}
|
|
|
public int getage(){
|
|
|
return age;
|
|
|
}
|
|
|
public void setage(int age){
|
|
|
this.age=age;
|
|
|
}
|
|
|
public Person (String name,String sex,int age){
|
|
|
this.name=name;
|
|
|
this.sex=sex;
|
|
|
this.age=age;
|
|
|
}
|
|
|
public abstract void eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// Chinese类继承自Person类
|
|
|
// 构造函数初始化name、sex和age
|
|
|
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
|
|
|
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
|
|
|
class Chinese extends Person {
|
|
|
/********* begin *********/
|
|
|
public Chinese(String name,String sex,int age){
|
|
|
super(name,sex,age);
|
|
|
sex=super.getname();
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是中国人，我喜欢吃饭！");
|
|
|
}
|
|
|
public void shadowBoxing(){
|
|
|
System.out.println(super.getname()+"在练习太极拳！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// English类继承自Person类
|
|
|
// 构造函数初始化name、sex和age
|
|
|
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
|
|
|
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
|
|
|
class English extends Person {
|
|
|
/********* begin *********/
|
|
|
public English(String name,String sex,int age){
|
|
|
super(name,sex,age);
|
|
|
sex=super.getname();
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是英国人，我喜欢吃三明治！");
|
|
|
}
|
|
|
public void horseRiding(){
|
|
|
System.out.println(super.getname()+"在练习骑马！");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
测试输入：
|
|
|
张继科
|
|
|
30
|
|
|
易建联
|
|
|
31
|
|
|
刘国梁
|
|
|
42
|
|
|
杜锋
|
|
|
37
|
|
|
package case3;
|
|
|
|
|
|
import java.util.Scanner;
|
|
|
|
|
|
public class Task3 {
|
|
|
public static void main(String[] args) {
|
|
|
@SuppressWarnings("resource")
|
|
|
Scanner sc = new Scanner(System.in);
|
|
|
String pppName = sc.next();
|
|
|
int pppAge = sc.nextInt();
|
|
|
String bpName = sc.next();
|
|
|
int bpAge = sc.nextInt();
|
|
|
String ppcName = sc.next();
|
|
|
int ppcAge = sc.nextInt();
|
|
|
String bcName = sc.next();
|
|
|
int bcAge = sc.nextInt();
|
|
|
// 测试运动员(乒乓球运动员和篮球运动员)
|
|
|
// 乒乓球运动员
|
|
|
// 通过带参构造函数实例化PingPangPlayer对象ppp
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、study()、speak()方法
|
|
|
/********* begin *********/
|
|
|
PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);
|
|
|
System.out.println(pppName+"---"+pppAge);
|
|
|
ppp.sleep();
|
|
|
ppp.eat();
|
|
|
ppp.study();
|
|
|
ppp.speak();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
// 篮球运动员
|
|
|
// 通过带参构造函数实例化BasketballPlayer对象bp
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、study()方法
|
|
|
/********* begin *********/
|
|
|
BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);
|
|
|
System.out.println(bpName+"---"+bpAge);
|
|
|
bp.sleep();
|
|
|
bp.eat();
|
|
|
bp.study();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
// 测试教练(乒乓球教练和篮球教练)
|
|
|
// 乒乓球教练
|
|
|
// 通过带参构造函数实例化PingPangCoach对象ppc
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、teach()、speak()方法
|
|
|
/********* begin *********/
|
|
|
PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);
|
|
|
System.out.println(ppcName+"---"+ppcAge);
|
|
|
ppc.sleep();
|
|
|
ppc.eat();
|
|
|
ppc.teach();
|
|
|
ppc.speak();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
// 篮球教练
|
|
|
// 通过带参构造函数实例化BasketballCoach对象bc
|
|
|
// 输出'name---age'
|
|
|
// 分别调用sleep()、eat()、teach()方法
|
|
|
/********* begin *********/
|
|
|
BasketballCoach bc=new BasketballCoach(bcName,bcAge);
|
|
|
System.out.println(bcName+"---"+bcAge);
|
|
|
bc.sleep();
|
|
|
bc.eat();
|
|
|
bc.teach();
|
|
|
/********* end *********/
|
|
|
System.out.println("----------------");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 说英语接口 声明抽象方法speak()
|
|
|
interface SpeakEnglish {
|
|
|
/********* begin *********/
|
|
|
void speak();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义人的抽象类Person 封装name和age
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 定义具体方法sleep() 输出'人都是要睡觉的'
|
|
|
// 抽象方法eat()（吃的不一样）
|
|
|
abstract class Person {
|
|
|
/********* begin *********/
|
|
|
private String name;
|
|
|
private int age;
|
|
|
public String getname(){
|
|
|
return name;
|
|
|
}
|
|
|
public void setname(String name){
|
|
|
this.name=name;
|
|
|
}
|
|
|
public int getage(){
|
|
|
return age;
|
|
|
}
|
|
|
public void setage(int age){
|
|
|
this.age=age;
|
|
|
}
|
|
|
public Person(String name,int age){
|
|
|
this.name=name;
|
|
|
this.age=age;
|
|
|
}
|
|
|
public void sleep(){
|
|
|
System.out.println("人都是要睡觉的");
|
|
|
}
|
|
|
abstract void eat();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义运动员Player（抽象类）继承自Person类
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
|
|
|
abstract class Player extends Person {
|
|
|
/********* begin *********/
|
|
|
public Player(String name,int age){
|
|
|
super(name,age);
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
abstract void study();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义教练Coach（抽象类）继承自Person类
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 教练教的不一样 定义抽象方法teach()
|
|
|
abstract class Coach extends Person {
|
|
|
/********* begin *********/
|
|
|
public Coach(String name,int age){
|
|
|
super(name,age);
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
abstract void teach();
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
|
|
|
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
|
|
|
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
|
|
|
class PingPangPlayer extends Player implements SpeakEnglish {
|
|
|
/********* begin *********/
|
|
|
public PingPangPlayer(String name,int age){
|
|
|
super(name,age);
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
|
|
|
}
|
|
|
public void study(){
|
|
|
System.out.println("乒乓球运动员学习如何发球和接球");
|
|
|
}
|
|
|
public void speak(){
|
|
|
System.out.println("乒乓球运动员说英语");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
|
|
|
// 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
|
|
|
class BasketballPlayer extends Player {
|
|
|
/********* begin *********/
|
|
|
public BasketballPlayer(String name,int age){
|
|
|
super(name,age);
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println("篮球运动员吃牛肉，喝牛奶");
|
|
|
}
|
|
|
public void study(){
|
|
|
System.out.println("篮球运动员学习如何运球和投篮");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
|
|
|
// 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
|
|
|
// 实现自己的speak()方法 输出'乒乓球教练说英语'
|
|
|
class PingPangCoach extends Coach implements SpeakEnglish {
|
|
|
/********* begin *********/
|
|
|
public PingPangCoach(String name,int age){
|
|
|
super(name,age);
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println("乒乓球教练吃小白菜，喝大米粥");
|
|
|
}
|
|
|
public void teach(){
|
|
|
System.out.println("乒乓球教练教如何发球和接球");
|
|
|
}
|
|
|
public void speak(){
|
|
|
System.out.println("乒乓球教练说英语");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
|
|
// 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
|
|
|
// 无参构造函数
|
|
|
// 有参构造函数初始化name和age
|
|
|
// 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
|
|
|
// 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
|
|
|
class BasketballCoach extends Coach {
|
|
|
/********* begin *********/
|
|
|
public BasketballCoach(String name,int age){
|
|
|
super(name,age);
|
|
|
name=super.getname();
|
|
|
age=super.getage();
|
|
|
}
|
|
|
public void eat(){
|
|
|
System.out.println("篮球教练吃羊肉，喝羊奶");
|
|
|
}
|
|
|
public void teach(){
|
|
|
System.out.println("篮球教练教如何运球和投篮");
|
|
|
}
|
|
|
/********* end *********/
|
|
|
}
|
|
|
|
