包与字符串
1.创建包的基本操作
在biology包中的animal包中有human类,它具有name,height,weight的属性,还具有eat(),sleep()和work()的行为,在biology包中的plant包中有flower类,它具有name,color,smell的属性,还具有drink()和blossom()的行为.
现在在一个school包中的garden包中一个张三的人,他是一个human类的对象,种植的rose是一个flower类对象,编程实现并测试各自的方法.
package biology.animal;
public class human {
String name;
int height;
int weight;
void eat() {
System.out.println("吃饭");
}
void sleep() {
System.out.println("睡觉");
}
void work() {
System.out.println("工作");
}
public human(String name, int height, int weight) {
super();
this.name = name;
this.height = height;
this.weight = weight;
}
public human() {
super();
// TODO Auto-generated constructor stub
}
}
package biology.plant;
public class flower {
String name;
String color;
String smell;
void drink() {
System.out.println("喝水");
}
void blosson() {
System.out.println("开花");
}
public flower(String name, String color, String smell) {
super();
this.name = name;
this.color = color;
this.smell = smell;
}
public flower() {
super();
// TODO Auto-generated constructor stub
}
}
package school.garden;
import biology.animal.human;
import biology.plant.*;
public class zhangsan {
public static void main(String[] args) {
human zs = new human("张三",180,160);
flower rose = new flower("玫瑰花","红色","香");
}
}
2.跨包访问
2. 在computer包中的mainbroad包中有一个VGACard的类,它有一个显示方法show(),显示”VGA checked success”,在server的包的mainbroad包中的showCard类是继承自VGACard,请测试showCard的show()功能。
package computer.mainbroad;
public class VGACard {
public void show() {
System.out.println("VGA checked success");
}
}
方法记得写成public，不然跨包可能会访问不到
package serve.mainbroad;
import computer.mainbroad.*;
public class showCard extends VGACard {
public static void main(String[] args) {
showCard t = new showCard();
t.show();
}
}
3.跨包使用类
3. 在com.graphic包中定义一个圆柱体类Cylinder，其半径r，高h都为私有属性，有构造方法和求体级方法volume()。在com.test包中定义一个测试类test，测试一个半径为5.34、高为2的圆柱体体积。半径PI为3.14
package com.graphic;
public class Cylinder {
private double r,h;
public Cylinder() {
super();
// TODO Auto-generated constructor stub
}
public Cylinder(double r, double h) {
super();
this.r = r;
this.h = h;
}
public double volume() {
return h*3.14*r*r;
}
}
package com.test;
import com.graphic.Cylinder;
public class test {
public static void main(String[] args) {
Cylinder t = new Cylinder(5.34,2);
System.out.println(t.volume());
}
}
4.统计子串出现次数
4. 编写程序统计一个字符子串在一个字符串中出现的次数和位置。如子字符串“nba”在字符串”asfasfnabaasdfnbasdnbasnbasdnbadfasdf”中出现的次数和出现的位置。
package com.test;
public class test {
public static void main(String[] args) {
String Str = "asfasfnabaasdfnbasdnbasnbasdnbadfasdf";
String str = "nba";
int index = 0;
int cnt = 0;
while(true) {
index = Str.indexOf(str, index);
if(index==-1) break;
cnt++;
System.out.println("第"+cnt+"次出现在下标"+index);
index+=str.length();
}
System.out.println("共出现了"+cnt+"次");
}
}
5.数组排序
5. 对字符串“23 10 -8 0 3 7 108”中的数值进行升序排序，生成一个数值有序的字符串 “-8 0 3 7 10 23 208”。
一些前置知识
1）ArrayList是基于动态数组实现的，它可以存储任意类型的元素，并且具有自动扩容的能力。以下是一些常用的ArrayList方法：
add(element)：向列表末尾添加一个元素。get(index)：获取指定索引位置的元素。size()：返回列表中元素的数量。remove(index)：删除指定索引位置的元素。
2）使用Collections.sort()方法进行排序：
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);
numbers.add(1);
System.out.println("排序前：" + numbers);
Collections.sort(numbers);
System.out.println("排序后：" + numbers);
}
}
3）如果你想将一串字符转化为整数，可以使用Java提供的Integer.parseInt()方法。这个方法可以将字符串转换为对应的整数。以下是一个示例代码：
public class Main {
public static void main(String[] args) {
String numberString = "12345";
int number = Integer.parseInt(numberString);
System.out.println("转换后的整数是：" + number);
}
}
4）如果你想输入一行字符串含空格，不能用sc.next()，而是用sc.nextLine()
思路：先将字符串（含空格）输入，以空格为界限，将数字字符串提取出来，将数字字符串转换为整形，插入ArrayList集合，用Collections.sort()排序。最后输出
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s;
s = sc.nextLine();
String temp = null;
ArrayList<Integer> a = new ArrayList<>();
for(int i = 0;i<s.length();i++) {
char c = s.charAt(i);
if(c==' ') {
a.add(Integer.parseInt(temp));
temp = "";
}
else {
temp+=c;
}
}
//a.add(100);
Collections.sort(a);
for(int i = 0;i<a.size();i++) {
if(i!=0) System.out.printf(" ");
System.out.printf("%d",a.get(i));
}
}
}
分支循环
1.模拟掷色子
1．编写一个模拟同时掷骰子的程序。要用Math.random()模拟产生两个骰子，将两个结果相加，相加的和等于7的可能性最大，等于2和12的可能性最小。程序模投掷3600次，判断求和的结果是否合理。
先介绍Math.random()的用法
Math.random()方法返回的是0.0到1.0之间的一个随机双精度浮点数。
//如果需要生成指定范围内的随机数，可以使用以下公式：
double randomNumInRange = Math.random() * (max - min) + min;
//如果想生成随机整数1—10
int randomInt = (int) (Math.random() * 10) + 1;
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
int[] a = new int[20];
int t = 3600;
while(t-->0) {
int b = (int)(Math.random()*6+1);
int c = (int)(Math.random()*6+1);
a[b+c]++;
}
for(int i = 2;i<=12;i++) {
System.out.println("和为"+i+"出现了"+a[i]+"次");
}
}
}
2.打印图形
2．编程：从键盘读取星号数，采用循环语句打印如下图形。如：从键盘输入10，则星号排列最大数是10。注意图4图5星号数需要为奇数：
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 1;i<=n;i++) {
for(int j = 1;j<=i;j++) {
System.out.printf("*");
}
System.out.println();
}
for(int i = 1;i<=n-1;i++) {
for(int j = 1;j<=i;j++) {
System.out.printf(" ");
}
for(int j = 1;j<=n-i;j++) {
System.out.printf("*");
}
System.out.println();
}
}
}
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 1;i<=n;i++) {
for(int j = 1;j<=i;j++) {
System.out.printf("*");
}
System.out.println();
}
for(int i = 1;i<=n-1;i++) {
for(int j = 1;j<=n-i;j++) {
System.out.printf("*");
}
System.out.println();
}
}
}
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 1;i<=n;i++) {
for(int j = 1;j<=n-i;j++) {
System.out.printf(" ");
}
for(int j = 1;j<=i;j++) {
System.out.printf("*");
}
System.out.println();
}
}
}
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 1;i<=n;i++) {//打印2*i-1
for(int j = 1;j<=n-i;j++) {
System.out.printf(" ");
}
for(int j = 1;j<=2*i-1;j++) {
System.out.printf("*");
}
System.out.println();
}
for(int i = n-1;i>=1;i--) {//打印2*i-1
for(int j = 1;j<=n-i;j++) {
System.out.printf(" ");
}
for(int j = 1;j<=2*i-1;j++) {
System.out.printf("*");
}
System.out.println();
}
}
}
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 1;i<=n;i++) {//打印2*i-1
for(int j = 1;j<=n-i;j++) {
System.out.printf(" ");
}
for(int j = 1;j<=2*i-1;j++) {
System.out.printf("*");
}
System.out.println();
}
}
}
3. 猜数字游戏
编写一个猜数字游戏的程序，预先生成一个0-9的随机数，用户键盘录入一个所猜的数字，如果输入的数字和后台预先生成的数字相同，则表示猜对了，这时，程序会打印“恭喜您，答对了！”如果不相同，则比较输入的数字和后台预先生成的数字大小，如果大了，打印“sorry，您猜大了！”如果小了，打印“sorry，您猜小了！”如果一直猜错，则游戏一直继续，直到数字猜对为止。
package com.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int ans = (int)(Math.random()*9);
while(true) {
int g = sc.nextInt();
if(g==ans) {
System.out.println("猜对了");
break;
}
else if(g>ans) {
System.out.println("猜大了");
}
else {
System.out.println("猜小了");
}
}
}
}
封装
1.有参构造的考察
定义一个类Person,定义name和age私有属性，定义有参的构造方法对name和age进行初始化。在测试类中创建该类的2个对象，姓名、年龄分别为lili、19和lucy、20，在屏幕打印出2个对象的姓名和年龄。
class Person {
private String name;
private int age;
Person(){}
Person(String name,int age){
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person("lili",19);
Person p2 = new Person("lucy",20);
System.out.println(p1.toString());
System.out.println(p2.toString());
}
}
2.计算长方形
首先定义一个计算长方形面积的类rectangleClass，要求类中有一个定义长方形左上角和右下角座标的构造函数，以及一个通过长方形右下角座标与左上角座标计算长方形面积,并实例化两个长方形进行测试.
用到了Math库的函数
class rectangleClass {
private int x1,y1,x2,y2;
public rectangleClass(int x1, int y1, int x2, int y2) {
super();
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
public int calc() {
return Math.abs(this.x1-this.x2)*Math.abs(this.y1-this.y2);
}
}
public class Main {
public static void main(String[] args) {
rectangleClass r1 = new rectangleClass(-5,3,-3,1);
rectangleClass r2 = new rectangleClass(2,-3,4,-6);
System.out.println(r1.calc());
System.out.println(r2.calc());
}
}3.设计Book类
设计一个表示图书的Book类，它包含图书的书名、作者、月销售量等私有属性，另有两个构造方法（一个不带参数，另一个带参数），成员方法setBook( ) 和printBook()分别用于设置和输出书名、作者、月销售量等数据。并设计相应的测试Book类的应用程序主类，测试并显示输出提供所有功能的结果。
class Book {
private String bookname,author;
private int sell;
public Book(String bookname, String author, int sell) {
super();
this.bookname = bookname;
this.author = author;
this.sell = sell;
}
public Book() {
super();
}
public void setBook(String bookname,String author,int sell) {
this.bookname = bookname;
this.author = author;
this.sell = sell;
}
public void printBook() {
System.out.println("书名："+this.bookname+" 作者："+this.author+" 月销量："+this.sell);
}
}
public class Main {
public static void main(String[] args) {
Book b1 = new Book("书本1","作者1",1234);
Book b2 = new Book("书本2","作者2",1234567);
b1.printBook();b2.printBook();
}
}
4.设计银行账户
请创建一个银行帐户类，要求如下：（１）类包括帐户名、帐户号、存款额等私有属性；（3）有三个参数的构造方法（２）可实现余额查询，存款和取款的操作。（３）创建该类的对象，验证以上两项。
其实还有一些可以完善的地方，例如取款存款不能为负数，懒得补充了。
class BankAccount {
private String account_name,account_id;
private int money;
public BankAccount(String account_name, String account_id, int money) {
this.account_name = account_name;
this.account_id = account_id;
this.money = money;
}
public BankAccount() {
}
public int search_money() {
return this.money;
}
public void take_money(int val) {
if(val>this.money) {
System.out.println("余额不足，取钱失败");
}
else {
this.money-=val;
System.out.printf("已取%d元，账户余额：%d\n",val,this.money);
}
}
public void save_money(int val) {
this.money+=val;
System.out.printf("已存%d元，账户余额：%d\n",val,this.money);
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
BankAccount b = new BankAccount("cwm","1234567890",999999);
System.out.println("0.退出 1.存钱 2.取钱 3.查询余额");
while(true) {
int op = sc.nextInt();
if(op==0) break;
else if(op==1) {
System.out.printf("存入：");
int save = sc.nextInt();
System.out.println();
b.save_money(save);
}
else if(op==2) {
System.out.printf("取出：");
int take = sc.nextInt();
System.out.println();
b.take_money(take);
}
else {
System.out.println(b.search_money());
}
}
}
}继承
1.设计学生类
设计一个学生类Student，其数据成员有name(姓名)、age(年龄)和degree(学位)。由Student类派生出本科生类Undergraduate和研究生类Graduate，本科生类Undergraduate增加成员specialty(专业)，研究生类增加成员direction(研究方向)。每个类都有show()方法，用于输出数据成员信息。最后请输出下列信息:
class Student{
String name,degree;
int age;
}
class Undergraduate extends Student{
String specialty;
Undergraduate(String name,int age,String degree,String specialty){
this.name = name;this.age = age;this.degree = degree;this.specialty = specialty;
}
void show() {
System.out.printf("姓名：%s 年龄:%d 学位%s 专业:%s\n",name,age,degree,specialty);
}
}
class Graduate extends Student{
String direction;
Graduate(String name,int age,String degree,String direction){
this.name = name;this.age = age;this.degree = degree;this.direction = direction;
}
void show() {
System.out.printf("姓名：%s 年龄:%d 学位%s 研究方向:%s\n",name,age,degree,direction);
}
}
public class Main {
public static void main(String[] args) {
Undergraduate u1 = new Undergraduate("张三",20,"本科","通信");
Graduate g1 = new Graduate("李四",25,"研究生","计算机");
u1.show();g1.show();
}
}
2.计算薪资
有工人、服务员、教师、科学家四种角色，其中服务员、工人只有月固定工资（元/月），教师除月固定工资外，还有课酬（元/节）。科学家除月固定工资外，还有科研激励奖（元/季度）。请通过继承设计出相应的类，将各种类型的员工的全年工资打印出来，并测试（张三、工人、4000元/月）、（李四、服务员、3500元/月）、（王五、教师、5000元/月、100元/节，200节/年）、（刘六、科学家、7000元/月、20000元/季度）。
package demo;
import java.util.*;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.Random;
import java.util.Arrays;
import javax.swing.*;
import java.awt.*;
import java.awt.*;
import java.awt.event.*;
class Person{
String name;
int basicSalary;
public Person(String name, int basicSalary) {
super();
this.name = name;
this.basicSalary = basicSalary;
}
}
class woker extends Person{
public woker(String name, int basicSalary) {
super(name, basicSalary);
// TODO Auto-generated constructor stub
}
int show() {
return basicSalary*12;
}
}
class waiter extends Person{
public waiter(String name, int basicSalary) {
super(name, basicSalary);
// TODO Auto-generated constructor stub
}
int show() {
return basicSalary*12;
}
}
class teacher extends Person{
public teacher(String name, int basicSalary) {
super(name, basicSalary);
// TODO Auto-generated constructor stub
}
int show() {
return basicSalary*12+100*200;
}
}
class scientist extends Person{
public scientist(String name, int basicSalary) {
super(name, basicSalary);
// TODO Auto-generated constructor stub
}
int show() {
return basicSalary*12+20000*4;
}
}
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
woker t1 = new woker("张三",4000);
waiter t2 = new waiter("李四",3500);
teacher t3 = new teacher("王五",5000);
scientist t4 = new scientist("刘六",7000);
System.out.println(t1.name+t1.show());
System.out.println(t2.name+t2.show());
System.out.println(t3.name+t3.show());
System.out.println(t4.name+t4.show());
}
}
3.Pet继承
根据下述继承关系图，请完成父类Pet 、子类Dog、Penguin的设计，并写一个测试类，测试类中完成狗对象的创建与输出，企鹅对象的创建与输出。
abstract class Pet{//因为print函数是无法统一的，所以写成抽象方法
String name;
int health,love;
abstract void print();//注意，抽象方法就不用写{}了
public String getName() {
return name;
}
public int getHealth() {
return health;
}
public int getLove() {
return love;
}
}
class Dog extends Pet{
String strain;
public Dog(String strain,String name,int health,int love) {
this.name = name;
this.health = health;
this.love = love;
this.strain = strain;
}
String getStrain() {
return strain;
}
@Override
void print() {
// TODO Auto-generated method stub
System.out.printf("品种:%s 名字：%s 健康：%d 喜爱程度%d\n",strain,name,health,love);
}
}
class Penguin extends Pet{
String sex;
public Penguin(String sex,String name,int health,int love) {
this.name = name;
this.health = health;
this.love = love;
this.sex = sex;
}
String sex() {
return sex;
}
@Override
void print() {
// TODO Auto-generated method stub
System.out.printf("性别：%s 名字：%s 健康：%d 喜爱程度%d\n",sex,name,health,love);
}
}
public class Main {
public static void main(String[] args) {
Dog d = new Dog("牧羊犬","狗子",100,60);
Penguin p = new Penguin("公","Q仔",90,50);
d.print();p.print();
}
}
抽象类，接口
1.学生抽象类
首先设计一个学生抽象类Student，其数据成员有name(姓名)、age(年龄)和degree(学位)，以及一个抽象方法show()。然后由Student类派生出本科生类Undergraduate和研究生类Graduate，本科生类Undergraduate增加成员specialty(专业)，研究生类增加成员direction(研究方向)。并且每个类都有show()方法，用于输出数据成员信息。请定义对象，并打印输出下列信息：
abstract class Student{
String name;
int age;
String degree;
public Student() {}
public Student(String name, int age, String degree) {
this.name = name;
this.age = age;
this.degree = degree;
}
abstract void show();
}
class Undergraduate extends Student{
String specialty;
public Undergraduate() {
super();
// TODO Auto-generated constructor stub
}
public Undergraduate(String name, int age, String degree,String specialty) {
super(name, age, degree);
this.specialty = specialty;
// TODO Auto-generated constructor stub
}
@Override
void show() {
// TODO Auto-generated method stub
System.out.println(name+" "+age+"岁 "+degree+" "+specialty);
}
}
class Graduate extends Student{
String direction;
public Graduate() {
super();
// TODO Auto-generated constructor stub
}
public Graduate(String name, int age, String degree,String direction) {
super(name, age, degree);
// TODO Auto-generated constructor stub
this.direction = direction;
}
@Override
void show() {
// TODO Auto-generated method stub
System.out.println(name+" "+age+"岁 "+degree+" "+direction);
}
}
public class Main {
public static void main(String[] args) {
Undergraduate u = new Undergraduate("张三",20,"计算机","软件工程");
Graduate g = new Graduate("李四",30,"计算机","计算机视觉");
u.show();g.show();
}
}
2.图形抽象类
设计一个抽象类Graphics,它具有一个String类型参数name和两个抽象方法parameter()、area()，name用来存储图形的名称，parameter()方法用于输出图形的名称和其它属性特征，area()方法用于输出图形的面积。请用该类派生的子类实现输出一个形状为长方形、长为3宽为2和它的面积以及输出一个形状为圆形、颜色为红色、半径为4和它的面积。
abstract class Graphics{
String name;
abstract void parameter();
abstract void area();
}
class Rectangle extends Graphics{
int highth,width;
Rectangle(String name,int h,int w){
this.name = name;
this.highth = h;
this.width = w;
}
@Override
void parameter() {
// TODO Auto-generated method stub
System.out.println(name+"长为"+highth+" 宽为"+width);
}
@Override
void area() {
// TODO Auto-generated method stub
System.out.println(name+"面积为"+highth*width);
}
}
class Round extends Graphics{
int r;String color;
Round(String name,int r,String color){
this.name = name;
this.r = r;
this.color = color;
}
void parameter() {
System.out.println(name+"颜色是"+color+" 半径为"+r);
}
@Override
void area() {
// TODO Auto-generated method stub
System.out.println(name+"面积为"+3.14*r*r);
}
}
public class Main {
public static void main(String[] args) {
Rectangle re = new Rectangle("长方形",3,2);
Round ro = new Round("圆形",4,"红色");
re.parameter();re.area();
ro.parameter();ro.area();
}
}3.圆形接口
设计一个接口circleInterface，要求接口中有一个定义PI的常量以及一个计算圆面积的空方法circleArea()。然后设计一个类circleClass实现该接口，通过构造函数circleClass(double r)定义圆半径，并增加一个显示圆面积的方法。最后，通过上述类生成两个半径分别为3.5、5.0的圆对象circle1、circle2进行测试。
interface circleInterface{
final double PI = 3.14;
double circleArea();
}
class circleClass implements circleInterface{
double r;
circleClass(double r){
this.r = r;
}
@Override
public double circleArea() {
// TODO Auto-generated method stub
return PI*r*r;
}
}
public class Main {
public static void main(String[] args) {
circleClass c1 = new circleClass(3.5);
circleClass c2 = new circleClass(5.0);
System.out.println(c1.circleArea());
System.out.println(c2.circleArea());
}
}
4.Shape接口
设计一个Shape接口和它的两个实现类Square和Circle,要求如下：1）Shape接口中有一个抽象方法area（），方法接收一个double类型的参数，返回一个double类型的结果。2）Square和Circle中实现了Shape接口的area()抽象方法，分别求正方形和圆形的面积并返回。在测试类中创建Square和Circle对象，计算边长为2的正方形面积和半径为3的园面积
interface Shape{
abstract double area(double x);
}
class Square implements Shape{
@Override
public double area(double x) {
// TODO Auto-generated method stub
return x*x;
}
}
class Circle implements Shape{
@Override
public double area(double x) {
// TODO Auto-generated method stub
return 3.14*x*x;
}
}
public class Main {
public static void main(String[] args) {
Square s = new Square();
System.out.println(s.area(2));
Circle c = new Circle();
System.out.println(c.area(3));
}
}
5.接口数组的应用
定义一个USB接口，并通过Mouse和U盘类实现它，具体要求是：
1.接口名字为USB，里面包括两个抽象方法：
void work（）；描述可以工作
void stop(); 描述停止工作
2.完成类Mouse，实现接口USB，实现两个方法：
work方法输出“我点点点”；
stop方法输出 “我不能点了”；
3.完成类UPan，实现接口USB，实现两个方法：
work方法输出“我存存存”；
stop方法输出 “我走了”；
4测试类Main中，main方法中
定义接口变量usb1 ，存放鼠标对象，然后调用work和stop方法
定义接口数组usbs,包含两个元素，第0个元素存放一个Upan对象，第1个元素存放Mouse对象，循环数组，对每一个元素都调用work和stop方法。
分析：这题用到了接口数组，跟普通数组的定义是一样的。
那么接口数组存在的意义是什么呢？
它可以存放不同类型的实例化。例如Mouse和UPan类都实现了USB接口，此时我们定义一个USB接口数组，里面就能存Mouse和Upan的实例化对象。
interface USB{
void work();
void stop();
}
class Mouse implements USB{
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("我点点点");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("我不能点了");
}
}
class UPan implements USB{
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("我存存存");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("我走了");
}
}
public class Main {
public static void main(String[] args) {
Mouse usb1 = new Mouse();
usb1.work();usb1.stop();
USB usbs[] = new USB[2];
UPan up = new UPan();
usbs[0] = usb1;
usbs[1] = up;
for(int i = 0;i<2;i++) {
usbs[i].work();
usbs[i].stop();
}
}
}6.抽象类Person
设计抽象类Person，派生出具体类：学生类Student和教师类Teacher，创建若干不同类对象后并在主方法中测试。
数据成员定义：
Person [ID，姓名，生日]
Student [专业，成绩]
Teacher [职称，工资]
带参构造方法分别为：
Person(int id,String name, int bir)
Student(int id,String name, int bir, String major,double score)
Teacher(int id,String name, int bir, String title, double salary)
toString方法(Eclipse自动生成)输入格式:
第一行整数n表示有n个对象，每个对象占2行，第一行为数字0（表示学生）或1（表示教师），第二行为生成对象的参数。输出格式:
按行输出具体对象的信息。输入样例:
在这里给出一组输入。例如：5 0 10101 Peter 20010121 Computer 87.5 1 20110014 Crystal 19900103 AI 7000 0 10102 Rose 20010715 E-Commerce 90 1 20120019 David 19781218 Prof 12000 0 10103 Semon 20000405 Computer 88
输出样例:
在这里给出相应的输出。例如：
Student [id=10101, name=Peter, bir=20010121, major=Computer, score=87.5] Teacher [id=20110014, name=Crystal, bir=19900103, title=AI, salary=7000.0] Student [id=10102, name=Rose, bir=20010715, major=E-Commerce, score=90.0] Teacher [id=20120019, name=David, bir=19781218, title=Prof, salary=12000.0] Student [id=10103, name=Semon, bir=20000405, major=Computer, score=88.0]
abstract class Person{
int id,bir;
String name;
public Person(int id, String name, int bir) {
this.id = id;
this.name = name;
this.bir = bir;
}
public Person() {
}
}
class Student extends Person{
String specialty;
double score;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(int id, String name, int bir,String specialty,double score) {
super(id, name, bir);
// TODO Auto-generated constructor stub
this.specialty = specialty;
this.score = score;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", bir=" + bir + ", specialty=" + specialty + ", score=" + score
+ "]";
}
}
class Teacher extends Person{
String title;
double salary;
public Teacher() {
super();
// TODO Auto-generated constructor stub
}
public Teacher(int id, String name, int bir,String title,double salary) {
super(id, name, bir);
// TODO Auto-generated constructor stub
this.title = title;
this.salary = salary;
}
@Override
public String toString() {
return "Teacher [id=" + id + ", name=" + name + ", bir=" + bir + ", title=" + title + ", salary=" + salary
+ "]";
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
while(n--!=0) {
int op = sc.nextInt();
String name,major,title;
double score,salary;
int id,bir;
id = sc.nextInt();
name = sc.next();
bir = sc.nextInt();
if(op==0) {
//学生
major = sc.next();
score = sc.nextDouble();
Student s = new Student(id,name,bir,major,score);
System.out.println(s.toString());
}
else {
title = sc.next();
salary = sc.nextDouble();
Teacher t = new Teacher(id,name,bir,title,salary);
System.out.println(t.toString());
}
}
}
}
7.矩形类（简单封装）
编写一个矩形类 Rect，包含：两个 private 属性: 矩形的宽width；矩形的高 height。
两个构造方法：(1)一个带有两个参数的构造器方法，用于将 width 和 height 属性初化；
(2)一个不带参数的构造器，将矩形初始化为宽和高都为 10。
两个方法：
(1)求矩形面积的方法area()
(2)求矩形周长的方法 perimeter()定义测试类 RectTest，在它的main 方法中定义一个 Rect类的对象，从键盘输入两个数据分别作为宽和高，并用area()和 perimeter()方法输出其面积和周长。
class Rect{
private double width,height;
Rect(){
this.width = 10;
this.height = 10;
}
Rect(double width,double height){
this.width = width;
this.height = height;
}
double area() {
return width*height;
}
double perimeter() {
return 2*(width+height);
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double w = sc.nextDouble();
double h = sc.nextDouble();
Rect r = new Rect(w,h);
System.out.println(r.area());
System.out.println(r.perimeter());
}
}
GUI
前置知识
如果要自定义按钮在面板上的位置，可以使用绝对布局（AbsoluteLayout）或固定布局（FixedLayout）。
在绝对布局中，每个组件可以通过设置其坐标和大小来精确地放置在面板上。这种布局方式适用于需要完全控制组件位置和大小的场景，但是需要注意的是，当窗口大小发生变化时，组件的位置和大小不会自动调整，需要手动更新。
在固定布局中，每个组件都有一个固定的大小和位置，通常使用网格布局（GridBagLayout）或表格布局（TableLayout）来实现。这种布局方式适用于组件数量较少且位置固定的场景，可以使代码更加简洁易懂。
1.改变字体颜色
public class Main {
public static void main(String[] args) {
JFrame f = new JFrame("操作事件");
f.setBounds(220,160,320,240);
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JTextArea t = new JTextArea("字体颜色",5,20);
JButton b = new JButton("设置字体颜色");
b.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
t.setForeground(Color.red);
}
});
JPanel pane = new JPanel();
JPanel p1 = new JPanel();
JPanel p2 = new JPanel();
pane.add(p1);
pane.add(t);
pane.add(p2);
pane.add(b);
f.add(pane);
}
}2.颜色控制器
题目要求按钮的位置和大小，说明需要使用的布局是空布局，但JFrame窗口的内容面板默认布局是边界布局(BorderLayout)，所以需要设置一下，注意是设置Jpanel类对象（容器）的布局，而不是窗口的布局。
pane.setLayout(null);
public class Main {
static int r = 0;
static int b = 0;
static int g = 0;
public static void main(String[] args) {
JFrame f = new JFrame();
f.setBounds(220,160,320,240);
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JButton b1 = new JButton("红色");
JButton b2 = new JButton("绿色");
JButton b3 = new JButton("蓝色");
b1.setBounds(20,80,80,40);
b2.setBounds(120,80,80,40);
b3.setBounds(220,80,80,40);
JPanel p = new JPanel();
b1.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
r+=10;
r = r>255?0:r;
p.setBackground(new Color(r,b,g));
}
});
b2.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
b+=10;
b = b>255?0:b;
p.setBackground(new Color(r,b,g));
}
});
b3.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
g+=10;
g = g>255?0:g;
p.setBackground(new Color(r,b,g));
}
});
p.setLayout(null);
p.add(b1);p.add(b2);p.add(b3);
f.add(p);
}
}关于GUI部分的解析，部分参考自Java期末复习题之GUI-CSDN博客
