一、第一题

请创建一个Animal动物类，要求有方法eat（）方法，方法输出一条语句“吃东西”。 创建一个接口A，接口里有一个抽象方法fly（）。创建一个Bird类继承Animal类并实现 接口A里的方法输出一条有语句“鸟儿飞翔”，重写eat（）方法输出一条语句“鸟儿 吃虫”。在Test类中向上转型创建b对象，调用eat方法。然后向下转型调用eat（）方 法、fly（）方法。

评分标准：
正确写出Animal类10分
正确定义接口A 10分
Bird类继承Animal类实现接口A 10分
向上转型创建对象b调用eat（）方法正确输出 10分
向下转型调用eat（）方法、fly（）方法正确输出 10分。

答案：

Animal.java：

A.java：

Bird.java：

Bird.java：

二、第二题

编写一个Person抽象类，要求含有姓名（name）年龄（age）两个私有属性以及吃饭（eat） 和睡觉（sleep）两个抽象方法，并写出带参构造方法，创建学生（student）和工人（worker） 两个类，继承Person类，学生类多出了私有属性学号和学习方法（输出我爱学习），工 人类多出了私有属性工号和工作方法（输出我爱工作），在主函数中创建学生和工人类 的实例对象，使用构造方法赋值，并输出所有属性和方法（共50分，能够定义类5分， 正确书写子父类构造方法1分，set get写对10分，方法重写10分，正确创建对象10 分，能运行5分）

显示结果如下：
姓名：李四，年龄：18，学号：1024
食堂吃饭
我爱学习
姓名：张三，年龄：20，工号：1025
自己做饭
在家躺着睡觉
我爱工作

Person.java：

Student.java：


Worker.java：

Mains.java：

三、第三题

利用继承，来描述，人，老师，学生之间的关系
1）老师含有属性：name，age，subject，含有方法：eat，teach，toString
2）学生含有属性：name，age，class，含有方法：eat，study，toString
3）利用继承的思想，从老师和学生中抽象出人，并创建Test进行调用并输出（System.out）

判分标准：
1）创建类Person，含有公有属性：name姓名，age年龄。含有方法void eat(String something)；方法中打印输出“我爱吃XXX”。含有构造方法，带两个参数，分别是name和age，并利用this关键字传值到成员变量中 	。（10分）
2）创建类Student，含有属性：class班级，含有方法，void study(String subject)；方法打印输出：我热爱学习subject。创建包含三个参数的构造方法，分别是name，age，class，利用super实现父类构造方法传值。重写toString方法，打印输出：我的名字是XX，我的年龄是XX，我的班级是XX（10分）
3）创建类Teacher，含有属性：subject，含有方法，void teach()；方法打印输出：我教授的是subject。创建包含三个参数的构造方法，分别是name，age，subject，利用super实现父类构造方法传值。重写toString方法，打印输出：我的名字是XX，我的年龄是XX（10分）
4）创建Test测试类，创建Student对象，并调用带3个参数的构造方法，自己赋值，然后依次调用study方法，eat方法，toString方法（20分）
5）创建Teacher对象，并调用带3个参数的构造方法，自己赋值，然后依次调用teach方法，eat方法，toString方法（10分）

Person.java：


Student.java：

Teacher.java：

Test.java：

四、第四题

需求：首先定义一个抽象类Animal,抽象类中定义一个抽象方法play（）抽象方法，创建 一个猫Cat类，继承Animal并重写play方法输出“我是猫，我玩老鼠”，创建一个狗类， 继承Animal并重写play方法输出“我是狗，我玩球”。最后编写测试类TestDemo，通 过多态创建猫，通过多态创建狗，并调用猫对象的play方，狗对象的play方法

效果如图：
	我是猫，我玩老鼠		
	我是狗，我玩球
评分标准
1）创建Animal抽象类，并定义抽象方法play.（10）
2）创建Dog类继承Animal类，重写play方法。（10）
3）创建Cat类继承Animal类，重写play方法。（10）
4）编写测试类，通过多态创建猫对象，狗对象（15）

Animal.java：

Cat.java：

Dog.java：

Test.java：

五、第五题

