Java程序设计（头歌实训1--实训11）
Java面向对象 - 封装、继承和多态
什么是封装，如何使用封装
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 + "岁");
}
}
什么是继承，怎样使用继承
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() + "吃骨头");
}
}
方法的重写与重载
package case4;
public class overridingTest {
public static void main(String[] args) {
/********* begin *********/
// 声明并实例化一Person对象p
Person p = new Person();
p.setName("张三");
p.setAge(18);
p.talk();
}
}
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.print("我是："+ name + "，今年：" + age + "岁，我在哈佛大学上学");
}
}
class Student extends Person {
/********* begin *********/
/********* end *********/
}
抽象类
package case5;
public class abstractTest {
public static void main(String[] args) {
/********* begin *********/
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
new Student("张三", 20, "学生").talk();
new Worker("李四", 30, "工人").talk();
// 分别调用各自类中被复写的talk()方法 打印信息。
/********* end *********/
}
}
abstract class Person {
/********* begin *********/
String name;
int age;
String occupation;
public Person(String name, int age, String occupation) {
super();
this.name = name;
this.age = age;
this.occupation = occupation;
}
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
public Student(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
//Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
public Worker(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("工人——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
接口
package case7;
public class interfaceTest {
public static void main(String[] args) {
// 实例化一Student的对象s，并调用talk()方法，打印信息
/********* begin *********/
new Student().talk();
/********* end *********/
}
}
interface Person {
public static final String name = "张三";
public static final int age = 18;
public static final String occupation = "学生";
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student implements Person {
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
什么是多态，怎么使用多态
package case8;
public class TestPolymorphism {
public static void main(String[] args) {
// 以多态方式分别实例化子类对象并调用eat()方法
/********* begin *********/
new Dog().eat();
new Cat().eat();
new Lion().eat();
/********* end *********/
}
}
class Animal {
/********* begin *********/
public void eat() {
System.out.println("eating");
}
/********* 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面向对象 - 封装、继承和多态
顺序输出
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 ta = new MyThread("AA",b,a);
MyThread tb = new MyThread("BB",c,b);
MyThread tc = new MyThread("CC",a,c);
ta.start();
tb.start();
tc.start();
/********* End *********/
}
}
class MyThread extends Thread {
/********* Begin *********/
String threadName;
Object p;
Object s;
public MyThread(String threadName, Object p, Object s){
this.threadName = threadName;
this.p = p;
this.s = s;
}
public void run() {
int count = 5;
while(count > 0){
synchronized(p){
synchronized(s){
System.out.println("Java Thread" + this.threadName);
count--;
s.notify();
}
try{
p.wait();
}catch(Exception e){
}
}
}
System.exit(0);
}
/********* End *********/
}
练习-Java输入输出之字节数据输入输出之综合练习
第1关：练习-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 input1 = input.next();
String output = input.next();
FileInputStream fis = new FileInputStream(input1);
FileOutputStream fos = new FileOutputStream(output);
int read = 0;
byte[] buff = new byte[8];
while((read = fis.read(buff)) != -1){
fos.write(buff,0,read);
}
fis.close();
fos.close();
/********** End **********/
}
}
Java高级特性 - IO流
第1关：什么是IO流
题目
1、下列关于字节和字符的说法正确的是（BC）
A、字节 = 字符 + 编码
B、字符 = 字节 + 编码
C、字节 = 字符 + 解码
D、字符 = 字节 + 解码
2、下列描述正确的是：（C ）
A、使用代码读取一个文件的数据时，应该使用输出流。
B、使用代码复制文件的时候，只需要使用输出流。
C、使用代码读取一个文本文件的数据时，只需要使用输入流即可。
D、从客户端向服务端发送数据可以使用输入流。
第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 *********/
File file = new File("src/step2/input/task.txt");
FileInputStream fs = new FileInputStream(file); //定义一个文件输入流
byte[] b = new byte[8]; //定义一个字节数组
fs.read(b); //将输入流的数据读入到字节数组
String str = new String(b,"UTF-8"); //通过utf-8编码表将字节转换成字符
System.out.println(str);
File dir = new File("src/step2/output");
if(!dir.exists()){
dir.mkdir();
}
FileOutputStream out = new FileOutputStream("src/step2/output/output.txt"); //创建输出流
String str1 = "learning practice";
byte[] c = str1.getBytes(); //将字符串转换成字节
out.write(c); //写数据
out.flush(); //刷新缓存区数据
fs.close(); //释放资源
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[] 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.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();
}
}
实验三 类的继承与派生 - 封装、继承和多态的综合练习
第1关：通关任务一
任务描述
本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。
package case1;
import java.util.Scanner;
public class Task1 {
public static void main(final String[] args) {
final Scanner sc = new Scanner(System.in);
final String dogName = sc.next();
final String dogSex = sc.next();
final String dogColor = sc.next();
final String catName = sc.next();
final String catSex = sc.next();
final double catWeight = sc.nextDouble();
// 通过有参构造函数实例化Dog类对象dog
// dog调用talk()方法
// dog调用eat()方法
/********* begin *********/
Dog dog = new Dog(dogName,dogSex,dogColor);
dog.talk();
Dog dog2 = new Dog(dogName);
dog2.eat();
/********* end *********/
// 通过有参构造函数实例化Cat类对象cat
// cat调用talk()方法
// cat调用eat()方法
/********* begin *********/
Cat cat = new Cat(catName ,catSex,catWeight);
cat.talk();
Cat cat2 = new Cat(catName);
cat2.eat();
/********* end *********/
}
}
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
/********* begin *********/
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 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 *********/
private String color;
public String getColor() {
return color;
}
public void setColor( String color) {
this.color = color;
}
Dog(String name) {
setName(name);
}
Dog(String name,String sex,String color) {
setName(name);
setSex(sex);
setColor(color);
}
public void talk(){
System.out.println("名称："+getName()+"，性别："+getSex()+"，颜色："+getColor()+"，汪汪叫");
}
public void eat() {
System.out.println(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;
}
Cat(String name) {
setName(name);
}
Cat(String name,String sex,double weight) {
setName(name);
setSex(sex);
setWeight(weight);
}
public void talk() {
System.out.println("名称：" + getName() + "，性别：" + getSex() + "，体重：" + getWeight() + "kg，喵喵叫");
}
public void eat() {
System.out.println(getName()+"吃鱼！");
}
/********* end *********/
}
第2关：通关任务二
任务描述
本关任务：按要求编写一个Java应用程序，巩固Java封装、继承和多态的知识。
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 *********/
Task2 task = new Task2();
Person person1 = new Chinese(cName, cSex, cAge);
task.showEat(person1);
Person person2 = new English(eName, eSex, eAge);
task.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 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;
Person(String name,String sex,int age){
this.name = name;
this.sex = sex;
this.age = 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 abstract void eat();
/********* end *********/
}
// Chinese类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
// 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
class Chinese extends Person {
/********* begin *********/
Chinese(String name, String sex, int age) {
super(name, sex, age);
}
public void eat(){
System.out.println("姓名："+getName()+"，性别："+getSex()+"，年龄："+getAge()+"，我是中国人，我喜欢吃饭！");
}
public void shadowBoxing(){
System.out.println(getName()+"在练习太极拳！");
}
/********* end *********/
}
// English类继承自Person类
// 构造函数初始化name、sex和age
// 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
// 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
class English extends Person {
/********* begin *********/
English(String name, String sex, int age) {
super(name, sex, age);
}
public void eat(){
System.out.println("姓名："+getName()+"，性别："+getSex()+"，年龄："+getAge()+"，我是英国人，我喜欢吃三明治！");
}
public void horseRiding(){
System.out.println(getName()+"在练习骑马！");
}
/********* end *********/
}
第3关：通关任务三
任务描述
本关任务：通过一个简单实例讲解并自己动手编写一个Java应用程序，全面复习Java面向对象知识。
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("----------------");
sc.close();
}
}
// 说英语接口 声明抽象方法speak()
interface SpeakEnglish {
/********* begin *********/
public abstract void speak();
/********* end *********/
}
// 定义人的抽象类Person 封装name和age
// 无参构造函数
// 有参构造函数初始化name和age
// 定义具体方法sleep() 输出'人都是要睡觉的'
// 抽象方法eat()（吃的不一样）
abstract class Person {
/********* begin *********/
private String name;
private int age;
Person(){}
Person(String name,int age){
this.name = name;
this.age = age;
}
public void sleep(){
System.out.println("人都是要睡觉的");
}
public abstract void eat();
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 *********/
}
// 定义运动员Player（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
abstract class Player extends Person {
/********* begin *********/
Player(){}
Player(String name,int age){
setName(name);
setAge(age);
}
public abstract void study();
/********* end *********/
}
// 定义教练Coach（抽象类）继承自Person类
// 无参构造函数
// 有参构造函数初始化name和age
// 教练教的不一样 定义抽象方法teach()
abstract class Coach extends Person {
/********* begin *********/
Coach(){};
Coach(String name,int age){
setName(name);
setAge(age);
}
/********* end *********/
}
// 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
// 无参构造函数
// 有参构造函数初始化name和age
// 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
// 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
// 实现自己的speak()方法 输出'乒乓球运动员说英语'
class PingPangPlayer extends Player implements SpeakEnglish {
/********* begin *********/
PingPangPlayer(){}
PingPangPlayer(String name,int age){
setName(name);
setAge(age);
}
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 *********/
BasketballPlayer(){};
BasketballPlayer(String name,int age){
setName(name);
setAge(age);
}
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 *********/
PingPangCoach(){}
PingPangCoach(String name,int age){
setName(name);
setAge(age);
}
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 *********/
BasketballCoach() {}
BasketballCoach(String name,int age){
setName(name);
setAge(age);
}
public void eat(){
System.out.println("篮球教练吃羊肉，喝羊奶");
}
public void teach(){
System.out.println("篮球教练教如何运球和投篮");
}
/********* end *********/
}
Java类的继承与派生 - 封装、继承和多态
第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 + "岁");
}
}
第2关：什么是继承，怎样使用继承
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() + "吃骨头");
}
}
第3关：方法的重写与重载
package case4;
public class overridingTest {
public static void main(String[] args) {
/********* begin *********/
// 声明并实例化一Person对象p
Person p = new Person();
p.setName("张三");
p.setAge(18);
p.talk();
}
}
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.print("我是："+ name + "，今年：" + age + "岁，我在哈佛大学上学");
}
}
class Student extends Person {
/********* begin *********/
/********* end *********/
}
第4关：抽象类
package case5;
public class abstractTest {
public static void main(String[] args) {
/********* begin *********/
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
new Student("张三", 20, "学生").talk();
new Worker("李四", 30, "工人").talk();
// 分别调用各自类中被复写的talk()方法 打印信息。
/********* end *********/
}
}
abstract class Person {
/********* begin *********/
String name;
int age;
String occupation;
public Person(String name, int age, String occupation) {
super();
this.name = name;
this.age = age;
this.occupation = occupation;
}
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
public Student(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
//Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
public Worker(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("工人——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
第5关：接口
package case7;
public class interfaceTest {
public static void main(String[] args) {
// 实例化一Student的对象s，并调用talk()方法，打印信息
/********* begin *********/
new Student().talk();
/********* end *********/
}
}
interface Person {
public static final String name = "张三";
public static final int age = 18;
public static final String occupation = "学生";
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student implements Person {
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
Java入门（第四章）- 分支结构
第1关：Java分支结构之 if...else
第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******/
}
}
第2关：Java分支结构之Switch
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 12:
case 1:
case 2:
System.out.print(input + "月是冬天");
break;
case 3:
case 4:
case 5:
System.out.print(input + "月是春天");
break;
case 6:
case 7:
case 8:
System.out.print(input + "月是夏天");
break;
case 9:
case 10:
case 11:
System.out.print(input + "月是秋天");
break;
}
/*****end*****/
}
}
Java高级特性 - 多线程基础（3）线程同步
第1关：使用synchronized关键字同步线程
package step2;
public class Task {
public static void main(String[] args) {
final insertData insert = new insertData();
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
public void run() {
insert.insert(Thread.currentThread());
}
}).start();
}
}
}
class insertData{
public static int num =0;
/********* Begin *********/
public synchronized void insert(Thread thread){
for (int i = 0; i <= 5; i++) {
num++;
System.out.println(num);
}
}
/********* End *********/
}
Java面向对象-Java中的异常
第1关：Java 中的异常处理机制
题目
1、在Java中，源文件Test.java中包含如下代码段，则程序编译运行结果是（ ）
public class HelloWorld{
public static void main(String[] args){
System.out.print(“HelloWorld!”);
}
}
A、输出：HelloWorld!
B、编译出错，提示“公有类HelloWorld必须在HelloWorld.java文件中定义”
C、运行正常，但没有输出内容
D、运行时出现异常
2、下列关于检测性异常和非检测性异常正确的是（ ）
A、IOException及其子类（FileNotFoundException等），都属于检测型异常
B、检测型异常不需要程序员来处理
C、运行时异常可以处理，也可以不处理，是可选的
D、错误也属于异常的一种
E、所有的异常类是从 java.lang.Exception 类继承的子类
3、关于下列代码，说法正确的是（）
public static void main(String[] args){
int num1 = 10;
int num2 = 0;
System.out.println(num1/num2);
}
A、输出0
B、编译报错，提示除数不能为0
C、输出无穷大
D、运行时报错，提示除数不能为0
第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(Exception e){
System.out.println("除数不能为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{
MyException(String msy){
super(msy);
}
}
/********* End *********/
学习-Java异常处理之try-catch之异常捕获
第1关：学习-Java异常处理之try-catch之异常捕获
import java.util.Scanner;
public class ExcTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：接收给定的整数
Scanner x=new Scanner(System.in);
int a=x.nextInt();
int b=x.nextInt();
// 第二步：求给定两个数的商，并捕获除数为0的异常
try{
int q=a/b;
System.out.print(q);
/********** End **********/
}
catch(Exception e)
{
System.out.print("除数不能为0");
}
}}
Java入门 - 数组基础
第1关：初识数组
package step1;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
int[] scores={91,88,60};
System.out.println("数组的第一个值为："+scores[0]); //在这里输出数组的第一个值
System.out.println("数组的第二个值为："+scores[1]); //在这里输出数组的第二个值
System.out.println("数组的第三个值为："+scores[2]); //在这里输出数组的第三个值
/********** End **********/
}
}
第2关：数组的使用
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]);
int[] scores;
Scanner sc = new Scanner(System.in);
//在这里使用Scanner获取系统输入的整数,并用获取到的数据来设置scores数组的长度
int length = sc.nextInt() ;
scores = new int [length] ;
/********** End **********/
System.out.println("数组scores的长度为：" + scores.length);
}
}
第3关：选择题（1）
题目
1、以下数组声明有误的是（C）
A、int[] num;
B、String num[];
C、double[] num=new double[];
D、String num[]=new String[5];
2、定义数组如下
String[] s={“ab”,”cd”,”ef”};
运行语句System.out.println(s[3]);程序运行的结果为（D）
A、ab
B、cd
C、ef
D、程序出错了
3、数组初始化有错误的是（ABCD）
A、int[] num={12,53.7,’6’};
B、String sewd[]=new String[]{12,52,63};
C、char car[]={‘’1,’2’,6’’};
D、double[] dou=new int[10];
第4关：数组练习-平均值和最大值
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的平均值和最大值
int sum=0;
for(int i=0;i<scores.length;i++){
sum+=scores[i];
}
double temp=(double)sum/(double)scores.length;
int t=-1;
for(int i=0;i<scores.length;i++){
if(t<scores[i]){
t=scores[i];
}
}
System.out.println("平均值：" +temp );
System.out.println("最大值：" +t );
/********** End **********/
}
}
第5关：二维数组
package step4;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
int[][]score={
{92,85},
{91,65},
{90,33}
};
for(int i=0;i<score.length;i++){
for(int j=0;j<score[i].length;j++){
System.out.println(score[i][j]);
}
}
for(int i=0;i<score.length;i++){
score[i][0]=1;
score[i][1]=2;
}
for(int i=0;i<score.length;i++){
for(int j=0;j<score[i].length;j++){
System.out.println(score[i][j]);
}
}
/********** End **********/
}
}
第6关：选择题（2）
题目
1、声明数组如下：
float[][] f=new float[2][3];
那么该数组一共有（C ）个元素
A、2
B、4
C、6
D、8
2、以下的程序是否有错（D）
A、不能运行
B、编译不通过
C、会正常运行
D、以上说法都不对
Java面向对象 - Java中的异常
第1关：Java 中的异常处理机制
题目
1、
在Java中，源文件Test.java中包含如下代码段，则程序编译运行结果是（ B）
public class HelloWorld{
public static void main(String[] args){
System.out.print(“HelloWorld!”);
}
}
A、输出：HelloWorld!
B、编译出错，提示“公有类HelloWorld必须在HelloWorld.java文件中定义”
C、运行正常，但没有输出内容
D、运行时出现异常
2、关于下列代码，说法正确的是（D）
public static void main(String[] args){
int num1 = 10;
int num2 = 0;
System.out.println(num1/num2);
}
A、输出0
B、编译报错，提示除数不能为0
C、输出无穷大
D、运行时报错，提示除数不能为0
第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(Exception e){
System.out.print("除数不能为0");
}
/********* End *********/
}
}
Java入门 - 数组进阶
第1关：数组的复制
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 i=0;i<arr2.length;i++)
{
arr2[i]=arr1[i];
System.out.println(arr2[i]);
}
//输出arr2
/********** End **********/
}
}
第2关：数组中元素的查找
package step2;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//str为要查找的字符串
String str = sc.next();
/********** Begin **********/
//创建数组 arr 给数组赋值 {"张三","张三丰","张无忌","王二麻子","张富贵"}
String[] arr = new String[]{"张三","张三丰","张无忌","王二麻子","张富贵"};
for(int i = 0;i<arr.length;i++){
if(str.equals(arr[i])){
System.out.println(str+"在数组的第"+(i+1)+"个位置");
break;
}
}
/********** End **********/
}
}
第3关：交换算法
package step3;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
/********** Begin **********/
//将a的值赋给b b的值赋给a
int c=0;
c=a;
a=b;
b=c;
/********** End **********/
System.out.println(a);
System.out.println(b);
}
}
第4关：选择排序
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 **********/
int max=arr[0];
for(int i=0;i<arr.length;i++){
if(max<arr[i]){
max=arr[i];
}
}
for(int i=0;i<arr.length-1;i++){
if(arr[0]<arr[i+1]){
int temp=arr[0];
arr[0]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=1;i<arr.length-1;i++){
if(arr[1]<arr[i+1]){
int temp=arr[1];
arr[1]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=2;i<arr.length-1;i++){
if(arr[2]<arr[i+1]){
int temp=arr[2];
arr[2]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=3;i<arr.length-1;i++){
if(arr[3]<arr[i+1]){
int temp=arr[3];
arr[3]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=4;i<arr.length-1;i++){
if(arr[4]<arr[i+1]){
int temp=arr[4];
arr[4]=arr[i+1];
arr[i+1]=temp;
}
}
System.out.println(Arrays.toString(arr));
/********** End **********/
}
}
第5关：冒泡排序
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 i=0;i<arr.length-1;i++){
if(arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=0;i<arr.length-2;i++){
if(arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=0;i<arr.length-3;i++){
if(arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=0;i<arr.length-4;i++){
if(arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=0;i<arr.length-5;i++){
if(arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=0;i<arr.length-6;i++){
if(arr[i]>arr[i+1]){
int temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
for(int i=0;i<arr.length-7;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 **********/
}
}
Java高级特性 - IO流Java高级特性 - IO流
第1关：字符流 - 输入输出
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 *********/
FileReader read = new FileReader("src/step3/input/input.txt");
FileWriter writer = new FileWriter("src/step3/output/output.txt");
char[] buff = new char[1024];
int arr = 0;
while((arr = read.read(buff)) != -1){
writer.write(buff,0,arr);
}
read.close();
writer.close();
/********* End *********/
}
}
第2关：复制文件
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();
}
}
Java高级特性 - IO流
第1关：什么是IO流
题目
1、下列关于字节和字符的说法正确的是（BC）
A、字节 = 字符 + 编码
B、字符 = 字节 + 编码
C、字节 = 字符 + 解码
D、字符 = 字节 + 解码
2、下列描述正确的是：（ C）
A、使用代码读取一个文件的数据时，应该使用输出流。
B、使用代码复制文件的时候，只需要使用输出流。
C、使用代码读取一个文本文件的数据时，只需要使用输入流即可。
D、从客户端向服务端发送数据可以使用输入流。
第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 *********/
File file = new File("src/step2/input/task.txt");
FileInputStream fs = new FileInputStream(file); //定义一个文件输入流
byte[] b = new byte[8]; //定义一个字节数组
fs.read(b); //将输入流的数据读入到字节数组
String str = new String(b,"UTF-8"); //通过utf-8编码表将字节转换成字符
System.out.println(str);
File dir = new File("src/step2/output");
if(!dir.exists()){
dir.mkdir();
}
FileOutputStream out = new FileOutputStream("src/step2/output/output.txt"); //创建输出流
String str1 = "learning practice";
byte[] c = str1.getBytes(); //将字符串转换成字节
out.write(c); //写数据
out.flush(); //刷新缓存区数据
fs.close(); //释放资源
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[] 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.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();
}
}
实验三 类的继承与派生 - 封装、继承和多态
第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 + "岁");
}
}
第2关：什么是继承，怎样使用继承
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() + "吃骨头");
}
}
第3关：super关键字的使用
package case3;
public class superTest {
public static void main(String[] args) {
// 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
/********* begin *********/
Student s =new Student("张三",18,"哈佛大学");
System.out.println("姓名："+s.name+"，年龄："+s.age+"，学校："+s.school);
/********* end *********/
}
}
class Person {
/********* begin *********/
String name;
int age;
public Person (String name, int age){
this.name=name;
this.age=age;
}
/********* end *********/
}
class Student extends Person {
/********* begin *********/
String school;
public Student(String name,int age,String school){
super(name,age);
this.school = school;
}
/********* end *********/
}
第4关：方法的重写与重载
package case4;
public class overridingTest {
public static void main(String[] args) {
/********* begin *********/
// 声明并实例化一Person对象p
Person p = new Person();
p.setName("张三");
p.setAge(18);
p.talk();
}
}
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.print("我是："+ name + "，今年：" + age + "岁，我在哈佛大学上学");
}
}
class Student extends Person {
/********* begin *********/
/********* end *********/
}
第5关：抽象类
package case5;
public class abstractTest {
public static void main(String[] args) {
/********* begin *********/
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
new Student("张三", 20, "学生").talk();
new Worker("李四", 30, "工人").talk();
// 分别调用各自类中被复写的talk()方法 打印信息。
/********* end *********/
}
}
abstract class Person {
/********* begin *********/
String name;
int age;
String occupation;
public Person(String name, int age, String occupation) {
super();
this.name = name;
this.age = age;
this.occupation = occupation;
}
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
public Student(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
//Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
public Worker(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("工人——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
第6关：final关键字的理解与使用
第7关：接口
package case7;
public class interfaceTest {
public static void main(String[] args) {
// 实例化一Student的对象s，并调用talk()方法，打印信息
/********* begin *********/
new Student().talk();
/********* end *********/
}
}
interface Person {
public static final String name = "张三";
public static final int age = 18;
public static final String occupation = "学生";
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student implements Person {
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
第8关：什么是多态，怎么使用多态
package case8;
public class TestPolymorphism {
public static void main(String[] args) {
// 以多态方式分别实例化子类对象并调用eat()方法
/********* begin *********/
new Dog().eat();
new Cat().eat();
new Lion().eat();
/********* end *********/
}
}
class Animal {
/********* begin *********/
public void eat() {
System.out.println("eating");
}
/********* 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 Java 主方法中的顺序结构
学习-Java顺序结构之无输入求多边形的面积
编程要求
仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。注意最后的输出格式为“该多边形的面积为 xxx”，其中 xxx 为多边形的面积。
测试说明
平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。
可在右侧“测试结果”区查看具体的测试集详情。
/**
* 任务：计算一个由正方形和等腰三角形组成的多边形的面积，其中正方形边长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*0.5;
// 第3步：计算多边形面积，即正方形面积和等腰三角形面积，赋值给变量area_total
double area_total=area_square+area_triangle;
// 第4步：打印输出多边形面积，即使用不换行输出语句输出变量area_total的值 输出格式：该多边形的面积为 xxx 其中xxx 为多边形的面积
System.out.print("该多边形的面积为 "+area_total);
/********** End **********/
}
}
练习-Java顺序结构之无输入求平抛小球与抛出点之间的距离
编程要求
仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。
小提示：
Java 的 Math 类提供了幂运算和开平方两种方法，可以帮我们解决本关的一些问题，在这里简单介绍一下，在后面的实训中我们会详细为大家介绍 Math 类的使用。
/**
* 任务：一小球以 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
double s = v0*t;
// 第二步：计算垂直距离，并赋值给h
double h = (g*t*t) / 2;
// 第三步：计算小球与原点的距离，并赋值给d，Math.sqrt()表示的是对括号里的值求平方根
double d = Math.sqrt( Math.pow(s,2) + Math.pow(h,2) );
// 第四步：打印出小球与原点的距离d 输出格式：小球所在位置与抛出点之间的距离为 xxx 米。 其中 xxx 为求出的距离
System.out.println("小球所在位置与抛出点之间的距离为 " + d +" 米。");
/********** End **********/
}
}
学习-Java 顺序结构之无输入之输出给定图案
/**
* 任务：输出实心等腰三角形。
* 类名为：OutputTriangle
*/
public class OutputTriangle {
public static void main(String[] args) {
// 请在下面的 Begin-End 处，按照所给的代码注释完成相应代码的编写
/********** Begin **********/
// 使用空格和*，向控制台输出一个高为4，底为7的等腰三角形，最后一个输出采用不换行输出
int i,j,k;
for(i=1;i<=4;i++)
{
for(k=3;k>i-1;k--)
System.out.print(" ");
for(j=1;j<=2*i-1;j++)
System.out.print("*");
System.out.println();
}
/********** End **********/
}
}
学习-Java顺序结构之无输入格式化输出求星期几
/**
* 任务：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 weeknum=sum%pre;
// 第四步：格式化输出这个值 如果结果是1，那么输出格式为：10天后是星期 1。
System.out.print("10天后是星期 "+weeknum+"。");
/********** End **********/
}
}
学习-Java顺序结构之有输入格式化输出平抛小球与抛出点之间的距离
/**
* 任务：一小球以 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=0.5*g*t*t;
// 第六步：计算小球与原点的距离，并赋值给d，Math.sqrt()可以用来对括号里的值求平方根
double d=Math.sqrt(s*s+h*h);
// 第七步：打印出小球与原点的距离d，最后结果四舍五入后保留两位小数
System.out.printf("%.2f",d);
/********** End **********/
}
}
学习-Java顺序结构之数学函数之求两数最大者
/**
* 任务：获取键盘两次输入的值，输出两者中的最大数。
* 类名为：CompareMax
*/
import java.util.Scanner;
public class CompareMax {
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 第一步：获取键盘第一次输入的值
double a=reader.nextDouble();
// 第二步：获取键盘第二次输入的值
double b=reader.nextDouble();
// 第三步：比较两数大小
double d=Math.max(a,b);
// 第四步：不换行输出最大的那个值
System.out.print(d);
/********** End **********/
}
}
练习-Java顺序结构之数学函数之根据三角形三边长求面积
/**
* 任务：根据从键盘输入的三角形的三个边长，求出三角形的面积。
* 类名为：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=0.5*(a+b+c);
double s=Math.sqrt(p*(p-a)*(p-b)*(p-c));
// 第三步：格式化输出三角形的面积
System.out.printf("三角形的面积为：%.2f",s);
/********** End **********/
}
}
练习-Java顺序结构之数学函数之三角函数
/**
* 任务：从键盘输入的值分别为三角形的 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 d = Math.sin(Math.toRadians(c));
// 第五步：根据三角形面积公式求取三角形面积，此处用0.5代替1/2
double s = 0.5 * a * b * d;
// 第六步：不换行输出三角形的面积
System.out.printf("%.2f",s);
/********** End **********/
}
}
学习-Java顺序结构之基本数据类型转换
/**
* 任务：变量 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型
int c=(int)a ;
// 第二步：将short型变量b转换为double型
double d=b;
// 第三步：换行输出变量a转换后的结果
System.out.println(c);
// 第四步：不换行输出变量b转换后的结果
System.out.print(d);
/********** End **********/
}
}
练习-Java顺序结构综合练习一之银行复利计息收益计算
/**
* 任务：假定一个用户每月向一个储蓄帐户中存 1000 元人民币，年利率为 2.25％。那么月利率为 0.0225/12=0.001875。
* 编写一个程序，输出 6 个月后的账户金额。
* 类名为：BankRate
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 第一步：创建一个名为 BankRate 的公开类
public class BankRate{
// 第二步：在这个类中定义主方法
public static void main(String[] agrs) {
// 第三步：在主方法中计算第六个月后总资金为多少
double monthlyInterestRate = 0.0225 / 12; // 月利率
double initialAmount = 1000; // 初始存款
double totalAmount = initialAmount; // 总金额
for (int i = 0; i < 6; i++) {
totalAmount += totalAmount * monthlyInterestRate; // 计算每个月的利息并累加到总金额
}
// 第四步：格式化输出六个月后账户的总金额，结果保留两位小数
System.out.printf("%.2f", totalAmount);
}
}
/********** End **********/
练习- Java顺序结构综合练习二之温度换算
/**
* 任务：编写一个程序，依次将摄氏温度为 1°、2°、3°、4°、5° 所对应的华氏温度的值四舍五入后保留两位小数输出， 摄氏温度和华氏温度转换公式如下：
* fahrenheit（华氏温度） = ( 9/5 ) × celsius（摄氏温度） + 32。
* 类名为：Temperature
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 第一步：创建一个名为 Temperature 的公开类
public class Temperature{
// 第二步：在这个类中定义主方法
public static void main(String[] args) {
// 第三步：在主方法中依次计算摄氏温度为 1°、2°、3°、4°、5° 所对应的华氏温度的值，四舍五入后保留两位小数，最后格式化输出华氏温度的值，例子：摄氏温度为1时，华氏温度为xx。
for (int i = 1; i < 6; i++) {
double celsius = i;
double fahrenheit = (9.0 / 5) * celsius + 32;
System.out.print("摄氏温度为" + i + "时，华氏温度为");
System.out.printf("%.2f", fahrenheit);
System.out.println("。");
}
}
}
/********** End **********/
练习- Java顺序结构综合练习三之金融投资收益计算
/**
* 任务：编写程序，读入投资额、年利率和投资年限，利用题目所给公式计算投资的未来价值
* 类名为：Finance
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 第一步：导入Scanner类
import java.util.*;
// 第二步：创建一个名为 Finance 的公开类
public class Finance {
// 第三步：定义主方法
public static void main(String[] args){
// 第四步：在主方法中，根据题目给出的计算投资的未来价值公式来计算未来价值
Scanner reader= new Scanner(System.in);
double a=reader.nextDouble();
double b=reader.nextDouble();
int c=reader.nextInt();
double sum=a*Math.pow(1+b/12,12*c);
// 第五步：格式化输出未来价值，结果保留两位小数
System.out.printf("%.2f",sum);
}
}
/********** End **********/
实训2 Java 主方法中的分支结构
学习-Java单路分支之求三个数中最大者
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单路分支之按序输出三个数
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双路分支之偶数判断
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.println("两个数同为偶数！");
// 第三步，如果不同为偶数，则打印输出“两个数至少有一个数为奇数！”
}else
{
System.out.println("两个数至少有一个数为奇数！");
}
/********** End **********/
}
}
练习-Java双路分支之判断回文数
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 i = num % 10;
// 第二步：获取十位数的数值
int i1 = num / 10 % 10;
// 第三步：获取百位数的数值
int i2 = num / 100 % 10;
// 第四步：获取千位数的数值
int i3 = num / 1000 % 10;
// 第五步：获取万位数的数值
int i4 = num / 10000 % 10;
// 第六步：将获取的个位数值乘以 10000
int a = i * 10000;
// 第七步：将获取的十位数值乘以 1000
int a1 = i1 * 1000;
// 第八步：将获取的百位数值乘以 100
int a2 = i2 * 100;
// 第九步：将获取的千位数值乘以 10
int a3 = i3 * 10;
// 第十步：将获取的万位数值乘以 1
int a4 = i4;
// 第十一步：将第六、七、八、九、十步转换后的数值相加
int a5 = a + a1 + a2 + a3 + a4;
// 第十二步：判断变量 num 是否等于第十一步的数值，如果等于，则在控制台输出“回文数”；反之，则输出“不是回文数”
if (num == a5) {
System.out.println("回文数");
} else {
System.out.println("不是回文数");
}
/********** End **********/
}
}
学习-Java双路分支之条件表达式之成绩判断
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多路分支之字符类型判断
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 asciiValue = (int)a;
// 第二步：判断强制转换成 int 类型的变量是否大于等于 65，同时小于等于 90 ，如果满足条件，则在控制台输出"该字符是大写字母"
if (asciiValue >= 65 && asciiValue <= 90) {
System.out.println("该字符是大写字母");
// 第三步：判断强制转换成 int 类型的变量是否大于等于 97，同时小于等于 122 ，如果满足条件，则在控制台输出"该字符是小写字母"
} else if (asciiValue >= 97 && asciiValue <= 122) {
System.out.println("该字符是小写字母");
// 第四步：判断强制转换成 int 类型的变量是否大于等于 48，同时小于等于 57 ，如果满足条件，则在控制台输出"该字符是数字"
} else if (asciiValue >= 48 && asciiValue <= 57) {
System.out.println("该字符是数字");
// 第五步：如果以上条件都不满足，则在控制台输出"该字符是其他字符"
} else {
System.out.println("该字符是其他字符");
}
/********** End **********/
}
}
练习-Java多路分支之月份天数计算
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
switch(month)
{
case 1:day=31;break;
case 3:day=31;break;
case 5:day=31;break;
case 7:day=31;break;
case 8:day=31;break;
case 10:day=31;break;
case 12:day=31;break;
}
// 第二步：判断变量 month 是否为 4、6、9、11 内的月份，如果是，则将数值 30 赋值给 day
if(month==4 || month==6 || month==9 || month==11)
{
day=30;
}
// 第三步：如果以上条件都不满足，则进入最后一种情况
if(month==2)
{
// 第四步：判断是否是闰年，是闰年，则将数值 29 赋值给 day；反之，则将数值 28 赋值给 day
if((year%400==0)||((year%4==0)&&(year%100!=0)))
{
day=29;
}
else
{
day=28;
}
}
/********** End **********/
System.out.print(year + "年" + month + "月有" + day + "天");
}
}
学习-Java多路分支之switch之百分制成绩转换GPA成绩
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 构建 A 、B、C、D、E 五条分支
* 分支 A ，控制台输出 “百分制分数段为90分以上”
* 分支 B ，控制台输出 “百分制分数段为80-89分”
* 分支 C ，控制台输出 “百分制分数段为70-79分”
* 分支 D ，控制台输出 “百分制分数段为60-69分”
* 分支 E ，控制台输出 “百分制分数段为60分以下”
*/
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;
default:
System.out.print("百分制分数段为60分以下");
}
/********** End **********/
}
}
学习-Java分支结构之嵌套
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) {
// 第二步：判断变量 a 取模 2 是否为 0 ，如果为 0 ，则在控制台输出 "该数既是自然数又是偶数"；反之，则输出"该数为自然数，但不是偶数"
if(a % 2 == 0){
System.out.print("该数既是自然数又是偶数");
} else {
System.out.print("该数为自然数，但不是偶数");
}
} else {
System.out.print("该数不是自然数");
}
/********** End **********/
}
}
练习-Java分支结构综合练习一之一元二次方程求解
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 dt = b*b-4*a*c;
// 第二步：如果方程有两个根，计算这两个值，将其按照题目所给的格式输出
if(dt>0){
double t1 = ((-b) + Math.sqrt(dt))/(2*a);
double t2 = ((-b) - Math.sqrt(dt))/(2*a);
System.out.println("该方程有两个根");
System.out.print("x1 = ");
System.out.print(String.format("%.2f",t1));
System.out.print("，x2 = ");
System.out.println(String.format("%.2f",t2));
}else
// 第三步：如果方程只有一个跟，计算出该值，将其按照题目所给的格式输出
if(dt==0){
double x = (-b)/(2*a);
System.out.println("该方程只有一个根");
System.out.print("x = ");
System.out.println(String.format("%.2f",x));
}else
// 第四步：若方程无解，将其按照题目所给的格式输出
if(dt<0){
System.out.println("该方程无解");
}
/********** End **********/
}
}
练习-Java分支结构综合练习二之物流运费计算
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;
// 第一步：判断该运输距离的折扣为多少 如果0 < s < 250，则折扣为0，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
if(0<s&&s<250)
exp = p*w*s;
// 第二步：如果250 ≤ S < 500，则折扣为0.02，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
if(250<=s&&s<500)
exp = p*w*s*(1.0-2.0/100.0);
// 第三步：如果500 ≤ S < 1000，则折扣为0.05，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
if(500<=s&&s<1000)
exp = p*w*s*(1.0-5.0/100.0);
// 第四步：如果1000 ≤ S，则折扣为0.08，根据总运输费用的计算公式，计算出总运输费用，将结果四舍五入后保留两位小数输出。
if(1000<=s)
exp = p*w*s*(1.0-8.0/100.0);
System.out.println(String.format("%.2f",exp));
/********** End **********/
}
}
练习-Java分支结构综合练习三之根据年月日计算星期
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 += 12;
y--;
}
// 第二步：使用基姆拉尔森日期公式，计算星期几
int iWeek = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400) % 7;
// 第三步：使用多路分支判断星期几。如果是星期一，则在控制台输出"星期一"；如果是星期二，则在控制台输出"星期二"....以此类推，如果是星期日，就是在控制台输出"星期日"
switch (iWeek) {
case 0:
System.out.print("星期一");
break;
case 1:
System.out.print("星期二");
break;
case 2:
System.out.print("星期三");
break;
case 3:
System.out.print("星期四");
break;
case 4:
System.out.print("星期五");
break;
case 5:
System.out.print("星期六");
break;
case 6:
System.out.print("星期日");
break;
}
/********** End **********/
}
}
学习-Java循环之break之判断素数
/*
任务：判断给定的任意一个大于 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 reader=new Scanner(System.in);
int x,i,a=0;
x=reader.nextInt();
for(i=2;i<x;i++)
{
if(x%i==0)
a++;
}
if(a==0)
System.out.print(x+"是一个素数");
else
System.out.print(x+"不是一个素数");
/********** End **********/
}
}
学习-Java循环之continue
/*
任务：使用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++){
// 第二步：判断是否为偶数，如果是，跳出本次循环，如果不是，对奇数个数变量值加1
if(i%2==0)
continue;
else
count=count+1;
}
// 第三步：循环结束，输出总的奇数个数
System.out.print(n + "前面共有" + count + "个奇数。");
/********** End **********/
}}
练习-Java数组之二维数值数组之矩阵加
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();
}
/********** End **********/
}
}
练习-Java数组之二维数值数组之矩阵转置
public class Transpose {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 定义二维数组并初始化
int arraryA[][]={{5,6,7},{15,65,43},{32,43,22},{11,88,6},{4,98,66}};
// 定义转置后的新数组
int arraryB[][] = new int[arraryA[0].length][arraryA.length];
// 转置数组
for(int i=0;i<arraryA.length;i++)
{
for(int j=0;j<arraryA[i].length;j++)
{
arraryB[j][i]=arraryA[i][j];
}
}
// 打印新数组
for (int i=0;i<arraryB.length ;i++ )
{
for (int j=0;j<arraryB[i].length ;j++ )
{
System.out.print(arraryB[i][j]+" ");
}
System.out.println();
}
/********** End **********/
}
}
练习-Java字符串之String类常用方法之文件名与邮箱验证
import java.util.Scanner;
public class StrTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：接收输入的两个字符串，第一个是文件名，第二个是邮箱地址
Scanner scanner = new Scanner(System.in);
String fileName = scanner.next();
String email = scanner.next();
judge(fileName, email);
}
// 第二步：判断文件名是否正确
public static void judge(String fileName,String email){
int k = fileName.lastIndexOf(".java");
if (k > 0 && fileName.substring(k).equals(".java"))
System.out.println("Java文件名正确");
else
System.out.println("Java文件名无效");
// 第三步：判断邮箱地址是否正确
int n = email.indexOf("@");
int s = email.lastIndexOf("@");
int i = email.indexOf(".");
if (n != -1 && i > n && n == s)
System.out.println("邮箱名正确");
else
System.out.println("邮箱名无效");
/********** End **********/
}
}
练习-Java字符串之String类常用方法之花名册
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类和对象之对象引用之坐标系中两点距离计算
/**
* 任务：已知两个点 A、B 以及坐标分别为(2,3) 、(8,-5) ，求 A 和 B 两点之间的距离。
* 类名为：Distance
*/
public class Distance {
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
/**
* 定义一个静态方法，该方法计算坐标两点的距离，携带四个参数，分别为x1、y1、x2、y2的值
* 将距离结果返回，返回类型为double
*/
static double juli(double x1,double y1,double x2,double y2){
double x=Math.pow((x1-x2),2)+Math.pow((y1-y2),2);
return Math.sqrt(x);
}
// 定义主方法
public static void main(String args[]){
// 通过类名.方法名的方式调用计算两点间距离的方法，分别将A、B的x1、y1、x2、y2的值传入该方法中
double result=Distance.juli(2,3,8,-5);
// 不换行输出，输出格式: A、B两点的距离为xx
System.out.printf("A、B两点的距离为%f",result);
}
/********** End **********/
}
练习-Java类和对象之对象引用之模拟手机功能
/**
* 任务：实现手机的基本功能。
* 类名为：Phone
*/
public class Phone {
// 定义五个变量，分别表示品牌、型号、价格、操作系统和内存
private String brand;
private String type;
private String price;
private String os;
private int memory;
// 无参构造
public Phone() {
}
// 有参构造
public Phone(String brand, String type, String 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.println("品牌：" + brand);
System.out.println("型号：" + type);
System.out.println("操作系统：" + os);
System.out.println("价格：" + price);
System.out.println("内存：" + memory);
}
/**
* 定义一个方法，该方法实现打电话的功能，无返回值，
* 携带一个int型参数，其中1,2,3分别表示爸爸、妈妈、姐姐的号，
* 输出格式 如果参数为1，换行输出：正在给爸爸打电话
* 如果出现其它情况，换行输出：你所拨打的电话为空号
*/
public void call(int number) {
if (number == 1) {
System.out.println("正在给爸爸打电话");
} else if (number == 2) {
System.out.println("正在给妈妈打电话");
} else if (number == 3) {
System.out.println("正在给姐姐打电话");
} else {
System.out.println("你所拨打的电话为空号");
}
}
/**
* 定义一个方法，该方法实现听音乐的功能，无返回值
* 携带一个参数，其表示为歌曲名
* 不换行输出格式：正在播放xx
*/
public void play(String song) {
System.out.println("正在播放" + song);
}
// 定义主方法
public static void main(String[] args) {
// 通过有参构造创建手机对象
Phone phone = new Phone("小米", "小米9", "2599.0", "Android 9", 8);
// 查询手机信息
phone.about();
// 给妈妈拨打电话
phone.call(2);
// 播放浮夸这首歌
phone.play("浮夸");
}
}
学习-Java继承和多态之对象类型的转换
/**
* 使用对象类型的转换，根据编程提示，完成猫类和动物类的转换，以及彼此方法和属性的调用
*/
// 定义动物类
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(Animal.staticName);
// 输出Cat类的eat()方法
cat.eat();
// 输出Animal类的staticEat()方法
Animal.staticEat();
// 调用Cat类的str变量
System.out.println(cat.str);
// 调用Cat类的eatMethod()方法
cat.eatMethod();
/********** End **********/
}
}
练习-Java继承和多态之final关键字
/**
* 按照代码文件中提供的注释完成 Demo 类的编写，使得程序正常输出。
*/
class DemoTest{
int i = 10;
}
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********* Begin *********/
// 将Demo类改为 final 形式
// 将Demo类改为 final 形式
// 将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();
// 输出PI的值
System.out.println(Demo.PI);
// 修改 demoTest2 的值是可以的，因为它不是 final 的
System.out.println(demo.demoTest2.i);
// 修改数组中的元素是可以的，因为数组本身是 final 的，但数组元素的值可以改变
for (int i = 0; i < demo.a.length; i++) {
demo.a[i] = 9;
System.out.println(demo.a[i]);
}
}
}
/********** End **********/
练习-Java继承和多态之接口(Person.java文件)
/**
* 编写一个学校接待方面的程序，招待不同身份的人的食宿问题
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 定义一个接口类 Person
interface Person
{
// 定义 eat()，实现输出吃饭的功能，无返回值
abstract void eat();
// 定义 sleep()，实现睡觉的功能，无返回值
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继承和多态之接口(ComputeClass.java)
/**
* 编写程序，实现两个数的求和运算和比较
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 定义一个接口类 Compute
interface Compute{
// 第一个为 sum()，实现两个数的相加，返回值为 int
public abstract int sum();
// 第二个为 max()，比较两个数的大小，携带两个参数，类型为int，返回值为int
public abstract int max(int a,int b);
}
// 定义一个公开的 ComputeClass 类并实现 Compute 接口
public class ComputeClass implements Compute{
// 有两个属性，分别表示两个数，类型为 int
int a;
int b;
// 有参构造方法
public ComputeClass(int a,int b){
this.a = a;
this.b = b;
}
// 实现接口中的求和方法
public int sum() {
int s = a + b;
return s;
}
// 实现接口中的获取较大数的方法
public int max(int a, int b) {
int max;
if (a > b){
max = a;
}else {
max = b;
}
return max;
}
}
/********** End **********/
练习-Java异常处理之throw之学生总成绩
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：创建ExcTest类
import java.util.Scanner;
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异常处理之RuntimeException之避免异常抛出
/*
任务：接收给定的两个整数（第一个为被除数，第二个为除数），实现以下需求：
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分支结构
第1关：Java分支结构之多重if
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******/
}
}
第2关：Java分支结构之Switch
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*****/
}
}
实训3 Java 主方法中的循环结构
学习-Java循环while之求非负数之和
/*
任务：使用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次
while(i<=4){
// 第二步：获取输入值
int a = input.nextInt();
// 第三步：判断输入值是否大于0，对大于0的值累加
if(a>0) sum+=a;
// 第四步：while循环中的变量加1
i++;
// 第五步：打印sum值
}
System.out.print(" "+sum);
/********** End **********/
}
}
练习-Java循环while之等差数列均值
/*
任务：接收输入值（整数数列），统计出等差数列的均值，每组输入以%结束，比如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对象接收的值，当下一个值等于%时，终止循环
while(!input.hasNext("%")) {
// 第二步：获取输入值
int a = input.nextInt();
// 第三步：对输入的数列值求和
sum += (int)a;
// 第四步：统计数列个数
z++;
}
// 第五步：数列中值的总和，除以数列个数求出均值（保留两位小数）
double b=(double)sum/z;
System.out.println(String.format("%.2f",b));
/********** End **********/
}
}
学习-Java循环do…while之前n个自然数平均值
/*
任务：通过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
int j = 1;
n = input.nextInt();
do{
sum+=i;
i++;
j++;
}
// 在while后判断条件，当i不小于n时退出循环
while(i<n);
double ever = (double)sum / (j-1);
// 输出平均值，保留两位小数
System.out.print(String.format("%.2f",ever));
/********** End **********/
}
}
练习-Java循环do…while之正负数数量统计
/*
任务：统计给定一列数的正数和负数个数
给定的数举例：-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 b = input.nextInt();
// 第二步：判断输入值是否为正数，如果是，把正数个数变量positive加1
if (b > 0) {
positive++;
}
// 第三步：判断输入值是否为负数，如果是，把负数个数变量negative加1
else if (b < 0) {
negative++;
}
// 第四步：在while后判断条件，当输入值的下一个值为%时，终止循环
if (input.hasNext("%")) {
break;
}
/********** End **********/
} while (input.hasNext());
// 第五步：输出正数和复数个数，具体格式见预期输出
System.out.print("正数个数为：" + positive + "。负数个数为：" + negative);
}
}
学习-Java循环for之求水仙花数
/*
* 任务：使用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;
// 第五步：判断个位数的三次幂，十位数的三次幂，百位数的三次幂的和是否等于这个数本身，等于的话，输出该数
int sum= ge*ge*ge + shi*shi*shi + bai*bai*bai ;
if(sum==i){
System.out.println(i+"是一个水仙花数。");
continue;
}
}
/********** End **********/
}
}
练习-Java循环for之求完数
/*
任务：接收一个整数，判断该数是否是完数。
完数的定义：一个数如果恰好等于它的因子之和（本身除外），这个数就称为完数。
例如数字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循环之嵌套循环之比赛名单判断
/*
任务：求出对战人信息。
输出样式：a的对手x
*/
public class TeamMate {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：使用循环求出与c的对战的人
for (char a = 'x'; a <= 'z'; a++) {
// 第二步：使用循环求出与a的对战的人
for (char b = 'x'; b <= 'z'; b++) {
if (a == b) continue;
// 第三步：使用循环求出与b对战的人
for (char c = 'x'; c <= 'z'; c++) {
if (a == c || c == b) continue;
// 第三步：打印对战信息
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循环综合练习一之住房贷款还款计算
/*
任务：编写一个程序，由用户输入住房贷款和贷款年限，程序输出不同利率下的月还款额和总还款额，利率从 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循环综合练习三之杨辉三角形
/*
* 任务：从控制台获取输入的正整数n，打印带有n行的杨辉三角形
* 每个数字保证最少5个宽度，每行前面保证2n个宽度
杨辉三角形的特点：
- 第 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
*/
// 请在Begin-End间编写代码
/********** Begin **********/
// 导入 Scanner 类
import java.util.Scanner;
// 定义公开类 Test
public class Test {
// 定义主方法 main，在该方法中完成本关任务
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循环综合练习四之日历打印
/*
接收一个年份数（大于等于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 sc = new Scanner(System.in);
int year = sc.nextInt();
int month = sc.nextInt(); //接受年月
int sum = 0; //计算1900-1-1到目标年月之前的总天数
int day_max = 0; //用于计算每个月的天数
if(year<1900){ //判断输入年数是否符合要求
System.out.print("请输入大于或等于1900的年份");
}else if(month < 1||month >12){ //判断输入月份是否符合要求
System.out.print("请输入正确的月份");
}else{ //这个else不能掉！
for(int i = 1900; i < year; i++){ //1900-year之间的天数
if(i%400==0||(i%100!=0&&i%4==0)){ //判断是否为闰年
sum += 366; //闰年366天 非闰年365天
}else{
sum += 365;
}
}
for(int j = 1; j<=month ; j++){ //求出每个月的天数
switch(j){
case 4:
case 6:
case 9:
case 11:
day_max = 30;
break;
case 2:
if(year%400==0||(year%100!=0&&year%4==0)){
day_max = 29;
}else{
day_max = 28;
}
break;
default :
day_max = 31;
}
if(j < month){ //将month之前的所有月份的天数加到sum中
sum+=day_max;
}
}
int count = (sum + 1) % 7; //求星期数 或则写成：int count = sum%7 +1;
// count = count - 1;
System.out.println("==================================================");
//打印格式
System.out.println("日\t一\t二\t三\t四\t五\t六");
int day = 1; //用来打印日历中的天数，同时作为判断是否推出循环的条件！
for(int i = 0; i < 5; i++){ //五行
for(int j = 0; j < 7; j++){ //七列
if(i==0&&j<count){
System.out.print("\t");
continue; //确保打印完所有\t后再打印day
}
if(day > day_max){ //退出循环的条件
break;
}
System.out.print(day+"\t");
day++;
}
System.out.println(); // 完成一行打印后换行！
}
System.out.print("==================================================");
}
}
}
/********** End **********/
练习-Java循环综合练习二之哥德巴赫猜想
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 **********/
}
}
实训5 Java 数组
练习-Java数组之Arrays类操作数组之数组排序
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类操作数组之填充替换数组元素
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数组之foreach遍历数组之正负数数量统计
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数组之二维字符数组之按字母序排序
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数组之二维数值数组之矩阵乘
// 请在Begin-End间编写完整代码，类名请使用Transpose
public class Transpose {
public static void main(String[] args) {
/********** Begin **********/
// 定义二维数组并初始化
int[][] arr = {{5, 6, 7}, {15, 65, 43}, {32, 43, 22}, {11, 88, 6}, {4, 98, 66}};
int[][] arr1 = {{94, 65, 31,87,21}, {48,2,0, 71, 98}, {38,29,66, 88, 100}};
// 定义新数组
int [][] newarr=new int[arr.length][arr1[0].length];
// 计算两个数组的乘积
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr1[0].length;j++){
for(int k=0;k<arr[0].length;k++){
newarr[i][j] =newarr[i][j] + arr[i][k] * arr1[k][j];
}
}
}
// 打印求积后的新数组
for (int x = 0; x < newarr.length; x++) {
for (int z = 0; z < newarr[x].length; z++) {
System.out.print(newarr[x][z] + " ");
}
System.out.println();
}
/********** End **********/
}
}
学习-Java数组之二维数值数组之多科成绩统计
/*
* 任务：统计每人的总分。
* 输出样式：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}};
// 请在 Begin-End 间编写代码
/********** Begin **********/
// 第一步：对每个人的各科成绩求和
int x,y;
for( x=0;x<arr.length;x++){
int sum=0;
for(y=0;y<arr[x].length;y++){
sum+=arr[x][y];
}
// 第二步：输出每个人的总分数
System.out.println(x+1+"号学生的总分："+sum);
}
/********** End **********/
}
}
练习-Java数组之一维字符数组之凯撒密码
import java.util.Arrays;
import java.util.Scanner;
public class PassWord {
public static void main(String[] args) {
// 请在Begin-End间编写完整代码
/********** 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数组之一维字符数组之大小写转换
/*
任务：创建一维字符数组并赋值（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[] c = new char[]{'a','B','A','Z','v','b'};
// 第二步：遍历数组元素，如果为小写，请转化为大写，如果为大写，请转化为小写。大小写的ASCII码相差32。
for (int i = 0; i < 6; i++){
if (c[i] > 96 && c[i] < 123){
c[i] = (char)(c[i] - 32);
}else{
c[i] = (char)(c[i] + 32);
}
}
// 第三步：输出数组元素
System.out.print("转化后的数组：[");
for (int i = 0; i < c.length; i++){
System.out.print(c[i]);
if(i < c.length - 1)
System.out.print(", ");
else if(i < c.length)
System.out.print("]");
}
/********** End **********/
}}
学习-Java数组之一维数值数组之查找Key值
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数组之一维数值数组之排序
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数组之一维数值数组之随机数统计
import java.util.Random;
import java.util.Scanner;
public class RandomTest {
public static void main(String[] args) {
// 接收给定数据
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数组之一维数值数组之数据去重
import java.util.Scanner;
public class ArrTest {
public static void main(String[] args) {
// 接收给定的数据
int y = 0;
Scanner scanner = new Scanner(System.in);
int z = scanner.nextInt();
int[] arr = new int[z];
while (!scanner.hasNext("#")) {
int x = scanner.nextInt();
arr[y] = x;
y++;
}
// 通过临时数组对原数组去重，最后将临时数组赋值给原数组
int[] tmp = new int[arr.length];
int m = 0;
for (int i = 0; i < arr.length; i++) {
boolean flag = true;
for (int n = 0; n < tmp.length; n++) {
if (tmp[n] == arr[i]) {
flag = false;
}
}
if (flag) {
tmp[m++] = arr[i];
}
}
int[] newArr = new int[m];
for (int k = 0; k < m; k++) {
newArr[k] = tmp[k];
}
arr = newArr;
// 打印去重后的数组值
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
学习-Java数组之一维数值数组之成绩统计
/*
任务：仔细阅读给出的代码框架及注释，在 Begin-End 间编写程序代码，求班级数学平均成绩，具体要求如下：
- 接收给定的数据（如：4，88，43，43，98，#...，其中第一个数代表数组长度，
其余数代表班级所有人数学成绩，# 号用于终止接收数据），遇到 # 号终止接收；
- 求班级数学平均成绩，平均成绩用 double 类型表示。
注意：数字分隔符为中文逗号。
*/
import java.util.Scanner;
public class ArrTest {
public static void main(String[] args) {
// 第一步：接收给定的第一个数，用于定义数组长度
Scanner input = new Scanner(System.in);
int n = input.nextInt();
// 第二步：定义数组
int[] array = new int[n];
int i =0;
// 第三步：把成绩赋值给数组元素
while(!input.hasNext("#")){
array[i] = input.nextInt();
i ++;
}
// 第四步：求所有成绩的和
int sum = 0;
for(int j = 0;j < n;j ++){
sum += array[j];
}
// 第五步：求平均成绩
double average = sum * 1.0 / n;
System.out.print("数学平均成绩为：" + average);
/********** End **********/
}
}
实训6 Java 字符串
学习-Java字符串之String类创建字符串之使用equals和==判断字符串是否相等
/*
任务：
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和==判断字符串是否相等
/*
任务：
1.使用字符串常量引用赋值创建以下两个字符串
字符串1：World
字符串2：world
2.使用equals和==比较这两个字符串是否相等
3.输出比较结果
*/
public class StrTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：使用字符串常量引用赋值创建给定的两个字符串
String str1 = "World";
String str2 = "world";
// 第二步：分别使用==和equals比较创建的两个字符串是否相等，并输出比较结果
System.out.println("使用==比较的结果：" + (str1 == str2)); // 使用==比较的结果：false
System.out.println("使用equals比较的结果：" + str1.equals(str2));
/********** End **********/
}
}
练习- Java字符串之String类创建字符串之字符数组创建字符串
/*
任务：
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类并置运算之字符串拼接
import java.util.Random;
import java.util.Scanner;
public class StrTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：接收给定的两个字符串，第一个为名字，第二个为姓氏
Scanner sc = new Scanner(System.in);
// 第二步：拼接姓氏和名字
String fname = sc.next();
String lname = sc.next();
// 第三步：输出姓名
System.out.print(lname.concat(fname)); //concat方法
/********** End **********/
}
}
练习-Java字符串之String类并置运算之字符串拼接
/*
任务：接收给定的加速度（第一个数）和时间（第二个数），计算该时间所处的距离。
具体输出样式见预期输出。
*/
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 v0 = 8.0; // 初速度
double x = v0 * t + 0.5 * a * Math.pow(t, 2);
System.out.printf("当时间为%d，加速度为%d时，距离为%.1f", t, a, x);
/********** End **********/
}
}
学习-Java字符串之String类常用方法之字符串长度
/*
任务：接收输入值（字符串），将该字符串反转输出，例如接收字符串"abc"，输出"cba"。
*/
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.next();
// 第二步：将字符串转化为字符数组
char[] chars = str.toCharArray(); //将字符串转换为字符数组
// 第三步：逆序输出字符数组
for (int i = (str.length()) - 1; i >= 0; i--){ // 根据字符串长度判断i的范围
System.out.print(chars[i]); //逆向打印字符数组
}
/********** End **********/
}
}
练习-Java字符串之String类常用方法之满足条件的子字符串
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();
// 第二步：对字符串做指定操作操作
String str2[] = str.split(","); //转换为字符串数组，
int count = 0;
for (int i = 0; i < str2.length; i++){
str2[i] = str2[i].replace(" ",""); //replace方法，把所有空格转换为空字符
if(str2[i].startsWith("a") && str2[i].endsWith("z") && str2[i].contains("li")){
count ++;
System.out.println("将符合条件的子字符串转化为小写：" + str2[i].toLowerCase() );
System.out.println("将符合条件的子字符串转化为大写：" + str2[i].toUpperCase());
}
}
if(count == 0){
System.out.print(str + "该字符串没有符合条件的子字符串");
}else{
System.out.println("字符串中共有符合条件的子字符串" + count + "个");
}
/********** End **********/
}
}
学习-Java字符串之String类格式化字符串之多类型数据的格式化输出
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类格式化字符串之日期时间格式化输出
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.Scanner;
import java.text.ParseException;
public class StrTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：接收给定的日期时间字符串
Scanner sc = new Scanner(System.in);
String str = sc.nextLine(); //输入字符串
// 第二步：创建SimpleDateFormat对象将输入的字符串转换为Date对象
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);
// 第五步：格式化输出给定日期和时间字符串的24小时制的小时
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);
/********** End **********/
}
}
练习-Java字符串之String类格式化字符串之温度转化
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字符串之字符串、字符数组与字节数组间的使用之单词重新排序
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 word = scanner.nextLine();
// 对单词重新排序（按照单词中的字母升序排序）
char[] chars = word.toCharArray();
Arrays.sort(chars);
String sortedWord = new String(chars);
// 输出新单词
System.out.println(sortedWord);
scanner.close();
}
}
练习-Java字符串之字符串、字符数组与字节数组间的使用之统计单词中各字母的ASCII码值的和
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 **********/
}
}
实训7 Java 类和对象
学习-Java类和对象之类的声明之学生类的定义
/**
* 任务：定义一个 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类和对象之类的声明之复数运算
/**
* 任务：求两个复数相加后的结果。
*/
// 请在下面的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类和对象之构造方法与对象创建之求椭圆面积
/**
* 任务：已知椭圆的短半轴长为20.00，长半轴的长为15.50，计算椭圆面积。
* 类名为：EllipseArea
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 创建一个名为 EllipseArea 的公开类
public class EllipseArea{
// 定义椭圆的两个属性 ：短半轴长和长半轴长
double shor,lon;
// 定义一个显示有参构造方法，携带两个参数，分别表示为传来的短半轴的值和长半轴传来的值
EllipseArea(double x,double y){
shor=x;
lon=y;
// 该方法实现将短半轴长和长半轴长分别初始化为携带的两个参数的值。
}
// 定义一个方法，该方法实现计算椭圆的面积，并将其返回，返回值类型为double
double area(){
return shor*lon*3.1415926;
}
// 定义主方法
public static void main(String args[]){
// 在主方法中通过有参构造方法实例化一个对象，将椭圆的短半轴的值和长半轴的值传入其中
EllipseArea x=new EllipseArea(15.50,20.00);
System.out.printf("椭圆形的面积为%.2f",x.area());
}
// 调用计算椭圆的面积的方法，计算该椭圆的面积
}
// 将计算后的结果四舍五入保留两位小数后输出，输出格式为：椭圆形的面积为xx
/********** End **********/
练习- Java类和对象之构造方法与对象创建之计算数学中的分数值
/**
* 任务：跟据键盘输入的分子和分母求出该分数的值。其中第一次输入的值为分子的值，第二次输入的值为分母的值，两次的值均为 int 型。
* 类名为：Fraction
*/
import java.util.Scanner;
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 创建一个名为 Fraction 的公开类
public class Fraction{
// 定义分数的两个属性 ：分子和分母
int num;
int den;
/**
* 定义一个方法，该方法实现计算该分数的值，携带两个参数，分别为传来的分子和分母的值
* 如果分母为0，不换行输出：分母不能为0
* 如果分母不为0，将该分数的值四舍五入保留两位小数后输出
* 输出格式为：该分数的值为xx
*/
public void count(int num,int den){
double s=num*1.0/den;
if(den==0){
System.out.print("分母不能为0");
}else{
System.out.println("该分数的值为"+String.format("%.2f",s));
}
}
// 定义主方法
public static void main(String[]args){
// 获取键盘传来的分子和分母的值
Scanner input=new Scanner(System.in);
int num=input.nextInt();
int den=input.nextInt();
// 在主方法中通过 Java 添加的无参构造方法定义一个对象
Fraction fraction=new Fraction();
// 调用计算分数值的方法，将获取到的分子和分母分别传入该方法中
fraction.count(num,den);
}
}
/********** End **********/
练习-Java类和对象之构造方法与对象创建之比较大小
/**
* 任务：比较键盘输入的两个 double 型的数值的大小，输出较大的值。
* 类名为：Compare
*/
import java.util.Scanner;
// 创建一个名为 Compare 的公开类
public class Compare {
// 分别定义两个数
double num1;
double num2;
/**
* 定义一个方法，该方法实现比较两数大小，携带两个参数，分别为传来的两个数的值
* 将两个数中较大的那个数返回，返回类型为 double
*/
public double compareNumbers(double num1, double num2) {
if (num1 > num2) {
return num1;
} else {
return num2;
}
}
// 定义主方法
public static void main(String[] args) {
// 获取键盘传来的两个数
Scanner scanner = new Scanner(System.in);
double num1 = scanner.nextDouble();
double num2 = scanner.nextDouble();
// 在主方法中通过无参构造方法定义一个对象
Compare compare = new Compare();
// 调用比较大小的方法，获得较大的那个数
double result = compare.compareNumbers(num1, num2);
// 不换行输出较大的那个数
System.out.print(result);
}
}
学习-Java类和对象之static关键字之求圆环面积和周长
/**
* 任务：已知圆环的大圆半径 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关键字之检验三边是否构成三角形
/**
* 任务：根据键盘输入的三个 double 型的数字判断其是否能构成三角形。
* 类名为：Triangle
*/
import java.util.Scanner;
public class Triangle {
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
/**
* 定义一个静态方法，该方法检验三边是否能构成三角形，携带三个参数，分别为传来的三个参数，无返回值
* 如果能构成，不换行输出：这三条边可以构成三角形
* 如果不能，不换行输出：这三条边不能构成三角形
*/
static void jianyan(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 in = new Scanner(System.in);
double a = in.nextDouble();
double b = in.nextDouble();
double c = in.nextDouble();
Triangle.jianyan(a, b, c);
}
// 通过类名.方法名的方式调用检验三边是否能构成三角形的方法，分别将键盘输入的三个数传入该方法中
/********** End **********/
}
学习-Java类和对象之参数传值机制之求球面积
/**
* 任务：已知一个球的半径为 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类和对象之可变参数
/**
* 定义输出考试学生的人数及姓名的方法，方法名为 print，传参的类型为String，无返回值。
*/
public class Student {
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
public static void main(String[] args){
Student student =new Student();
// System.out.println("本次参加考试的人有3人，名单如下：");
student.print("张强","李成","王勇");
//System.out.println("本次参加考试的人有2人，名单如下：");
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类和对象之可变参数
/**
* 定义一个名为 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类和对象之参数传值机制之求球体积
/**
* 任务：已知一个球的半径为 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类和对象之对象组合之求圆柱体积
/**
* 任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 定义一个圆类，类名为 Circle
class Circle {
// 定义两个量，分别为半径和π值
double r;
double pi = Math.PI;
// 有参构造器
Circle(double r1) {
r = r1;
}
// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
double area() {
return r * r * pi;
}
}
// 定义一个公开的圆柱类 Cylinder
public class Cylinder {
// 定义圆柱中的高
double h;
// 引用圆类
Circle circle;
// 有参构造
Cylinder(double height) {
h = height;
}
/**
* 定义一个方法，该方法实现计算圆柱的体积，返回值为double
*/
double tiji(double area) {
return area * h;
}
// 定义主方法
public static void main(String[] args) {
// 通过有参构造创建圆对象，将底面半径设置为 20
Circle c1 = new Circle(20);
// 通过有参构造创建圆柱对象，将圆柱的高设置为 50，将圆对象传入
Cylinder c2 = new Cylinder(50);
// 调用计算圆柱积的方法
double volume = c2.tiji(c1.area());
// 四舍五入格式化不换行输出圆柱的体积，输出格式：圆柱的体积为xx
System.out.printf("圆柱的体积为%.2f", volume);
}
}
/********** End **********/
练习-Java类和对象之对象组合之求圆锥体表面积
/**
* 任务：已知圆锥的母线为 15，底面半径为 8，求圆锥的表面积。
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 定义一个圆类，类名为 Circle
class Circle{
// 定义两个量，分别为半径和π值
double r; //半径
static final double PI = Math.PI;
// 有参构造器
public Circle(double r){
this.r = r;
}
// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
double area(){
double a = PI * r * r;
return a;
}
}
// 定义一个扇形类，类名为 Sector
class Sector {
double l; //母线
double r; //半径
static final double PI = Math.PI;
// 有参构造器
public Sector(double l, double r) {
this.l = l;
this.r = r;
}
// 定义一个方法，实现求圆锥侧面积，将侧面积返回，返回类型为double，
double area() {
double s = PI * r * l;
return s;
}
}
// 定义一个公开的圆锥类 Cone
class Cone{
Circle circle;
Sector sector;
public Cone(Circle circle, Sector sector){
this.circle = circle;
this.sector = sector;
}
/**
* 定义一个方法，该方法实现计算圆锥的表面积，返回值为double
*/
double area(){
double s = circle.area() + sector.area();
return s;
}
// 定义主方法
public static void main(String[] args) {
// 通过有参构造创建圆对象，将底面半径设置为 8
Circle circle = new Circle(8);
// 通过有参构造创建扇形对象，将扇形所需的半径和母线传入
Sector sector = new Sector(15, 8);
// 通过有参构造创建圆锥对象，将圆对象和矩形对象传入
Cone cone = new Cone(circle, sector);
// 调用计算圆锥表面积的方法
double s = cone.area();
// 四舍五入格式化不换行输出圆锥表面积，输出格式：圆锥的表面积为xx
System.out.printf("圆锥的表面积为%.2f", s);
}
}
/********** End **********/
学习-Java类和对象之包的定义
com/pojo/Student.java文件
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.pojo 的包
package com.pojo;
public class Student {
public static String[] info(){
// 实现返回所有学生的功能，在该方法中定义一个 String 数组
String arry[]={"小明","小红","小强","小刚"};
return arry;
// 返回该数组
}
}
/********** End **********/
Test/Test.java文件
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.test 的包
// 导入 Student 类
package com.test;
import com.pojo.Student;
public class Test {
public static void main(String[] args) {
System.out.println("学生信息如下：");
//调用 Student 类的 info 方法，遍历数组
for(String names:Student.info()){
System.out.println(names);
}
}
}
/********** End **********/
练习-Java类和对象之包的定义
com/model/Movie.java
// 请在下面的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 **********/
com/test/Test.java
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.test 的包
package com.test;
// 导入 Movie 类
import com.model.Movie;
// 导入 java.util.Scanner 类
import java.util.Scanner;
// 定义一个公开的 Test 类
public class Test{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
Movie m = new Movie();
String a = scan.next();
String b = scan.next();
String c = scan.next();
String d = scan.next();
m.setName(a);
m.setLei(b);
m.setTime(c);
m.setArer(d);
m.say();
}
}
// 定义主方法
// 实例化 Movie 对象
// 将键盘四次输入的电影信息赋值给 Movie 对象
// 调用获取 Movie 信息的方法
/********** End **********/
学习-Java类和对象之this关键字
/**
* 任务：编写一个商品结算的小程序
* 类名为：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关键字
/**
* 任务：定义一个完整的学生类，该类定义了学生的基本信息。
* 类名为：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类和对象之访问限制
/**
* 任务：实现图书类，该类包含了图书的基本属性和信息。
* 类名为：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类和对象之访问限制
Movie.java
/**
* 任务：实现一个电影类
* 类名为：Movie
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
public class Movie {
// 定义6个变量
// 电影id（id int） 电影名称（movieName String） 电影类型（movieType String）
// 电影评分（double score） 电影时长（totalTime int） 电影简介（content String）
private int id;
private String movieName;
private String movieType;
private double score;
private int totalTime;
private String content;
public int getId()
{
return id;
}
public void setId(int id)
{
this.id=id;
}
public String getMovieName()
{
return movieName;
}
public void setMovieName(String movieName)
{
this.movieName=movieName;
}
public String getMovieType()
{
return movieType;
}
public void setMovieType(String movieType)
{
this.movieType=movieType;
}
public double getScore()
{
return score;
}
public void setScore(double score)
{
this.score=score;
}
public int getTotalTime()
{
return totalTime;
}
public void setTotalTime(int totalTime)
{
this.totalTime=totalTime;
}
public String getContent()
{
return content;
}
public void setContent(String content)
{
this.content=content;
}
// 定义设置和获取6个变量值的方法
}
/********** End **********/
学习-Java类和对象之对象数组
/**
* 任务：使用对象数组的方式创建 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类和对象之对象数组
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 **********/
}
}
实训8 Java 继承和多态
学习-Java继承和多态之final关键字
/**
* 调试代码，对代码进行增添、删除和修改等操作，使得程序能够正常运行，输出结果请参照预期输出结果。
*/
// 请在下面的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="+speedlimit);
}
}
class Bike2 {
// 输出 running
//final 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继承和多态之super关键字
/*
* 定义 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关键字
/*
* 根据要求补全 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继承和多态之方法重写
/**
* 重写 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继承和多态之方法重写
/**
* 任务：重写 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继承和多态之方法重载
/**
* 任务：定义名为 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继承和多态之方法重载
/**
* 任务：使用重载方法为 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继承和多态之成员变量隐藏
/**
* 任务：定义一个 NewWeight 的公开类，并继承 OldWeight 类，在该类中实现计算身高的标准体重。
*/
class OldWeight {
double height = 175;
public double getWeight(){
return height - 105;
}
}
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 定义一个NewWeight的公开类，并继承OldWeight类
public class NewWeight extends OldWeight
{
// 定义一个变量height，类型为double
double height;
// 定义一个有参构造方法，携带身高参数
public NewWeight(double height) {
this.height = height;
}
// 定义一个方法名为weight的方法，返回类型为double，计算现在的标准体重并返回
public double weight() {
return height - 105;
}
}
/********** End **********/
学习-Java继承和多态之成员变量隐藏之优惠促销价格计算
/**
* 任务：计算商品打折后的价格
*/
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继承和多态之子类对象特点
/**
* 任务：使用 instanceof 运算符判断所给对象是否为特定类的一个实例，并输出判断结果。
*/
public class Demo {
public static void main(String[] args){
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
Object hello = "Hello";
// 判断hello是否是Object类的实例
System.out.println(hello instanceof Object);
// 判断hello是否是String类的实例
System.out.println(hello instanceof String);
// 判断hello是否是Math类的实例
System.out.println(hello instanceof Math);
// 判断a是否是Object类的实例
String a = "hello";
System.out.println(a instanceof Object);
}
}
学习-Java继承和多态之子类对象特点
/**
* 任务：使用 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继承和多态之子类继承性
/**
* 任务：定义一个三角形 Triangle 类，继承 Shape 类，
* 在这个类中分别定义一个名为 area 的方法，实现计算该形状面积的功能。
* 类名为：Triangle
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 定义一个Triangle的公开类，并继承Shape类
public class Triangle extends Shape{
// 定义一个area方法，实现计算矩形面积的功能。
public double area(){
double s = 1.0 / 2 * getHeight() * getWidth();
return s;
}
}
/********** End **********/
学习-Java继承和多态之子类继承性
/**
* 任务：定义一个 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岁，它正在睡觉
/********** End **********/
练习-Java继承和多态之综合练习
/**
* 按照动物、宠物、猫和蜘蛛的关系，通过编程实现各自的关系并声明自己的属性和方法。
*/
// 请在下面的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继承和多态之abstract类
/**
* 通过图形类的计算面积的方法，计算矩形和三角形的面积。
*/
// 请在下面的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类
// 请在下面的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继承和多态之对象类型的转换
/**
* 判断梨类、苹果类和水果类的关系，并通过对象类型转换调用彼此的属性和方法。
*/
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 **********/
}
}
实训9 Java 异常处理
第1关：学习-Java异常处理之try-catch之异常捕获
import java.util.Scanner;
public class ExcTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：接收给定的整数
Scanner x=new Scanner(System.in);
int a=x.nextInt();
int b=x.nextInt();
// 第二步：求给定两个数的商，并捕获除数为0的异常
try{
int q=a/b;
System.out.print(q);
/********** End **********/
}
catch(Exception e)
{
System.out.print("除数不能为0");
}
}}
第1关：练习-Java异常处理之try-catch之异常捕获
/*
任务：接收给定的一行字符串，实现以下需求：
1.通过逗号(英文逗号)切割字符串，得到一个字符串数组；
2.输出数组中第五个元素；
3.捕获数组越界异常，输出“数组长度小于5”。
字符串样式：hello,32,java,hao,tian
切割后的字符串数组长度不一定大于等于5，当我们输出数组中第五个元素时，会生成一个叫做数组越界的异常。
*/
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：创建ExcTest类
import java.util.Scanner;
public class ExcTest{
public static void main(String[] args){
Scanner input =new Scanner(System.in);
String string =input.nextLine();
String[] str=string.split(",");
try{
System.out.println(str[4]);
} catch (Exception e){
System.out.println("数组长度小于5");
}
}
}
// 第二步：接收给定的字符串
// 第三步：切割字符串，得到一个数组
// 第四步：输出数组中第五个元素，并捕获异常
/********** End **********/
第1关：学习-Java异常处理之finally语句之求两个数的和
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();
int x;
// 第二步：求给定两个数的商，并捕获除数不为 0 的异常
try{
x = a / b;
System.out.println(x);
}catch (Exception e){
System.out.println("除数不能为0");
}
// 第三步：不管是否捕获到异常，都输出给定两个数的和
finally {
System.out.println(a + b);
}
/********** End **********/
}
}
第1关：练习-Java异常处理之finally语句之输出所有元素
import java.util.Scanner;
public class ExcTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 切割给定的一行字符串，得到一个字符串数组，
// 将数组中每个元素转化为int类型，使用 finally 输出所有元素，并捕获数据类型转换异常
Scanner scanner = new Scanner(System.in); // 接收给定的字符串
String s = scanner.nextLine();
String[] split = s.split("-"); // 切割字符串，得到一个数组
for(String str:split) { // 将数组中所有元素转化为int类型，并捕获异常
try {
int x = Integer.parseInt(str);
} catch (Exception e) {
System.out.println(String.format("元素%s不能转换为int类型", str));
}
finally { // 使用finally输出所有元素
System.out.println("元素"+str);
}
}
/********** End **********/
}
}
第1关：学习-Java异常处理之常见异常类之数据格式转换异常
import java.util.Scanner;
public class ExcTest {
public static void main(String[] args) {
// 请在Begin-End间编写代码
/********** Begin **********/
// 定义变量
double sum = 0;
// 接收给定的字符串
Scanner input = new Scanner(System.in);
String str = input.next();
// 切割字符串，得到一个数组
String[] array = str.split("#");
// 将数组中所有元素转化为double类型，并输出所有double类型的和以及捕获异常
for (int i = 0;i < array.length;i ++){
try{
double d = Double.parseDouble(array[i]);
sum += d;
}catch (Exception e){
System.out.println("元素" + array[i] + "不能转换为double类型");
}
}
System.out.println("转换后的所有double类型数据的和为：" + sum);
/********** End **********/
}
}
第1关：练习-Java异常处理之常见异常类之输入类型异常
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);
double x = scanner.nextDouble();
double y = scanner.nextDouble();
// 打印接收两个值的加减乘结果（输入的第一个数当被减数，第二个数当减数，保留两位小数）
System.out.println(String.format("%.2f", x+y));
System.out.println(String.format("%.2f", x-y));
System.out.println(String.format("%.2f", x*y));
/********** End **********/
}
}
第1关：学习-Java异常处理之自定义异常之判断用户名
import java.util.Scanner;
public class ExcTest {
public static void main(String[] args) throws MyException {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：接收给定的字符串
Scanner input = new Scanner(System.in);
String str = input.next();
// 第二步：判断用户名长度是大于3还是小于3，如果小于3，抛出异常，否则输出提示语句
if (str.length() < 3){
throw new MyException("用户名小于三位Exception");
}else {
System.out.println("用户名格式正确");
}
}
}
// 第三步：自定义异常
class MyException extends Exception{
public MyException(){
}
public MyException(String name){
super(name);
}
}
/********** End **********/
第1关：学习-Java异常处理之throws之抛出并捕获异常
import java.util.Scanner;
public class Exc1Test {
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：创建任意方法并抛出异常
public static void Exc() throws ArithmeticException{
// 第二步：接收给定的两个字符串
Scanner scanner = new Scanner(System.in);
String next = scanner.next();
String next1 = scanner.next();
// 第三步：把第二个字符串的长度减1，得到一个整数值
int i = next1.length() - 1;
// 第四步：输出第一个字符串长度是整数值的多少倍
System.out.print( next.length() / i);
}
public static void main(String[] args) {
// 第五步：调用创建的方法，并捕获异常，输出"除数不能为0"
try{
Exc();
}
catch (ArithmeticException e){
System.out.print("除数不能为0");
}
}
/********** End **********/
}
第1关：练习-Java异常处理之自定义异常之质数
// 请在Begin-End间编写代码
/********** Begin **********/
import java.util.Scanner;
// 第一步：自定义异常，异常名为MyException
class MyException extends Exception{
public MyException (String string){
super (string);
}
}
// 第二步：创建ExcTest类
public class ExcTest{
// 第三步：接收给定的整数
public static void main(String[] args) throws Exception{
Scanner input =new Scanner (System.in);
int n=input.nextInt();
if(n==2){
System.out.print(n);
System.exit(0);
}
// 第四步：判断所给的整数是否为质数，如果不是，抛出自定义的异常
for (int i=2;i<n;i++){
if(n%i==0){
throw new MyException("非质数异常");
}
else System.out.print(n);
}
}
// 第五步：如果所给数是质数，请输出该数
}
/********** End **********/
第1关：练习-Java异常处理之throws之抛出并捕获异常
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：创建ExcTest类
import java.util.Scanner;
public class ExcTest {
// 第二步：创建任意方法并抛出数组越界异常
public static void ArrIndex()throws ArrayIndexOutOfBoundsException{
// 第三步：接收给定的一行字符串
Scanner scanner = new Scanner(System.in);
String s = scanner.nextLine();
// 第四步：切割字符串，得到一个数组
String[] split = s.split(",");
// 第五步：输出数组中第五个元素
System.out.print(split[4]);
}
public static void main(String[] args) {
// 第六步：调用创建的方法，捕获异常，输出数组长度小于5
try{ ArrIndex();}
catch (ArrayIndexOutOfBoundsException e){
System.out.print("数组长度小于5");
}
}
}
/********** End **********/
第1关：学习-Java异常处理之throw之酒店入住
import java.util.Scanner;
public class ExcTest {
public static void main(String[] args) throws Exception{
// 请在Begin-End间编写代码
/********** Begin **********/
// 第一步：接收给定的年龄
Scanner input = new Scanner(System.in);
int age = input.nextInt();
// 第二步：判断用户年龄，小于18或者大于90时，抛出异常
if (age < 18 | age >90){
throw new Exception("18岁以下，90岁以上的住客必须由亲友陪同");
}
// 第三步：当年龄介于18到90之间时，输出指定提示语
if (age >= 18 & age <= 90){
System.out.println("欢迎入住本酒店");
}
/********** End **********/
}
}
第1关：练习-Java异常处理之RuntimeException之避免抛出
public class ExcTest {
int a=1;
public static void main(String[] args) {
ExcTest t1 = new ExcTest();
ExcTest t2 = null;
// 请在Begin-End间编写代码
/********** Begin **********/
// 请在此添加或者修改代码
try{
System.out.println(t2.a);
System.out.println(t2.funC());
} catch (Exception e){
System.out.println("对象不能为空");
}
/********** End **********/
}
public String funC(){
return "123";
}
}
实训10 Java 输入输出
学习-Java输入输出之InputStream类之字节数据输入处理
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
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();
// 创建字节输入流对象
InputStream inputStream = new FileInputStream(str);
int n;
// 读取文件，并将内容转换为字符输出
while ((n = inputStream.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 **********/
}
}
第1关：练习-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 **********/
// 定义变量
Scanner input = new Scanner(System.in);
// 接收给定字符串
String str= input.next();
// 创建Reader对象
Reader reader = new FileReader(str);
// 打印字符
for(;;){
int n = reader.read();
if(n==-1){
break;
}
System.out.print((char)n);
}
// 读取并打印数据
try{
reader.close();
}catch(Exception e){
}
/********** End **********/
}
}
学习-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 str = input.nextLine();
// 切割字符串
String[] array = str.split("，");
// 创建FileWriter对象
FileWriter fileWriter = new FileWriter(array[0]);
// 向文件中写入字符流
fileWriter.write(array[1]);
fileWriter.close();
/********** End **********/
}
}
第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输入输出之File类之获取文件信息
import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
public class FileTest {
public static void main(String[] args){
// 请在Begin-End间编写完整代码
/********** Begin **********/
// 接收给定字符串（目录）
Scanner scanner=new Scanner(System.in);
String input=scanner.next();
// 遍历目录，输出最小文件和最大文件名以及它们的大小
File f = new File(input);
File[] fis = f.listFiles();
if(null==fis)
return;
long minSize = Integer.MAX_VALUE;//定义最大用于比较
long maxSize = 0;
File minFile = null;
File maxFile = null;
for (File file : fis) {
//判断是否是文件夹
if(file.isDirectory())
continue;
if(file.length()>maxSize){
maxSize = file.length();
maxFile = file;
}
if(file.length()!=0 && file.length()<minSize){
minSize = file.length();
minFile = file;
}
}
String maxf=maxFile.getName();
String minf=minFile.getName();
maxf.replace("/test/","");
System.out.printf("最大的文件是%s，其大小是%,d字节%n",maxf,maxFile.length());
System.out.printf("最小的文件是%s，其大小是%,d字节%n",minf,minFile.length());
}
}
第1关：学习-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-End间编写完整代码
/********** Begin **********/
// 接收给定的字符串
Scanner sc = new Scanner(System.in);
File f0= new File(sc.next());
// 当给定文件大小等于0时，抛出异常
if(f0.length()==0)
throw new RuntimeException("文件大小为0，不可拆分");
FileInputStream fis = new FileInputStream(f0);
// 把文件所有数据读取到数组中
byte[] bytes = new byte[1024*1024];
fis.read(bytes);
// 计算需要被划分成多少个子文件
// 加上for循环后是将本文件所在目录大于100k的文件都拆分
// File fp = new File(f1.getParent());
// File[] files =fp.listFiles();
// for(File f0:files){
int N=(int)f0.length();//获得指定的文件字节数
if(!(N<100)){//大于100字节
int i=0;
while(N>0){
//封装要创建的文件
File file0 = new File(f0.getPath()+"-"+i);
if(!file0.exists())//不存在就创建
file0.createNewFile();
//创建后就写入
FileOutputStream fos=new FileOutputStream(file0);
fos.write(bytes,0,102400);//写入100*1024个字节（拆分）
N-=102400;
i++;
fos.close();
}
}
// }
// 将读取到的数据写入到子文件中
// FileOutputStream fos= new FileOutputStream();
/********** End **********/
// File f3=new File("/test3/test2.docx");
// System.out.println(f3.length());
}
}
第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 {
// 请在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;
}
}
}
第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 **********/
}
}
练习-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 **********/
// 使用缓冲流读取给定文件，并返回读取时间
Long startTime = System.currentTimeMillis();
byte[] temp = new byte[8];
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(str)); int len=0;
while ((len = bis.read(temp)) != -1) {
bis.read(temp);
}
Long endTime = System.currentTimeMillis();
/********** End **********/
return endTime - startTime;
}
public Long inputStream() throws IOException{
// 请在Begin-End间编写完整代码
/********** Begin **********/
// 使用文件字节流读取给定文件，并返回读取时间
Long startTime = System.currentTimeMillis();
byte[] temp = new byte[8];
FileInputStream bis = new FileInputStream(str);
int len=0;
while ((len = bis.read(temp)) != -1) {
bis.read(temp);
}
Long endTime = System.currentTimeMillis();
return endTime - startTime;
/********** 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 **********/
// 定义变量
Scanner input = new Scanner(System.in);
// 接收给定字符串
String str= input.next();
// 创建Reader对象
Reader reader = new FileReader(str);
// 打印字符
for(;;){
int n = reader.read();
if(n==-1){
break;
}
System.out.print((char)n);
}
// 读取并打印数据
try{
reader.close();
}catch(Exception e){
}
/********** End **********/
}
}
实训11 多线程程序设计
JAVA程序设计进阶_1_创建线程
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***/
int i;
for (i = num; i > 0; --i)
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) {
this.num = num;
}
@Override
public void run() {
// 重写run方法，在子线程中执行阶乘计算
int result = 1; // result保存计算出的结果
// 计算阶乘
for (int i = 1; i <= num; i++) {
result *= i;
}
// 直接输出结果
System.out.println(result);
}
}
第3关：使用匿名Thread和Runnable对象创建线程
package step3;
public class ThreadHelper {
/**
* 在子线程中计算参数的阶乘并输出
* @param num
*/
static public void calcOnNewThread(int num) {
// 使用Thread匿名对象以及Runnable匿名对象创建并执行子线程
new Thread(new Runnable() {
@Override public void run() {
int result = 1;
// 计算阶乘
for (int i = 1; i <= num; i++) {
result *= i;
}
// 直接输出
System.out.println(result);
}
}).start();
}
/**
* 使用一个私有的构造器，防止该类被实例化
*/
private ThreadHelper() {
throw new UnsupportedOperationException(this.getClass().getSimpleName() + " can not be instantiated.");
}
}
第4关：Thread创建综合
Java多线程基础
第1关：创建线程
package step1;
//请在此添加实现代码
/********** Begin **********/
public class ThreadClassOne extends Thread{
public int i=0;
public ThreadClassOne(){
super();
}
public void run(){
for(i=0;i<10;i++){
if(i%2==1){
System.out.print(i+" ");
}
}
}
}
class ThreadClassTwo implements Runnable {
private Thread t;
public void run() {
for (int i = 0; i <= 10; i++) {
if (i % 2 == 0) {
System.out.print(i + " ");
}
}
}
public void start() {
if (t == null) {
t = new Thread(this, "");
t.start();
}
}
}
/********** End **********/
Java网络编程
第1关：InetAddress类
package step1;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class InetAddressExample {
public static void main(String[] args) throws UnknownHostException {
// ---------------------Begin------------------------
// 获取本机名
String localHostName = InetAddress.getLocalHost().getHostName();
System.out.println("本机名：" + localHostName);
// 获取本机IP地址
String localHostIP = InetAddress.getLocalHost().getHostAddress();
System.out.println("本机IP地址：" + localHostIP);
// ---------------------End------------------------
}
}
第2关：URL编程获取网页内容
第3关：方法的重写与重载
package case4;
public class overridingTest {
public static void main(String[] args) {
/********* begin *********/
// 声明并实例化一Person对象p
Person p = new Person();
p.setName("张三");
p.setAge(18);
p.talk();
}
}
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.print("我是："+ name + "，今年：" + age + "岁，我在哈佛大学上学");
}
}
class Student extends Person {
/********* begin *********/
/********* end *********/
}
第4关：抽象类
package case5;
public class abstractTest {
public static void main(String[] args) {
/********* begin *********/
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
new Student("张三", 20, "学生").talk();
new Worker("李四", 30, "工人").talk();
// 分别调用各自类中被复写的talk()方法 打印信息。
/********* end *********/
}
}
abstract class Person {
/********* begin *********/
String name;
int age;
String occupation;
public Person(String name, int age, String occupation) {
super();
this.name = name;
this.age = age;
this.occupation = occupation;
}
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
public Student(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
//Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
public Worker(String name, int age, String occupation) {
super(name, age, occupation);
// TODO 自动生成的构造函数存根
}
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("工人——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
第5关：接口
package case7;
public class interfaceTest {
public static void main(String[] args) {
// 实例化一Student的对象s，并调用talk()方法，打印信息
/********* begin *********/
new Student().talk();
/********* end *********/
}
}
interface Person {
public static final String name = "张三";
public static final int age = 18;
public static final String occupation = "学生";
public abstract void talk();
/********* end *********/
}
//Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student implements Person {
@Override
public void talk() {
// TODO 自动生成的方法存根
System.out.println("学生——>姓名：" + name + "，年龄：" + age + "，职业：" + occupation+"！");
}
/********* begin *********/
/********* end *********/
}
第6关：什么是多态，怎么使用多态
package case8;
public class TestPolymorphism {
public static void main(String[] args) {
// 以多态方式分别实例化子类对象并调用eat()方法
/********* begin *********/
new Dog().eat();
new Cat().eat();
new Lion().eat();
/********* end *********/
}
}
class Animal {
/********* begin *********/
public void eat() {
System.out.println("eating");
}
/********* 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 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 ta = new MyThread("AA",b,a);
MyThread tb = new MyThread("BB",c,b);
MyThread tc = new MyThread("CC",a,c);
ta.start();
tb.start();
tc.start();
/********* End *********/
}
}
class MyThread extends Thread {
/********* Begin *********/
String threadName;
Object p;
Object s;
public MyThread(String threadName, Object p, Object s){
this.threadName = threadName;
this.p = p;
this.s = s;
}
public void run() {
int count = 5;
while(count > 0){
synchronized(p){
synchronized(s){
System.out.println("Java Thread" + this.threadName);
count--;
s.notify();
}
try{
p.wait();
}catch(Exception e){
}
}
}
System.exit(0);
}
/********* 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 input1 = input.next();
String output = input.next();
FileInputStream fis = new FileInputStream(input1);
FileOutputStream fos = new FileOutputStream(output);
int read = 0;
byte[] buff = new byte[8];
while((read = fis.read(buff)) != -1){
fos.write(buff,0,read);
}
fis.close();
fos.close();
/********** End **********/
}
}
第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******/
}
}
第2关：Java分支结构之Switch
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 12:
case 1:
case 2:
System.out.print(input + "月是冬天");
break;
case 3:
case 4:
case 5:
System.out.print(input + "月是春天");
break;
case 6:
case 7:
case 8:
System.out.print(input + "月是夏天");
break;
case 9:
case 10:
case 11:
System.out.print(input + "月是秋天");
break;
}
/*****end*****/
}
}
第1关：使用synchronized关键字同步线程
package step2;
public class Task {
public static void main(String[] args) {
final insertData insert = new insertData();
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
public void run() {
insert.insert(Thread.currentThread());
}
}).start();
}
}
}
class insertData{
public static int num =0;
/********* Begin *********/
public synchronized void insert(Thread thread){
for (int i = 0; i <= 5; i++) {
num++;
System.out.println(num);
}
}
/********* End *********/
}
第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(Exception 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.print("用户名格式正确");
}
}
}
class MyException extends Exception{
private static final long serialVersionUID = 1L;
public MyException(){
}
public MyException(String msg){
super(msg);
}
}
/********* End *********/
第1关：初识数组
package step1;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
int[] scores={91,88,60};
System.out.println("数组的第一个值为："+scores[0]); //在这里输出数组的第一个值
System.out.println("数组的第二个值为："+scores[1]); //在这里输出数组的第二个值
System.out.println("数组的第三个值为："+scores[2]); //在这里输出数组的第三个值
/********** End **********/
}
}
第4关：数组练习-平均值和最大值
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的平均值和最大值
int sum=0;
for(int i=0;i<scores.length;i++){
sum+=scores[i];
}
double temp=(double)sum/(double)scores.length;
int t=-1;
for(int i=0;i<scores.length;i++){
if(t<scores[i]){
t=scores[i];
}
}
System.out.println("平均值：" +temp );
System.out.println("最大值：" +t );
/********** End **********/
}
}
第5关：二维数组
package step4;
public class HelloWorld {
public static void main(String[] args) {
/********** Begin **********/
int[][]score={
{92,85},
{91,65},
{90,33}
};
for(int i=0;i<score.length;i++){
for(int j=0;j<score[i].length;j++){
System.out.println(score[i][j]);
}
}
for(int i=0;i<score.length;i++){
score[i][0]=1;
score[i][1]=2;
}
for(int i=0;i<score.length;i++){
for(int j=0;j<score[i].length;j++){
System.out.println(score[i][j]);
}
}
/********** End **********/
}
}
第1关：字符流 - 输入输出
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 *********/
FileReader read = new FileReader("src/step3/input/input.txt");
FileWriter writer = new FileWriter("src/step3/output/output.txt");
char[] buff = new char[1024];
int arr = 0;
while((arr = read.read(buff)) != -1){
writer.write(buff,0,arr);
}
read.close();
writer.close();
/********* End *********/
}
}
字符流输入输出
package step3;
import java.io.File;
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 *********/
File file1 = new File("src/step3/input/input.txt");
File file2 = new File("src/step3/output/output.txt");
FileReader fr = new FileReader(file1);
FileWriter fw = new FileWriter(file2);
char[] ch = new char[8];
fr.read(ch);
fw.write(ch);
fr.close();
fw.close();
/********* End *********/
}
}
顺序输出
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 ta = new MyThread("A",c,a);
MyThread tb = new MyThread("B",a,b);
MyThread tc = new MyThread("C",b,c);
ta.start();
ta.sleep(100);
tb.start();
tb.sleep(100);
tc.start();
tc.sleep(100);
/********* End *********/
}
}
class MyThread extends Thread {
/********* Begin *********/
private String threadName;
private Object prev;
private Object self;
public MyThread(String name,Object prev,Object self){
this.threadName = name;
this.prev = prev;
this.self = self;
}
public void run() {
int count = 5;
while(count>0){
synchronized(prev){
synchronized(self){
System.out.println("Java Thread"+this.threadName+this.threadName);
count--;
self.notify();
}
try {
prev.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.exit(0);
}
/********* End *********/
}
捕获异常
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(Exception e){
System.out.println("除数不能为0");}
/********* End *********/
}
}
构造方法
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 p=new Person();
Person p1=new Person(name,sex)
/********** End **********/
}
//创建Person对象，并创建两种构造方法
/********** Begin **********/
class Person{
String name1;
String sex1;
public Person()
{
System.out.println("一个人被创建了");
}
public Person(String name,String sex)
{ // this.name1=name;
//this.sex1=sex;
System.out.println("姓名："+ name +"，性别：" + sex +"，被创建了");
}
/********** End **********/
类与对象练习：
Test：
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方法
WuMingFen.check();
/********** End **********/
}
}
Wumingfen:
/********** Begin **********/
//在这里添加包名 step4
package step4;
//创建类 添加属性和方法
public class WuMingFen{
String theMa;
int quantity;
boolean likeSoup;
public WuMingFen(){
this.theMa = theMa;
this.quantity = quantity;
this.likeSoup = likeSoup
}
public WuMingFen(String name,int a,boolean b){
System.out.println("面码："+name+"，粉的份量："+a+"两，是否带汤："+b)
}
public WuMingFen(String name,int a){
System.out.println("面码："+name+"，粉的份量："+a+"两，是否带汤：false");
}
public static void check(){
System.out.println("面码：酸辣，粉的份量：2两，是否带汤：true");
}
}
String类的常用方法
package step1;
public class StringExample {
public static void main(String args[]) { /********* Begin *********/
String s1 = new String("you are a student"),
s2 = new String("how are you");
if (s1.equals(s2)) // 使用equals方法判断s1与s2是否相同
{
System.out.println("s1与s2相同");
} else {
System.out.println("s1与s2不相同");
}
String s3 = new String("22030219851022024");
if (s3.contains("220302")) // 判断s3的前缀是否是“220302”
{
System.out.println("吉林省的身份证");
}
String s4 = new String("你"), s5 = new String("我");
if (s4.compareTo(s5)>0)// 按着字典序s4大于s5的表达式
{
System.out.println("按字典序s4大于s5");
} else {
System.out.println("按字典序s4小于s5");
}
int position = 0;
String path = "c:\\java\\jsp\\A.java";
position = path.lastIndexOf("\\");// 获取path中最后出现\\的位置
System.out.println("c:\\java\\jsp\\A.java中最后出现\\的位置:" + position);
String fileName = path.substring(path.lastIndexOf("\\")+1);// 获取path中“A.java”子字符串
System.out.println("c:\\java\\jsp\\A.java中含有的文件名:" + fileName);
String s6 = new String("100"), s7 = new String("123.678");
int n1 = Integer.parseInt(s6); // 将s6转化成int型数据
double n2 = Double.parseDouble(s7); // 将s7转化成double型数据
double m = n1 + n2;
System.out.println(m);
String s8 = String.valueOf(m); // String调用valueOf(m)方法将m转化为字符串对象
position = s8.indexOf(".");
String temp = s8.substring(position+1); // 获取s8中小数点后面的小数
System.out.println("数字" + m + "有" + temp.length() + "位小数");
String s9 = new String("ABCDEF");
char a[] = s9.toCharArray(); // 将s9存放到数组a中
for (int i = a.length - 1; i >= 0; i--) {
System.out.print(" " + a[i]);
} /********* End *********/
}
}
矩阵转置
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();
}
System.out.println("行列互调后数组为：");
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
System.out.print(matrix[j][i]+" ");
}
System.out.println();
} /********** End **********/
scanner.close();
}
}
求平均分及各个区间段的人数
package step3;
import java.util.Scanner;
public class Score {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in); /********** Begin **********/
int A=0,B=0,C=0,D=0,E=0;
double sum=0;
double score=scanner.nextDouble();
while(score!=-1){
if(score<60){
E++;
}else if(score<70){
D++;
}else if(score<80){
C++;
}else if(score<90){
B++;
}else {
A++;
}
sum+=score;
score=scanner.nextDouble();}
int total=A+B+C+D+E;
double average=sum/total;
System.out.println("不及格的人数为："+E);
System.out.println("及格的人数为："+D);
System.out.println("中等的人数为："+C);
System.out.println("良好的人数为："+B);
System.out.println("优秀的人数为："+A);
System.out.println("全班平均分为："+String.format("%.1f",average));
/********** End **********/
scanner.close();
}
}
编写一个代表三角形的类
package step1;
import java.util.Scanner;
public class Triangle {
// 自行设计类的实现/********** Begin **********/
private double a;
private double b;
private double c;
public Triangle(double a,double b,double c){
this.a=a;
this.b=b;
this.c=c;
}
public double getA(){
return a;
}
public void setA(double a){
this.a=a;
}
public double getB(){
return b;
}
public void setB(double b){
this.b=b;
}
public double getC(){
return c;
}
public void setC(double c){
this.c=c;
}
public double getarea(){
double s=(a+b+c)/2;
double area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
return area;
}
public double getperi(){
return a+b+c;
}
public String toString(){
return "三角形(" + a + "," + b + "," + c + ")";
} /********** End **********/
public static void main(String[] args) {
/********** Begin **********/
Scanner sc = new Scanner(System.in);
double a,b,c; //定义三条边
a = sc.nextDouble();
b = sc.nextDouble();
c = sc.nextDouble();
Triangle t1 = new Triangle(a, b, c);
//输出面积
System.out.println(t1 + "的面积为:" + String.format("%.2f",t1.getarea()));
//输出周长
System.out.println(t1 + "的周长为:" + String.format("%.2f",t1.getperi()));
/********** End **********/
}
}
编写一个圆环类
package step2;
public class Ring { /********** Begin **********/
private double a;
private double b;
private String c;
public Ring(double a,double b,String c){
this.a=a;
this.b=b;
this.c=c;
}
public double getA(){
return a;
}
public void setInnerRadius(double a){
this.a=a;
}
public void setA(double a){
this.a=a;
}
public double getB(){
return b;
}
public void setOuterRadius(double b){
this.b=b;
}
public void setB(double b){
this.b=b;
}
public String getC(){
return c;
}
public void setColor(String c){
this.c=c;
}
public void setC(String c){
this.c=c;
}
public double getarea(){
return Math.PI*(b*b-a*a);
}
public double getperiw(){
return 2*Math.PI*b;
}
public double getperin(){
return 2*Math.PI*a;
} /********** End **********/
public static void main(String[] args) {
Ring ring = new Ring(5, 8, "red");
System.out.println("圆环的内半径: " + ring.getA());
System.out.println("圆环的外半径: " + ring.getB());
System.out.println("圆环的颜色: " + ring.getC());
System.out.println("圆环的面积: " + String.format("%.2f",ring.getarea()));
System.out.println("圆环的外圆周长: " + String.format("%.2f",ring.getperiw()));
System.out.println("圆环的内圆周长: " + String.format("%.2f",ring.getperin()));
System.out.println();
ring.setInnerRadius(4);
ring.setOuterRadius(6);
ring.setColor("blue");
System.out.println("圆环的内半径: " + ring.getA());
System.out.println("圆环的外半径: " + ring.getB());
System.out.println("圆环的颜色: " + ring.getC());
System.out.println("圆环的面积: " + String.format("%.2f",ring.getarea()));
System.out.println("圆环的外圆周长: " + String.format("%.2f",ring.getperiw()));
System.out.println("圆环的内圆周长: " + String.format("%.2f",ring.getperin()));
}
}
编写一个学生类
package step3;
public class Student { /********** Begin **********/
private int num;
private int age;
private String name;
public Student(int num,int age,String name){
this.num=num;
this.age=age;
this.name=name;
}
public int getNum(){
return num;
}
public void setNum(int num){
this.num=num;
}
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;
}
public String toString(){
return "学号:"+num+",姓名:"+name+",年龄:"+age;
} /********** End **********/
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("班级学生名单如下：");
output(s); // 第1次调用output方法输出数组
/********** Begin **********/
for(int i=0;i<s.length;i++){ // 将所有学生年龄加1
s[i].age=s[i].age+1;
} /********** End **********/
System.out.println("所有学生年龄加 1 后...");
output(s); /// 第2次调用output方法输出数组
int count = 0;
/********** Begin **********/
for(int i=0;i<s.length;i++){ //统计大于20岁的学生个数
if(s[i].age>20){
count++;
}
}
/********** End **********/
System.out.println("大于 20 岁人数是：" + count);
}
/* 以下方法输岀学生数组的所有元素 */
private static void output(Student s[]) {
for (int i = 0; i < s.length; i++)
System.out.println(s[i]);
}
}
类的继承
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;
}
public String toString(){ //重写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();
}
}
上转型对象的使用，多态的特性
package step2;
abstract class Employee {
public abstract double earnings();
}
class YearWorker extends Employee { //重写earnings()方法
/********** Begin **********/
public double earnings(){
return 100000;
}
/********** End **********/
}
class MonthWorker extends Employee { //重写earnings()方法
/********** Begin **********/
public double earnings(){
return 10000*12;
}
/********** End **********/
}
class WeekWorker extends Employee { //重写earnings()方法
/********** Begin **********/
public double earnings(){
return 5000*4*12;
}
/********** 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) {
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());
}
}
接口的使用
package step3;
/********** Begin **********/
// 定义接口
interface Display {
public void display();
}
// 通知类
class Inform implements Display {
public void display() { // 实现 display() 方法
System.out.println("通知内容");
}
}
// 汽车类
class Car implements Display {
public void display() { // 实现 display() 方法
System.out.println("汽车油量");
}
}
// 广告类
class Adervise implements Display {
public void display() { // 实现 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();
}
}
}
综合应用—学生信息管理系统
student：
package step4;
public class Student {
/********** Begin **********/
private String sno; // 学号
private String sname; // 姓名
private String sdept; // 系别
public String getSno() {
return sno;}
public void setSno(String sno) {
this.sno = sno;}
public String getSname() {
return sname;}
public void setSname(String sname) {
this.sname = sname;}
public String getSdept() {
return sdept;}
public void setSdept(String sdept) {
this.sdept = sdept;}
@Override
public String toString() {
return "学号: " + sno + " 姓名: " + sname + " 系部: " + sdept;}
/********** End **********/
}
IStudentDAO:
package step4;
public interface IStudentDAO {
/********** Begin **********/
void insertStudent(Student student);
void updateStudent(Student student);
void deleteStudent(String sno);
Student findStudentBySno(String sno);
void displayAllStudent(); /********** End **********/
}
studentDAOlmpl:
package step4;
import java.util.ArrayList;
import java.util.List;
public class StudentDAOImpl implements IStudentDAO {
static List<Student> students = new ArrayList<Student>(); /********** Begin **********/
@Override
public void insertStudent(Student stu) {
// TODO Auto-generated method stub
students.add(stu);
}
@Override
public void deleteStudent(String sno) {
// TODO Auto-generated method stub
for(Student stu:students){
if(stu.getSno().equals(sno)){
students.remove(stu);
break;
}
}
}
@Override
public void updateStudent(Student stu) {
// TODO Auto-generated method stub
for(Student s:students){
if(stu.getSno().equals(s.getSno())){
stu.setSname(s.getSname());
stu.setSdept(s.getSdept());
break;
}
}
}
@Override
public Student findStudentBySno(String sno) {
// TODO Auto-generated method stub
for(Student stu:students){
if(stu.getSno().equals(sno)){
return stu;
}
}
return null;
}
/********** End **********/
/***显示所有学生信息记录参考代*/
@Override
public void displayAllStudent() {
if (students.size() > 0) {
for (Student stu : students) {
System.out.println(stu);
}
}else {
System.out.println("数据库中无学生记录!");
}
}
}
MainClass:
package step4;
import java.util.Scanner;
public class MainClass {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
StudentDAOImpl studentDAOImpl = new StudentDAOImpl();
//1. 插入学生信息
Student stu = new Student();
stu.setSno(scanner.next());
stu.setSname(scanner.next());
stu.setSdept(scanner.next());
studentDAOImpl.insertStudent(stu);
//2. 显示插入学生信息
System.out.println("1. 插入学生信息如下：");
studentDAOImpl.displayAllStudent();
//3. 更新学生信息
stu.setSname("李四");
stu.setSdept("计算机系");
studentDAOImpl.updateStudent(stu);
System.out.println("2. 更新后学生信息如下：");
System.out.println(studentDAOImpl.findStudentBySno(stu.getSno()));
//4. 删除指定学生信息
System.out.println("3. 删除当前学号学生信息：" + stu.getSno());
studentDAOImpl.deleteStudent(stu.getSno());
System.out.println("学生信息已删除!");
//2. 显示插入学生信息
System.out.println("5. 显示所有学生信息：");
studentDAOImpl.displayAllStudent()
scanner.close();
}
}
实验四：
public ArtFont() {
super("字体设置"); // 设置默认字体
boldStyle = 0;
italicStyle = 0;
underlineStyle = 0;
fontSizeStyle = 10;
fontNameStyle = "宋体";
font = new Font(fontNameStyle, boldStyle + italicStyle, fontSizeStyle);
northPanel = getNorthPanel();
centerPanel = getCenterPanel();
southPanel = getSouthPanel();
// 设置容器;
Container container = getContentPane();
container.setLayout(new BorderLayout());
// 将northPanel添加到窗体的北部
container.add(northPanel, BorderLayout.NORTH);
// 将centerPanel添加到窗体的中部
container.add(centerPanel, BorderLayout.CENTER);
// 将southPanel添加到窗体的南部
container.add(southPanel, BorderLayout.SOUTH);
setSize(500, 300);
// 将窗体位于屏幕的中央
setLocationRelativeTo(null);
setVisible(true);
}
private JPanel getNorthPanel() {
JPanel panel = new JPanel();
label = new JLabel("输入",JLabel.LEFT);
inputText = new JTextField(10);
boldBx = new JCheckBox("粗体");
italicBx = new JCheckBox("斜体");
colorBtn = new JButton("颜色");
JLabel label2 = new JLabel("计Z2008 202062318 盛燕",JLabel.RIGHT);
inputText.addActionListener(this);
colorBtn.addActionListener(this);
boldBx.addItemListener(this);
italicBx.addItemListener(this);
panel.add(label);
panel.add(inputText);
panel.add(boldBx);
panel.add(italicBx);
panel.add(colorBtn);
panel.add(label2);
return panel;
}
private JPanel getCenterPanel() {
JPanel panel = new JPanel();
txtArea = new JTextArea(10, 10);
panel.setLayout(new BorderLayout());
panel.add(new JScrollPane(txtArea), BorderLayout.CENTER);
return panel;
}
private JPanel getSouthPanel() {
JPanel panel = new JPanel();
//获得系统默认字体
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
fontNames = ge.getAvailableFontFamilyNames();
fontType = new JComboBox(fontNames);
//设置字体大小
fontSizes = new String[63];
for (int i = 0; i < fontSizes.length; i++) {
fontSizes[i] = Integer.toString(i+10);
}
fontSize =new JComboBox(fontSizes);
windowStyle =new JComboBox(style);
fontSize.addItemListener(this);
fontType.addItemListener(this);
panel.add(fontType);
panel.add(fontSize);
panel.add(windowStyle);
return panel;
}
public static void main(String args[]) {
ArtFont artFont = new ArtFont();
artFont.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
@Override
public void itemStateChanged(ItemEvent e) {
// TODO Auto-generated method stub
if (e.getSource() == boldBx) {
if(boldBx.isSelected()){
boldStyle=Font.BOLD;
}else{
boldStyle=Font.PLAIN;
}
} else if (e.getSource() == italicBx) {
if(italicBx.isSelected()){
italicStyle=Font.ITALIC;
}else{
italicStyle=Font.PLAIN;
}
} else if (e.getSource() == fontType) {
fontNameStyle= (String) e.getItem();
} else if (e.getSource() == fontSize) {
fontSizeStyle=Integer.parseInt((String) e.getItem());
} else if (e.getSource() == windowStyle) {
String s = (String) e.getItem();
String className = "";
if (s.equals("Windows显示效果"))
className = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
else if (s.equals("Unix显示效果"))
className = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
else if (s.equals("默认显示效果"))
className = UIManager.getCrossPlatformLookAndFeelClassName();
try {
UIManager.setLookAndFeel(className);
SwingUtilities.updateComponentTreeUI(this);
} catch (Exception de) {
System.out.println("Exception happened!");
}
}
font = new Font(fontNameStyle, boldStyle + italicStyle, fontSizeStyle);
txtArea.setFont(font);
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if (e.getSource() == inputText) {
txtArea.setText(inputText.getText());
} else if (e.getSource() == colorBtn) {
colorStyle=JColorChooser.showDialog(this,"请选择一种颜色",colorStyle);
colorBtn.setForeground(colorStyle);
txtArea.setForeground(colorStyle);
}
}
实验6
（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 fout = new FileOutputStream(file);
DataOutputStream dout = new DataOutputStream(fout);
// 利用输出流向文件中写入数组数据
for(int i=0;i<data.length;i++){
dout.writeInt(data[i]);
} //关闭输出流
dout.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 **********/
}
}
(2)输出流实现发送电报：
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 **********/
}
}
（4） 简单tcp通信client：
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();
}
}
Server：package step3;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Server extends Thread
@Override
public void run() {
try {
//创建服务器端ServerSocket(ss)，指定端口号8000
/********** Begin **********/
ServerSocket ss = new ServerSocket(8080);
/********** end **********/
Socket s = ss.accept();
DataOutputStream dos = new DataOutputStream(s.getOutputStream());
DataInputStream dis = new DataInputStream(s.getInputStream());
dos.writeUTF("你已经连上服务器了，告诉我你的姓名...");
String name = dis.readUTF();
dos.writeUTF("再见:" + name);
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
（5） tcp通信实现奇偶判断client：
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();
}
}
}
Receivethread：package step4;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.SocketException;
class ReceiveThread extends Thread {
DataOutputStream dos;
DataInputStream dis;
Socket s;
public ReceiveThread(Socket s, DataOutputStream dos, DataInputStream dis) {
this.s = s;
this.dos = dos;
this.dis = dis;
}
@Override
public void run() {
try {
dos.writeUTF("请输入一个整数，我知道是奇数还是偶数");
while(true) {
String num = dis.readUTF();
if("-1".equals(num)) {
s.close();
break;}
String result = (Integer.parseInt(num)%2==0)?"偶数":"奇数";
dos.writeUTF(num + "是..." + result);}
} catch (SocketException e) {
try {
s.close();
} catch (IOException e1) {
e1.printStackTrace();}
} catch (IOException e) {
System.out.println("数据读取异常");}
}
}
Serverplus：package step4;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerPlus extends Thread {
@Override
public void run() {
try {
/********** Begin ********** //创建服务器端ServerSocket(ss)，指定端口号8000
ServerSocket ss = new ServerSocket(8080);
/********** end **********/
Socket s = ss.accept();
DataOutputStream dos = new DataOutputStream(s.getOutputStream());
DataInputStream dis = new DataInputStream(s.getInputStream());
ReceiveThread thread = new ReceiveThread(s, dos, dis);
thread.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
学习通作业一：
package lab1;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner myscanner = new Scanner(System.in);
System.out.println("请输入姓名：");
String name=myscanner.next();
System.out.println(name+",您好！欢迎学习Java。");
}
}
（2）编写字符界面面板计算器程序package lab2;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner myscanner = new Scanner(System.in);
System.out.print("请输入第一个操作数: x=");
double x = myscanner.nextDouble();
System.out.print("请输入第二个操作数: y=");
double y = myscanner.nextDouble();
double sum,sub,mup,chu;
sum=x+y;
sub=x-y;
mup=x*y;
chu=x/y;
System.out.println("运算结果如下：");
System.out.println("x+y="+sum);
System.out.println("x-y="+sub);
System.out.println("x*y="+mup);
System.out.println("x/y="+chu);
}
}
（3）package lab3;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
Scanner myscanner=new Scanner(System.in);
double x,y;
System.out.print("请输入第一个操作数： x=");
x=myscanner.nextDouble();
System.out.print("请输入第二个操作数： y=");
y=myscanner.nextDouble();
double sum,sub,mup,chu;
sum=x+y;
sub=x-y;
mup=x*y;
chu=x/y;
System.out.println("运算结果如下：");
System.out.println(x+"+"+y+"="+sum);
System.out.println(x+"-"+y+"="+sub);
System.out.println(x+"*"+y+"="+mup);
System.out.println(x+"/"+y+"="+chu);
}
}
作业二：（1）计算圆面积周长
package test4;
import java.util.Scanner;
public class circle {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(" ==== 计算圆面积周长 ====");
System.out.println("请输入圆的半径：");
Scanner sc=new Scanner(System.in);
double r=sc.nextDouble();
System.out.println("半径为"+r+"的圆面积: "+String.format("%.2f", getarea(r)));
System.out.println("半径为"+r+"的圆周长: "+String.format("%.2f", getperi(r)));
}
public static double getarea(double r) {
return 3.14*r*r;
}
public static double getperi(double r) {
return 2*3.14*r;
}
}
（2）求矩形面积和周长的程序：
package test4;
import java.util.Scanner;
public class rectangle {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(" ==== 计算矩形面积周长 ====");
System.out.println("请输入矩形的长度：");
Scanner sc=new Scanner(System.in);
double l=sc.nextDouble();
System.out.println("请输入矩形的宽度：");
double b=sc.nextDouble();
System.out.println("长"+l+"宽"+b+"的矩形面积: "+String.format("%.2f", getarea(l,b)));
System.out.println("长"+l+"宽"+b+"的矩形周长: "+String.format("%.2f", getperi(l,b)));
}
public static double getarea(double l,double b) {
return l*b;
}
public static double getperi(double l,double b) {
return 2*(l+b);
}
（3）编程成绩统计程序，要求运行时提示输入逗号分隔的多个成绩分数，然后对这些分数降序排序，并找出最高和最低分，统计平均分。
package test4;
import java.util.Scanner;
import java.util.Arrays;
public class score {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(" ====成绩统计====");
System.out.println("请输入逗号分隔的多个成绩分数(最多1位小数):");
Scanner sc = new Scanner(System.in);
String str =sc.nextLine();
String[] strs=str.split(",");
double is[]=new double[strs.length];
for(int i=0;i<strs.length;i++) {
is[i]=Double.parseDouble(strs[i]);}
System.out.println("按从大到小(降序)排序后的数据:");
Arrays.sort(is);
for(int i=0;i<is.length/2;i++) {
double temp=is[i];
is[i]=is[is.length-1-i];
is[is.length-1-i]=temp;}
for(int i=0;i<is.length;i++) {
System.out.print(is[i]+" ");}
System.out.println();
System.out.println("最高分: "+max(is));
System.out.println("最低分: "+min(is));
System.out.println("平均分: "+String.format("%.2f",aver(is)));}
public static double max(double[] nums) {//最高分
double max=nums[0];
for(int i=0;i<nums.length;i++) {
if(nums[i]>max)
max=nums[i];}
return max;}
public static double min(double[] nums) {//最低分
double min=nums[0];
for(int i=0;i<nums.length;i++) {
if(nums[i]<min)
min=nums[i];}
return min;}
public static double aver(double[] nums) {//平均分
double aver=nums[0],sum = 0;
for(int i=0;i<nums.length;i++) {
sum+=nums[i];}
aver=sum/nums.length;
return aver;
}
}
作业三：GUI整数加法器：
package homeworks;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class IntegerAdder extends JFrame implements ActionListener {
private static final long serialVersionUID = 1L;
private String num1, operator, result;
private boolean startNum2;
private JButton[] numButtons;
private JButton addButton, equalsButton, clearButton;
public IntegerAdder() {
setTitle("整数加法器");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel = new JPanel();
panel.setLayout(new GridLayout(4, 3));
numButtons = new JButton[10];
for (int i = 0; i < numButtons.length; i++) {
numButtons[i] = new JButton(String.valueOf(i));
numButtons[i].addActionListener(this);}
addButton = new JButton("加");
addButton.addActionListener(this);
equalsButton = new JButton("等于");
equalsButton.addActionListener(this);
clearButton = new JButton("清空");
clearButton.addActionListener(this);
clearButton.setPreferredSize(new Dimension(100, 30));
panel.add(numButtons[0]);
panel.add(numButtons[1]);
panel.add(numButtons[2]);
panel.add(numButtons[3]);
panel.add(numButtons[4]);
panel.add(numButtons[5]);
panel.add(numButtons[6]);
panel.add(numButtons[7]);
panel.add(numButtons[8]);
panel.add(numButtons[9]);
panel.add(addButton);
panel.add(equalsButton);
JPanel topPanel = new JPanel(new BorderLayout());
topPanel.setPreferredSize(new Dimension(0, 30));
topPanel.add(clearButton, BorderLayout.CENTER);
getContentPane().add(topPanel, BorderLayout.NORTH);
getContentPane().add(panel, BorderLayout.CENTER);
pack();
setVisible(true);
num1 = "";
operator = "";
result = "";
startNum2 = false}
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < numButtons.length; i++) // 数字按钮
if (e.getSource() == numButtons[i]) {
if (!startNum2) {
num1 += i;
} else {
result += i;}
clearButton.setText("清空");
return;
}
}
// 清空按钮
if (e.getSource() == clearButton) {
num1 = "";
operator = "";
result = "";
startNum2 = false;
clearButton.setText("清空");
}
if (e.getSource() == addButton) { // 加号按钮
operator = "+";
startNum2 = true;
clearButton.setText("清空");
if (e.getSource() == equalsButton) { // 等号按钮
int n1 = Integer.parseInt(num1);
int n2 = Integer.parseInt(result);
int sum = n1 + n2;
clearButton.setText(num1 + operator + result + "=" + sum);
num1 = String.valueOf(sum);
operator = "";
result = "";
startNum2 = false;
}
}
public static void main(String[] args) {
new IntegerAdder();
}
}
（2）package homeworks;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class TextStyler extends JFrame implements ActionListener {
private JTextArea textArea;
private JCheckBox italicCheck, boldCheck;
private JRadioButton largeRadio, mediumRadio, smallRadio;
public TextStyler() {
setTitle("文本样式"); // 设置窗口属性
setSize(400, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 创建主面板，并设置布局为 BoxLayout
JPanel mainPanel = new JPanel();
mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.X_AXIS));
// 创建左侧面板，包含可复选按钮
JPanel leftPanel = new JPanel();
leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.Y_AXIS));
italicCheck = new JCheckBox("斜体");
italicCheck.addActionListener(this);
boldCheck = new JCheckBox("粗体");
boldCheck.addActionListener(this);
leftPanel.add(italicCheck);
leftPanel.add(Box.createVerticalStrut(10));
leftPanel.add(boldCheck);
mainPanel.add(leftPanel);
JPanel rightPanel = new JPanel();// 创建右侧面板，包含单选按钮
rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.Y_AXIS));
largeRadio = new JRadioButton("大字号");
largeRadio.addActionListener(this);
mediumRadio = new JRadioButton("中字号");
mediumRadio.addActionListener(this)
smallRadio = new JRadioButton("小字号");
smallRadio.addActionListener(this);
ButtonGroup group = new ButtonGroup();
group.add(largeRadio);
group.add(mediumRadio);
group.add(smallRadio);
rightPanel.add(largeRadio);
rightPanel.add(Box.createVerticalStrut(10));
rightPanel.add(mediumRadio);
rightPanel.add(Box.createVerticalStrut(10));
rightPanel.add(smallRadio);
mainPanel.add(rightPanel);
// 创建文本框，并设置初始字体样式
textArea = new JTextArea("我喜欢C++，\n但我更喜欢Java");
Font font = new Font("黑体", Font.PLAIN, 12);
textArea.setFont(font);
mainPanel.add(textArea);
// 将主面板添加到窗口中，并显示窗口
add(mainPanel);
setVisible(true);}
// 实现 ActionListener 接口中的方法
public void actionPerformed(ActionEvent e) {
Font font;
int size = 0;
int style = Font.PLAIN;
if (e.getSource() == italicCheck) { // 根据选择设置字体样式
style = italicCheck.isSelected() ? style | Font.ITALIC : style & ~Font.ITALIC;
} else if (e.getSource() == boldCheck) {
style = boldCheck.isSelected() ? style | Font.BOLD : style & ~Font.BOLD;
} else if (e.getSource() == largeRadio) {
size = 48;
font = new Font("黑体", style, size);
textArea.setFont(font);
return; // 直接返回，不需要设置字体大小
} else if (e.getSource() == mediumRadio) {
size = 24;
} else if (e.getSource() == smallRadio) {
size = 12;
}font = new Font("黑体", style, size);
textArea.setFont(font);
}
public static void main(String[] args) {
new TextStyler();
}
}
作业四：Java综合编程编写带图形界面的聊天程序
Server
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
public class Server implements ActionListener {
JTextArea textArea;
JTextField textField;
JButton sendButton;
ServerSocket serverSocket;
List<ClientThread> clients;
public static void main(String[] args) {
new Server().start();
}
public Server() {
JFrame frame = new JFrame("服务器");
JPanel panel = new JPanel(new BorderLayout());
textArea = new JTextArea(20, 60);
textArea.setEditable(false);
JScrollPane scrollPane = new JScrollPane(textArea);
panel.add(BorderLayout.CENTER, scrollPane);
JPanel bottomPanel = new JPanel(new BorderLayout());
textField = new JTextField(40);
bottomPanel.add(BorderLayout.CENTER, textField);
sendButton = new JButton("发送");
sendButton.addActionListener(this);
bottomPanel.add(BorderLayout.EAST, sendButton);
panel.add(BorderLayout.SOUTH, bottomPanel);
frame.setContentPane(panel);
frame.setSize(400,300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
public void start() {
try {
serverSocket = new ServerSocket(8000);
clients = new ArrayList<ClientThread>();
while (true) {
Socket socket = serverSocket.accept();
ClientThread clientThread = new ClientThread(socket,textArea);
clients.add(clientThread);
clientThread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public synchronized void removeFromClients(ClientThread clientThread) {
clients.remove(clientThread);
}
@Override
public void actionPerformed(ActionEvent event) {
String message = textField.getText();
if (!message.equals("")) {
// 发送消息给所有客户端
for (ClientThread client : clients) {
client.sendToClient("服务器说： " + message);
}
textField.setText("");
}
}
class ClientThread extends Thread {
Socket socket;
DataInputStream dis;
DataOutputStream dos;
JTextArea textArea;
public ClientThread(Socket socket, JTextArea textArea) {
this.socket = socket;
this.textArea = textArea;
try {
dis = new DataInputStream(socket.getInputStream());
dos = new DataOutputStream(socket.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
public void close() {
try {
dos.writeUTF("exit");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void sendToClient(String message) {
try {
synchronized (this) {
dos.writeUTF(message);
textArea.append(message + "\n"); // 在客户端窗口中显示消息记录
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
String name = dis.readUTF();
textArea.append(name + "连接成功！\n"); // 添加消息提示
while (true) {
String message = dis.readUTF();
if (message.equals("exit")) {
break;}
textArea.append("客户端" + "说： " + message + "\n"); // 在服务器窗口显示消息记录
}
textArea.append(name + "离开了！\n");
removeFromClients(this);
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void sendToAllClients(String message) {
for (ClientThread client : clients) {
try {
synchronized (client) {
if (!this.equals(client)) { // 不要发送给自己
client.sendToClient(message);
}
client.dos.writeUTF(message);
client.textArea.append(message + "\n"); //在客户端窗口显示消息
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Client
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
public class Client {
JTextArea textArea;
JTextField textField;
Socket socket;
DataInputStream dis;
DataOutputStream dos;
public static void main(String[] args){
new Client().start();
}
public Client() {
JFrame frame = new JFrame("客户端");
JPanel panel = new JPanel(new BorderLayout());
textArea = new JTextArea(20, 60);
textArea.setEditable(false);
JScrollPane scrollPane = new JScrollPane(textArea);
panel.add(BorderLayout.CENTER, scrollPane);
// 添加输入框和发送按钮
JPanel bottomPanel = new JPanel(new BorderLayout());
textField = new JTextField(40);
bottomPanel.add(BorderLayout.CENTER, textField);
JButton sendButton = new JButton("发送");
sendButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
sendMessage();
}
});
bottomPanel.add(BorderLayout.EAST, sendButton);
panel.add(BorderLayout.SOUTH, bottomPanel);
frame.setContentPane(panel);
frame.setSize(400,300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
public void start() {
try {
socket = new Socket("127.0.0.1", 8000);
dis = new DataInputStream(socket.getInputStream());
dos = new DataOutputStream(socket.getOutputStream());
String name = JOptionPane.showInputDialog("请输入你的姓名：");
dos.writeUTF(name);
Thread listenThread = new ListenThread();
listenThread.start();
} catch (IOException e) {
e.printStackTrace();
}
}
public void sendMessage() {
try {
String message = textField.getText();
if (!message.equals("")) {
dos.writeUTF(message);
// 在聊天记录中显示客户端说的话
textArea.append("客户端说： " + message + "\n");
}
textField.setText("");
} catch (IOException e) {
e.printStackTrace();
}
}
class ListenThread extends Thread {
@Override
public void run() {
try {
while (!socket.isClosed()) {
String message = dis.readUTF();
textArea.append(message + "\n");
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (dis != null) dis.close();
if (dos != null) dos.close();
if (socket != null) socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
本文来自博客园，作者：Cloudservice，转载请注明原文链接：https://www.cnblogs.com/whwh/p/18219601，只要学不死，就往死里学！
