1、交通工具类（vehicle）
成员变量：
类型（vType) String类型 如： 小型车、大型车
载客人数(vNum) int类型 如： 20
构造方法：
构造方法（1），输出“创建了一个交通工具”；
构造方法（2），调用构造方法（1），并通过形参初始化类型（vType)和载客人数(vNum)；
普通方法：
设置get和set方法用于获取和设置类中各个变量的值；
重写Equals方法，当且仅当类型（vType)和载客人数(vNum) 均相等时，即为同一交通工具。
重写toString方法，返回类型（vType)和载客人数(vNum)的信息
样式如下：类型：小型车，载客人数：20
2、计费接口（Charge）
成员方法：
billingMethods( )，用于输出不同类型交通工具的不同计费方式，如：
公交车计费方式：
一元****/****张（不计公里数）
3、公交车类（Bus）
继承vehicle类
实现Charge接口
成员变量：
线路号（bNo） String类型 如：5路、4路
线路（line） String类型 如：科技学院—火车站
构造方法：
先调用父类构造方法（2）初始化类型（vType)和载客人数(vNum)，再初始化线路号（bNo）和线路（line）。
普通方法：
重写billingMethods( )方法。
定义showBus（）方法，用于输出Bus对象的所有信息（父类和子类）
4、通过main函数测试。
创建两个vehicle对象v1和v2，分别输出v1和v2，并调用其equals方法判断两个对象是否相等；
创建一个Bus对象，调用其showBus（）方法和billingMethods( )方法。
1、程序代码：
//*************交通工具类********************
public class Vehicle {
private String vType;
private int vNum;
public Vehicle(){
System.out.println("创建了一个交通工具");
}
public Vehicle(String vType,int vNum) {
this();
this.vType = vType;
this.vNum = vNum;
}
public String getvType() {
return vType;
}
public void setvType(String vType) {
this.vType = vType;
}
public int getvNum() {
return vNum;
}
public void setvNum(int vNum) {
this.vNum = vNum;
}
public boolean equals(Object obj) {
// 判断当前对象和传递的对象，如果是同一个对象直接通过
if (this == obj) {
return true;
}
// 判断传递进来的对象是否是Vehicle类型,不是的话直接pass
if (!(obj instanceof Vehicle)) {
return false;
}
// 将obj向下转型为Vehicle引用，可以访问Vehicle特有内容，否则只能访问共有内容
Vehicle v = (Vehicle) obj;
return this.vType == v.vType && this.vNum == v.vNum;
}
@Override
public String toString() {
return "Vehicle{" +
"类型：'" + vType + '\'' +
",载客人数：" + vNum +
'}';
}
}
//***************Charge接口*****************
interface Charge{
public abstract void billingMethods();
}
//*************公交车类*********************
class Bus extends Vehicle implements Charge{
private String line;
private String bNo;
public String getbNo() {
return bNo;
}
public void setbNo(String bNo) {
this.bNo = bNo;
}
public String getLine() {
return line;
}
public void setLine(String line) {
this.line = line;
}
public Bus(String vType,int vNum,String bNo,String line) {
super(vType,vNum);
this.bNo = bNo;
this.line = line;
}
public void billingMethods(){
System.out.println("一元/张（不计公里数）");
}
public void showBus(){
System.out.println("类型："+this.getvType());
System.out.println("载客人数"+this.getvNum());
System.out.println("线路号："+this.bNo);
System.out.println("线路："+this.line);
}
public static void main(String[] args){
//创建两个交通工具对象
Vehicle v1=new Vehicle("火车",1209);
Vehicle v2=new Vehicle("客机",235);
System.out.println(v1.toString());
System.out.println(v2.toString());
System.out.println("两个对象是否相等:"+v1.equals(v2));
//创建一个公交车类
Bus bus=new Bus("公交车",34,"K5","8848");
bus. showBus();
bus.billingMethods();
}
}
测试结果：
2、程序解析：
（1）用到的知识点：
a、类的创建（成员变量与成员方法的创建，构造方法，方法的重写）
b、类的继承（extends）
c、接口的创建与实现（implements）
d、方法的重写（equals（）方法和toString（）方法）
（2）程序解析：
a、交通工具类：
创建该类的目的是被后面的Bus类所继承。
equals方法是对两个对象的内存地址的比较，无实际意义。因此，需要子类重写equals方法。用于比较两个对象的值是否相等
toString方法如果不重写的话返回对象的内存地址，没有实际意义，因此需要进行重写返回对象的信息。
public class Vehicle {
//成员变量用private修饰，不允许外界（Vehicle类外）直接访问，但是此类内部可直接访问，保证了安全性
private String vType;
private int vNum;
//定义构造方法（一种特殊的方法）：
//方法名与类名相同
//无返回值，但是不能加void。
public Vehicle(){
System.out.println("创建了一个交通工具");
}
public Vehicle(String vType,int vNum) {
//调用本类的构造方法用this关键字
this();//调用本类无参的构造方法
this.vType = vType;
this.vNum = vNum;
}
public String getvType() {
return vType;
}//创建getvType方法目的是提供给外界获取本类的成员变量的值的路径，因为成员变量为Private，但是此方法为Public
public void setvType(String vType) {
this.vType = vType;
}//创建setvType方法目的是提供给外界修改本类的成员变量的值的路径，因为成员变量为Private，但是此方法为Public
public int getvNum() {
return vNum;
}
public void setvNum(int vNum) {
this.vNum = vNum;
}
public boolean equals(Object obj) {
// 判断当前对象和传递的对象，如果是同一个对象直接通过
if (this == obj) {
return true;
}
// 判断传递进来的对象是否是Vehicle类型,不是的话直接pass
if (!(obj instanceof Vehicle)) {
return false;
}
// 将obj向下转型为Vehicle引用，可以访问Vehicle特有内容，否则只能访问共有内容
Vehicle v = (Vehicle) obj;
//将比较的结果返回
return this.vType == v.vType && this.vNum == v.vNum;
}
@Override
//返回此对象的信息
public String toString() {
return "Vehicle{" +
"类型：'" + vType + '\'' +
",载客人数：" + vNum +
'}';
}
}
b、创建计费接口：
接口：接口是比抽象类更为抽象的类，interface关键字提供了一个完全抽象的类，包含了类要实现的方法。一个接口的实现类必须实现接口所描述的所有方法，否则就必须声明为抽象类。
接口的特点：
成员变量：必须是静态的，且必须要赋初值，改制不能再被修改。默认修饰符为：public static final
成员方法：为抽象的，public abstarct 可以省略，接口中不能有一般方法。
interface Charge{
public abstract void billingMethods();
}
c、公交车类：
class Bus extends Vehicle implements Charge{
private String line;
private String bNo;
public String getbNo() {
return bNo;
}
public void setbNo(String bNo) {
this.bNo = bNo;
}
public String getLine() {
return line;
}
public void setLine(String line) {
this.line = line;
}
public Bus(String vType,int vNum,String bNo,String line) {
//子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。在子类的构造方法中可使用语句 super(参数列表) 调用父类的构造方法
super(vType,vNum);
this.bNo = bNo;
this.line = line;
}
//实现接口中的方法
public void billingMethods(){
System.out.println("一元/张（不计公里数）");
}
public void showBus(){
System.out.println("类型："+this.getvType());//Bus类在交通工具类外，需要用getvType()获取值
System.out.println("载客人数"+this.getvNum());
System.out.println("线路号："+this.bNo);
System.out.println("线路："+this.line);
}
public static void main(String[] args){
Vehicle v1=new Vehicle("火车",1209);
Vehicle v2=new Vehicle("客机",235);
System.out.println(v1.toString());
System.out.println(v2.toString());
System.out.println("两个对象是否相等:"+v1.equals(v2));
Bus bus=new Bus("公交车",34,"K5","8848");
bus.showBus();
bus.billingMethods();
}
}
二、创建长方形类和长方体类求长方体的底面积和体积：
public class REctangle {
private double width;
private double length;
public REctangle(double width, double length) {
this.length = length;
this.width = width;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
public void area() {
System.out.println("面积为：" + width * length);
}
}
class Cuboid extends REctangle {
private double height;
public Cuboid(double width, double length, double height) {
super(width, length);
this.height = height;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public void tiJi() {
System.out.println("体积为：" + getWidth() * getLength() * height);
}
public static void main(String[] args) {
Cuboid cuboid=new Cuboid(1,2,3);
cuboid.tiJi();
REctangle re=new REctangle(1,2);
re.area();
}
}
3、排序：
（1）冒泡排序：
A：数组直接排序：
public class Sort {
public static void main(String[] args) {
int t;
int arr[] = new int[]{1,3,5,2,65,12};//arr.length为数组的长度
for (int i = 0; i < arr.length - 1; i++) {//外层循环：从数组第一个元素开始，至倒数第二个元素,每次归位一个元素
for (int j = arr.length-1; j >i; j--) {//内层循环从最后一个元素开始
if (arr[j] < arr[j-1]) {//如果逆序，即后面的元素比前面的要小，则交换位置
t = arr[j];
arr[j] = arr[j - 1];
arr[j-1] = t;
}
}
}
for(int i=0;i<arr.length;i++)//for循环从第一个到最后一个元素依次输出
System.out.println(arr[i]);
}
}
测试结果：
B：数组输入数字后（赋值）排序：
import java.util.Scanner;
public class Sort {
public static void main(String[] args) {
int t;
int arr[] = new int[10];
Scanner sc=new Scanner(System.in);
System.out.println("请输入十个整数");
for(int i=0;i<10;i++) {
arr[i]=sc.nextInt();
}
for (int i = 0; i < arr.length - 1; i++) {
for (int j = arr.length-1; j >i; j--) {
if (arr[j] < arr[j-1]) {
t = arr[j];
arr[j] = arr[j - 1];
arr[j-1] = t;
}
}
}
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
}
（2）选择排序：
A：
public class Sort {
public static void main(String[] args) {
int i,j,k,tmp;
int arr[] = new int[]{1,3,5,2,65,12};
for(i=0;i<arr.length-1;i++){
k=i;//k用来记录每次排序后最小元素的下标,默认为无序区域的第一个元素
for(j=i+1;j<arr.length;j++)
if(arr[j]<arr[k])//如果存在比a[k]小的数字
k=j;//将j位置信息记录下来，直到末尾，即k为从（i+1）到末尾的所有数字的最小值的元素位置
if(k!=j){//K!=J证明无序区域的第一个元素不是最小的，后面还有比它还要小的元素，则进行交换，有序区域元素个数增加
tmp=arr[i];
arr[i]=arr[k];
arr[k]=tmp;
} }
for(i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
}
测试结果：
B：输入数字后排序：
import java.util.Scanner;
public class Sort {
public static void main(String[] args) {
int i,j,k,tmp;
int arr[] = new int[10];
Scanner sc=new Scanner(System.in);
System.out.println("请输入十个整数");
for(i=0;i<10;i++) {
arr[i]=sc.nextInt();
}
for(i=0;i<arr.length-1;i++){
k=i;
for(j=i+1;j<arr.length;j++)
if(arr[j]<arr[k])
k=j;
if(k!=j){
tmp=arr[i];
arr[i]=arr[k];
arr[k]=tmp;
} }
for(i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
}