请创建一个Car抽象类，要求有brand（品牌）属性，并且要求封装私有化，写出属性的 set、get方法。抽象类Car构造方法中也可以对brand属性赋值，写出一个抽象方法run （）。创建一个跑车类SportsCar继承抽象类Car。实现Car抽象方法输出一条语句“超 级跑车”，在本类中写出一个自己的方法price（），输出一条语句“售价100w”。在测 试类Test类中创建跑车对象car1，用构造器赋值品牌属性，输出属性，调用run（）、 price（）方法。创建跑车car2，用set方法赋值属性，输出属性，调用run（）、price （）方法。

评分标准：
1）正确写出抽象类Car ，封装属性，写出抽象方法10分
2）封装属性，写出set、get、抽象方法 10分
3）正确继承Car类写出SportsCar类和并实现run（） 方法。10分
4）创建car1、car2对象并调用方法10分
5）成功正确输出 10分
显示结果如下：
	法拉利
	超级跑车
	售价100w
	兰博基尼
	超级跑车
	售价100w

Car.java：

SportsCar.java：

Test.java：

六、第六题

完成那个USB接口的例子，分别定义USB接口，两个方法start，stop。两个子类：Flash和Print，重写两个方法，方法中随便输出两句话。定义计算机类Computer，有一个plugin方法，有一个USB类型的参数，用来调用start和stop。在主方法中实例化Computer类，调用plugin方法，分别传递Flash和Print的对象，通过向上转型，完成功能。

注意：因为从键盘输入我们还没有学习，所以上面若提到使用键盘输入，改为在程序中随意定义几个值（如果会键盘输入那就使用键盘输入）

USB.java：

Print.java：

Flash.java：

Computer.java：

Mains.java：

七、第七题

（1）请创建一个Car抽象类，要求有brand（品牌）属性，并且要求封装私有化，写出属性的 set、get方法。抽象类Car构造方法中对brand属性赋值，写出一个抽象方法run（）。（2）创建一个跑车类SportsCar继承抽象类Car。实现Car抽象方法输出一条语句“超级跑车”，在本类中写出一个自己的方法price（），输出一条语句“售价100w”。（10分）
（3）定义测试类Test类，并创建跑车对象car1，用构造器赋值品牌属性，使用setter方法输出属性值，再调用run（）、 price（）方法。 （10分）
（4）创建跑车car2，向上转型到Car，使用setter方法为brand赋值属性，输出属性值，调用run（）方法。（10分）

Car.java：

package kaoshi_1;

public abstract class Car {
	private String brand;

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public Car(String brand) {
		this.brand=brand;
	}
	
	public Car() {
		
	}
	public abstract void run();
}

SportCar.java：

package kaoshi_1;

public class SportCar extends Car {

	public void run() {
		System.out.println("超级跑车");
	}
	public SportCar(String brand) {
		super(brand);
	}
	public void price() {
		System.out.println("售价100w");
	}
	public SportCar() {
		
	}
}

Test.java：

package kaoshi_1;

public class Test {
	public static void main(String[] args) {
		SportCar car1 = new SportCar("奥迪A6");
		System.out.println(car1.getBrand());
		car1.run();
		car1.price();
		
		Car car2 = new SportCar();
		car2.setBrand("玛莎拉蒂");
		System.out.println(car2.getBrand());
		car2.run();
	}
}

八、第八题

（1）定义一个Flower花作为父类
属性：颜色 价格
属性要进行封装（即为每条私有属性写set，get方法）
定义无参构造方法，和传两个参数的有参构造方法一个。
方法：显示详细信息的方法showInfo （15分）
（2）定义一个Rose玫瑰花类继承Flower类
玫瑰花自己的属性：产地（要求对产地属性进行封装 私有化属性）
重写父类中的显示详细信息的方法showInfo，在重写的showInfo方法中通过super调用父类的showInfo方法；并显示产地信息。
再定义一个方法warn警告显示：不要摘玫瑰花，小心扎手！ （15分）
（3）定义测试类Test完成：（10分）
①实例化Flower类，调用构造方法赋值，并调用方法，输出：
花的颜色是白色，价格是10元
②实例化玫瑰花类，调用方法，输出：
花的颜色是紫色，价格是30元
产地是大理
不要摘玫瑰花，小心扎手！

Flower.java：

package kaoshi_1;

public class Flower {
	private String color;
	private String price;
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public String getPrice() {
		return price;
	}
	public void setPrice(String price) {
		this.price = price;
	}
	public Flower() {
		
	}
	public Flower(String color,String price) {
		this.color=color;
		this.price=price;
	}
	public void showInfo() {
		System.out.println("花的颜色是"+this.color+",价格是"+this.price+"元");
	}
}

Rose.java：

package kaoshi_1;

public class Rose extends Flower {
	private String address;
	
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public void showInfo() {
		super.showInfo();
		System.out.println("产地是"+this.address);
	}
	public void warn() {
		System.out.println("不要摘玫瑰花，小心扎手！");
	}
	public Rose() {
		
	}
	public Rose(String color,String price,String address) {
		super(color,price);
		this.address=address;
	}
}

Test2.java：

package kaoshi_1;

public class Test2 {
	public static void main(String[] args) {
		Flower f=new Flower("白色","10");
		f.showInfo();
		
		Rose r=new Rose("紫色","30","大理");
		r.showInfo();
		r.warn();
	}
}

九、第九题

（1）首先定义一个程序员的接口Programmer,接口中定义一个抽象方法ACode（）； （10分）
（2）创建一个Student类，实现接口Programmer并实现ACode（）方法，ACode（）方法可输出输出“程序员在敲代码”， Student类有年龄，姓名，班级，性别私有属性（封装），各个属性的set，get方法，写空参构造方法，和一个有参构造方法包含这四个属性。 （10分）
（3）定义测试类，在main方法中创建一个Student对象，将自己的年龄，姓名，班级，性别，赋值给这个对象，并在控制台打印出对象的各个属性。调用所有的方法。（10分）

效果如图：

程序员在敲代码
  姓名：孙悟空  性别：女  年龄：19  班级：三年级二班 

Programmer.java：

package kaoshi_1;

public interface Programmer {
	public abstract void ACode();
}

Student.java：

package kaoshi_1;

public class Student implements Programmer {
	private int age;
	private String name;
	private String clas;
	private String sex;
	public void ACode() {
		System.out.println("程序员在敲代码");
	}
	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 getClas() {
		return clas;
	}
	public void setClas(String clas) {
		this.clas = clas;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Student() {
		
	}
	public Student(int age,String name,String clas,String sex) {
		this.age=age;
		this.name=name;
		this.clas=clas;
		this.sex=sex;
	}
}

Test3.java：

package kaoshi_1;

public class Test3 {

	public static void main(String[] args) {
		Student s=new Student(19,"孙悟空","三年级二班","女");
		s.ACode();
		System.out.println("姓名："+s.getName()+"，性别"+s.getSex()+"，年龄："+s.getAge()+"，班级："+s.getClas());
	}
}

第1题

案例：

声明一个日期类MyDate，包含属性：年、月、日

声明一个Test02测试类，并在main方法中，创建3个日期对象，一个是你的出生日期，一个是随机定义的日期，一个是今年过年的日期，并打印显示

系统预定义的日期类型。jdk1.8+提供了2套日期类型

java.util.Date

public class Date implements java.io.Serializable,Cloneable,
Comparable<Date>{
    private transient long fastTime;  //具体的日期是采用从1970-1-1 0：0：0 到指定日期的毫秒值进行存储。  年-1900  月-1
}

自定义类

public class MyDate{  //默认继承于java.lang.Object类，不需要import语句导入。
    int year;   //成员属性  范围限定词默认为package，只是同包可见
    int month;
    int date;
    public void setYear(int year){  //方法名称命名的规则为小写字母开头，大写字母分词
        this.year = year;  
    }
    public String toString(){
        return year + "年" + month + "月" + date + "日";
    }
}

测试类

public class Test02{
    public static void main(String[] args){
        MyDate d1 = new MyDate();
        d1.year = 1972;
        d1.month = 4;
        d1.date = 30;
        System.out.println(d1.toString());
    }
}

第2题

案例：

声明公民类Citizen，包含属性：姓名，生日，身份证号，其中姓名是String类型，生日是MyDate类型，身份证号也是String类型。

声明Test03测试类，在main方法中创建你们家庭成员的几个对象，并打印信息。

public class Citizen{
    protected String name;
    public MyDate birth;
    private String ID;
​    
    //私有属性添加get/set方法访问
    public String getID() {
        return ID;
    }
​
    public void setID(String iD) {
        ID = iD;
    }
​
    public String toString() {
        return "家庭成员 " + "姓名：" + name + " 出生日期：" + birth + " 身份证号：" + this.ID;
    }
}

测试类

public class Test03 {
    public static void main(String[] args) {
        Citizen citizen  = new Citizen();
        citizen.name = "张三";
        MyDate mydate = new MyDate();
        mydate .setYear(2021);
        mydate .setMonth(03);
        mydate .setDate(06);
        citizen.birth = d1;
        citizen.setID("123456789");
        System.out.println(citizen.toString());
    }
​
}

第3题

案例：

声明一个日期类MyDate，包含属性：年、月、日，并在MyDate类中声明几个方法：

1、boolean isLeapYear()：判断当前日期的是闰年吗？

2、void set(int y, int m, int d)：修改年，月，日为新日期

3、void puls(int years, int months, int days)：加上years年，months月，days天后的日期

并在测试类Test04的main方法中创建对象，并调用测试

public class MyDate{
    private int year;
    private int month;
    private int date;
    
    //判断当前日期是否是闰年
    public boolean isLeapYear(){
        if(year % 4 == 0 && year / 100 !=0)
            return ture;
        else if(year % 400 == 0)
            return true;
        else
            return false;
    }
    
    //修改年，月，日为新日期
    public void set(int y,int m, int d){
        year = y;
        month = m;
        date = d;  
    }
    //加上years年，months月，days天后的日期
    public void puls(int years, int months, int days){
        this.year += years;
        this.date += days;
        this.month += months;
        if (this.month > 12) {
            this.year++;
            this.month -= 12;
        }
        //这里得判断加完的月份值是否超过12，天数是否超过本月的天数
        //如果超过则月份和天数做出相应的变化
        //2月有闰年的存在  所以需要单独进行判断
        //特殊12月  如果超出则需要对年进行修稿
        while (true) {
            if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10) {
                if (date > 31) {
                    date -= 31;
                    month++;
                } else
                    break;
            } else if (month == 4 || month == 6 || month == 9 || month == 11) {
                if (date > 30) {
                    date -= 30;
                    month++;
                } else
                    break;
            } else if (month == 2) {
                //调用当前类中的方法  判断是否是闰年
                if (isLeapYear()) {
                    if (date > 28) {
                        date -= 28;
                        month++;
​
                    } else
                        break;
                } else if (date > 29) {
                    date -= 29;
                    month++;
                } else
                    break;
            } else if (month == 12) {
                if (date > 31) {
                    date -= 31;
                    month = 1;
                    year++;
                }
            }
        }
    }
}

测试类

public class Test04 {
	public static void main(String[] args) {
		MyDate date = new MyDate();
         //调用方法 修改年，月，日为新日期
		date.set(2001, 3, 6);
		System.out.println(date);
         // 判断是否为闰年
         System.out.println(date.isLeapYear());
		//加上years年，months月，days天后的日期
         date.puls(20, 9, 3);
		System.out.println(date);
	}

}

第4题

案例：

声明一个三角形类Triangle，包含属性：a,b,c，表示三条边，包含几个方法：

1、boolean isRightTriangle()：判断是否是一个直角三角形

2、boolean isIsoscelesTriangle()：判断是否是一个等腰三角形

3、boolean isEquilateralTriangle()：判断是否是一个等边三角形

4、double getArea()：根据三条边，用海伦公式求面积

5、double getLength()：求周长

并在测试类Test05的main方法中调用测试

public class Triangle {
    private double a;
    private double b;
    private double c;
​
    // 判断是否为直角三角形
    public boolean isRightTriangle() {
        // 首先判断值的合法性
        if (a > 0 && b > 0 && c > 0) {
            // 判断是否构成三角形
            if (a + b > c && a + c > b && b + c > a) {
                // 判断是否为直角三角形
                if (a * a == b * b + c * c || b * b == a * a + c * c || c * c == a * a + b * b) {
                    return true;
                }
            }
        }
        return false;
    }
​
    // 判断是否为等腰三角形
    public boolean islsoscelesTriangle() {
        // 判断值的合法性
        if (a > 0 && b > 0 && c > 0) {
            // 判断是否能构成三角形
            if (a + b > c && a + c > b && b + c > a) {
                // 判断是否为等腰三角形
                if (a == b || b == c || a == c) {
                    return true;
                }
            }
        }
        return false;
​
    }
    
    //判断是否为等边三角形
    public boolean isEquilateralTriangle() {
        // 判断值的合法性
        if (a > 0 && b > 0 && c > 0) {
            // 判断是否能构成三角形
            if (a + b > c && a + c > b && b + c > a) {
                // 判断是否为等边三角形
                if (a == b && b == c) {
                    return true;
                }
            }
        }
        return false;
    }
    
    //计算三角形的周长
    public double getLength() {
        // 判断值的合法性
        if (a > 0 && b > 0 && c > 0) {
            // 判断是否能构成三角形
            if (a + b > c && a + c > b && b + c > a) {
                return (a + b + c);
            }
        }
        return -1;
    }
    
    //计算三角形的面积（利用海伦公式）
    public double getArea() {
        // 判断值的合法性
        if (a > 0 && b > 0 && c > 0) {
            // 判断是否能构成三角形
            if (a + b > c && a + c > b && b + c > a) {
                double p = (a + b + c) / 2;
                double q = (p * (p - a) * (p - b) * (p - c));
                return Math.sqrt(q);
            }
        }
        return -1;
    }
    
    //私有类外访问  添加get/set方法
    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 class Test05 {
    public static void main(String[] args) {
        Triangle triangle  = new Triangle();  //调用无参构造器
         // 私有属性通过set方法修改值  get方法获取
        triangle.setA(3.); 
        triangle.setB(4.);
        triangle.setC(5.);
         //通过对象名.方法名调用方法
        System.out.println("是否为等边三角形："+triangle.isEquilateralTriangle());
        System.out.println("是否为等腰三角形："+triangle.islsoscelesTriangle());
        System.out.println("是否为直角三角形："+triangle.isRightTriangle());
        System.out.println("面积为："+triangle.getArea());
        System.out.println("周长为："+triangle.getLength());
    }
​
}

第5题

工具类的概念和static方法

定义对象的目标是为了封装数据和数据相关操作，同一个类属的对象相互堵路

public class A{
 public void pp(){}
}
/*  在测试类中
 *  正常调用方法pp: new A().pp();
 *  不能  A.pp();
 *  在类A内部可以直接调用
 */
public class A{
    public void pp() {}
    public void cc() {
        pp();   //允许方法之间相互调用
    }
}
​

工具类中只有操作，没有数据的封装，则可以定义访问为static静态的。静态方法不需要创建对象在进行调用

public class A{
    public static void pp(){}
}
/*
 * 在测试类中
 * 通过 A.pp()进行调用  也可以使用new A().pp();  但是不建议
 */

案例：

声明一个数学计算工具类MathTools，包含如下方法：

1、int add(int a, int b)：求a+b

2、int subtract(int a,int b)：求a-b

3、int mutiply(int a, int b)：求a*b

4、int divide(int a, int b)：求a/b

5、int remainder(int a, int b)：求a%b

6、int max(int a, int b)：求a和b中的最大值

7、int min(int a, int b)：求a和b中的最小值

8、boolean equals(int a, int b)：判断a和b是否相等

9、boolean isEven(int a)：判断a是否是偶数

10、boolean isPrimeNumer(int a)：判断a是否是素数

11、int round(double d)：返回d的四舍五入后的整数值

public class MathTools {
    // 如果没有定义构造器 系统默认提供无参构造器
    // 如果自定义构造器 那么应该提供无参构造器（建议做法）
    public MathTools() {
    }
​
    // a+b
    public static int add(int a, int b) {
        int c = a + b;
        return c;
    }
​
    // a-b
    public static int subtract(int a, int b) {
        int c = a - b;
        return c;
    }
​
    // a*b
    public static int mutiply(int a, int b) {
        int c = a * b;
        return c;
    }
​
    // a%b
    public static int remainder(int a, int b) {
        int c = a % b;
        return c;
    }
​
    // a和b中的最大值
    public static int Max(int a, int b) {
        int c = Math.max(a, b);
        return c;
    }
​
    // a和b中的最小值
    public static int Min(int a, int b) {
        int c = Math.min(a, b);
        return c;
    }
​
    // 判断a和b是否相等
    public static boolean equals(int a, int b) {
        if (a == b) {
            return true;
        }
        return false;
    }
​
    // 判断a是否是偶数
    public static boolean isEven(int a) {
        if (a % 2 == 0) {
            return true;
        }
        return false;
    }
​
    // 返回四舍五入后的整数值
    public static int round(double a) {
        // 传入的参数为double类型 所以需要进行窄化操作
        int c = (int) Math.round(a);
        return c;
    }
​
    // a/b
    public static int Divide(int a, int b) {
        int c = a / b;
        return c;
    }
​
    // 判断a是否是素数
    public boolean isPrimeNumber(int a) {
        int count = 0;
        for (int i = 2; i < a; i++) {
            if (a % i == 0) {
                count++;
                break;
            }
        }
        if (count == 0)
            return true;
        else
            return false;
    }
}

声明一个Test06测试类，并在main方法中调用测试

public class Test06 {
    public static void main(String[] args) {
        new MathTools();
        // 调用方法 判断是否为素数
        boolean res = MathTools.isPrimeNumber(13);
        System.out.println(res);
        // 两数和
        int sum = MathTools.add(2, 3);
        System.out.println(sum);
        // 四舍五入
        int digital = MathTools.round(18.2);
        System.out.println(digital);
    }
}

第6题

案例：练习排序算法和折半查找法以及System.arrayCopy方法

声明一个数组管理工具类MyArrays，包含如下方法：

1、void sort(int[] arr)：可以为任意一维整型数组arr实现从小到大排序

2、int indexOf(int[] arr, int value)：可以在任意一维整型数组arr中查找value值的下标，如果不存在返回-1

3、int[] copy(int[] arr, int len)：可以实现从任意一维数组arr中复制一个新数组返回，新数组的长度为len，从arr[0]开始复制

import java.util.Arrays;
​
public class MyArrays {
    // 定义方法 利用冒泡排序对数组进行排序(自然排序)
    public static void sort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int k = 0; k < arr.length - i; k++) {
                if (arr[k] > arr[k + 1]) {
                    int temp = arr[k + 1];
                    arr[k + 1] = arr[k];
                    arr[k] = temp;
                }
            }
        }
    }
​
    // 在任意一维整型数组arr中查找value值的下标，如果不存在返回-1
    public static int indexOf(int[] arr, int value) {
        sort(arr); // 折半查找的前提是有序的  所以调用冒泡排序对数组进行排序
        return binarySearch(arr, value, 0, arr.length - 1);//利用折半查找的方法寻找value值的下标
    }
​
    // 折半查找
    public static int binarySearch(int[] arr, int target, int begin, int end) {
        if (begin > end)
            return -1;
        int mid = (begin + end) / 2;
        if (arr[mid] < target) {
            begin = mid + 1;
        } else if (arr[mid] > target) {
            end = mid - 1;
        } else
            return mid;
        return binarySearch(arr, target, begin, end); // 调用自身
    }
​
    // 实现从任意一维数组arr中复制一个新数组返回，新数组的长度为len，从arr[0]开始复制
    public static int[] copy(int[] arr, int len) {
        int[] res = new int[len];
        int newLen = Math.min(len, arr.length);
        System.arraycopy(arr, 0, res, 0, newLen);
        return res;
    }
​
    // 输出数组
    public static void showArray(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

声明一个Test07测试类，并在main方法中调用测试

import java.util.Arrays;
import java.util.Random;
​
public class Test07 {
​
    public static void main(String[] args) {
        Random random = new Random();
        // 生成[10,20)以内的随机数(int类型)
        int[] arr = new int[random.nextInt(10) + 10];
        // 生成随机数组
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
        }
        new MyArrays();
        // 调用静态方法 冒泡排序
        MyArrays.sort(arr);
        // 调用方法输出数组
        MyArrays.showArray(arr);
        int[] arr1 = new int[] { 6, 2, 1, 3, 8, 4, 56, 7, 9 };
        // 调用方法 寻找value=56的下标
        int temp = MyArrays.indexOf(arr1, 56);
        System.out.println("数组中56的下标为：" + temp);
        // 实现数组的复制
        int[] res = MyArrays.copy(arr, 10);
        System.out.println("复制后的数组为：" + Arrays.toString(res));
    }
​
}

​

第7题

案例：

声明一个常识工具类DateCommonsTools，包含如下方法：

1、String getWeekName(int week)：根据星期值，返回对应的英语单词

2、String getMonthName(int month)：根据月份值，返回对应的英语单词

3、int getTotalDaysOfMonth(int year, int month)：返回某月的总天数

4、int getTotalDaysOfYear(int year)：获取某年的总天数

5、boolean isLeapYear(int year)：判断某年是否是闰年

public class DateCommonsTools {
//根据星期值，返回对应的英语单词
    public String getWeekName(int week) {
​
        String[] arr = new String[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Staurday", "Sunday" };
        if (week < 7 && week > 0)
            return arr[week];
        else
            return "输入有误！";
    }
​
//根据月份值，返回对应的英语单词
    public String getMonthName(int month) {
        String[] arr = new String[] { "January", "February", "March", "April", "May", "June", "July", "Auguet",
                "September", "October", "November", "December" };
        if (month > 0 && month < 13)
            return arr[month];
        else
            return "";
    }
​
//返回某年某月的总天数
    public int getTotalDaysOfMonth(int year, int month) {
        int res = 0;
        if (month > 0 && month < 32) {
            switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                res = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                res = 30;
                break;
            case 2:
                if (isLeapYear(year))
                    res = 28;
                else
                    res = 29;
                break;
            default:
                System.out.println("输入有误！");
            }
        }
        return res;
    }
​
//获取某年的总天数
    public int getTotalDaysOfYear(int year) {
        if (isLeapYear(year))
            return 366;
        else
            return 356;
    }
​
//判断是否为闰年
    private static boolean isLeapYear(int year) {
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
            return true;
        else
            return false;
​
    }
}

声明一个Test08测试类，并在main方法中调用测试

public class Test08 {
    public static void main(String[] args) {
        new DateCommonsTools();
        String WeekName = DateCommonsTools.getWeekName(2);
        System.out.println(WeekName);
        String MonthName = DateCommonsTools.getMonthName(10);
        System.out.println(MonthName);
        int MonthNum = DateCommonsTools.getTotalDaysOfMonth(2020, 2);
        System.out.println(MonthNum);
        int YearNum = DateCommonsTools.getTotalDaysOfYear(2020);
        System.out.println(YearNum);
    }
​
}

学了面向对象,我们来做几道基础题

面向对象基础

1、定义一个点类Point，包含2个成员变量x、y分别表示x和y坐标，2个构造器Point()和Point(int x0,y0),以及一个movePoint（int dx,int dy）方法实现点的位置移动，创建两个Point对象p1、p2，分别调用movePoint方法后，打印p1和p2的坐标。

代码演示

public class Point {
	
	//成员变量
	private double x;
	private double y;
	
	//每一个类都带有一个默认的无参构造函数
	public Point() {
		super(); //表示父类的构造函数
		
		/*
		 * 	1.构造函数与类名完全一致
		 * 	2.不能带有返回值类型
		 * 	3.不需要return语句
		 * 
		 * 	作用:创建对象
		 */
	}
	public Point(int x0,int y0) {
		this.x=x0;
		this.y=y0;
	}
	
	public void movePoint(int dx,int dy) {
		this.x+=dx;
		this.y+=dy;
	}
	
	public static void main(String[] args) {
		Point p1 = new Point (2,4);
		p1.movePoint(2, 4);
		System.out.println("p1坐标为:"+p1.x+","+p1.y);
		
		Point p2 = new Point (5,8);
		p2.movePoint(50, 120);
		System.out.println("p2坐标为:"+p2.x+","+p2.y);
	}

2、定义一个矩形类Rectangle：
2.1 定义三个方法：getArea()求面积、getPer()求周长，showAll()分别在控制台输出长、宽、面积、周长。
2.2 有2个属性：长length、宽width
2.3 通过构造方法Rectangle(int width, int length)，分别给两个属性赋值
2.4 创建一个Rectangle对象，并输出相关信息

代码演示

public class Rectangle {
	
	int length;
	int width;
	
	
	/*
	 * 	static
	 * 	1.修饰变量:直接通过类名来访问
	 * 	2.修饰方法:也可以通过类名来访问
	 * 	3.修饰代码块:加载类的时候优先执行,并只执行一次
	 * 
	 * 	非静态方法可以访问静态方法和变量
	 * 	静态方法不可以访问非静态方法和变量
	 */
	
	public int getArea() {
		int area=length*width;
		return area;
	}
	
	public int getPer() {
		return (length+width)*2;
	}
	
	public void showAll() {
		int l=this.length;
		int w=this.width;
		int a=length*width;
		int p=(length+width)*2;
		System.out.println("长:"+l+","+"宽:"+w+","+"面积:"+a+","+"周长:"+p);
	}
	
	public Rectangle (int length,int width) {
		this.length=length;
		this.width=width;
	}
	
	public static void main(String[] args) {
		Rectangle r=new Rectangle(5,5);
		r.showAll();
	}

设计一个类Student，该类包括姓名、学号和成绩。设计一个方法，按照成绩从高到低的顺序输出姓名、学号和成绩信息。

代码演示

public class Student {

	String name;
	int empno;
	int grade;
	
	public Student(String name,int empno,int grade) {
		this.name=name;
		this.empno=empno;
		this.grade=grade;
	}
	
	public static void sort(Student[] s) {
		for(int i=1;i<s.length;i++) {
			for(int j=0;j<s.length-i;j++) {
				if(s[j].grade < s[j+1].grade) {
					Student t;
					t=s[j];
					s[j]=s[j+1];
					s[j+1]=t;
				}
			}
		}
	}
	
	public static void main(String[] args) {
		
		Student s1=new Student("小明", 1, 80);
		Student s2=new Student("小红", 2, 90);
		Student s3=new Student("小王", 3, 99);
		
		Student[] arr = {s1,s2,s3};
		
		sort(arr);
		
		for(Student is:arr) {
			System.out.println(is.name+"\t"+is.empno+"\t"+is.grade);
		}
		
	}

面向对象高级特性

1、创建一个球员类，并且该类最多只允许创建十一个对象。提示利
用static 和封装性来完成。

类的说明：

代码演示:

public class Players {
	private static int sum;
	
	public Players() {
		super();
		System.out.println("创建了一个对象!");
	}

	public static Players create() {
		Players players=null;
		if(sum>=11) {
			System.out.println("创建的对象以超过11个!");
		}else {
			players=new Players();
			sum++;
		}
		return players;
	}
	
	public static void main(String[] args) {
		Players[] players=new Players[11];
		for(int i=0;;i++) {
			Players p=Players.create();
			if(p==null) {
				break;
			}else {
				players[i]=p;
			}
		}
		
	}
}

结果:

2、设计2个类，要求如下：
2.1 定义一个汽车类Vehicle，
2.1.1 属性包括：汽车品牌brand（String类型）、颜色color（String类型）和速度speed（double类型）。
2.1.2 至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0）。
2.1.3 为属性提供访问器方法。注意：汽车品牌一旦初始化之后不能修改。
2.1.4 定义一个一般方法run()，用打印语句描述汽车奔跑的功能
2.1.5 在main方法中创建一个品牌为“benz”、颜色为“black”的汽车。
2.2 定义一个Vehicle类的子类轿车类Car，要求如下：
2.2.1 轿车有自己的属性载人数loader（int 类型）。
2.2.2 提供该类初始化属性的构造方法。
2.2.3 重新定义run()，用打印语句描述轿车奔跑的功能。
2.2.4 在main方法中创建一个品牌为“Honda”、颜色为“red”，载人数为2人的轿车。

代码演示:

//Vehicle 类
public class Vehicle {
	private String brand;
	private String color;
	private double speed;
	
	
	
	public String getBrand() {
		return brand;
	}
//	public void setBrand(String brand) {
//		this.brand = brand;
//	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public double getSpeed() {
		return speed;
	}
	public void setSpeed(double speed) {
		this.speed = speed;
	}
	public Vehicle() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Vehicle(String brand, String color) {
		super();
		this.brand = brand;
		this.color = color;
		this.speed = 0;
	}
	public void run() {
		System.out.println("汽车奔跑");
	
	}
	public static void main(String[] args) {
		Vehicle v = new Vehicle("benz", "black");
		System.out.println("品牌:"+v.brand+"\n颜色:"+v.color+"\n速度:"+v.speed);
		v.run();
	}
}



//Car 类
public class Car extends Vehicle{
	int loader;

	public Car(String brand,String color,int loader) {
		super(brand,color);
		this.loader=loader;
	}
	
	public void run() {
		System.out.println("品牌:"+getBrand()+"\r颜色:"+getColor()+"\r载人数:"+loader);
		System.out.println("轿车奔跑");
	}
	
	public static void main(String[] args) {
		Car c=new Car("Honda","red",2);
		c.run();
	}
}

结果:

更多内容,等待后续更新!