建了一个群：908722740 ，欢迎小伙伴门的加入，平时可以互相学习交流，不管是学习还是工作上的都可以多多交流，本人在校学生，技术有限，错误的地方欢迎指正。

目录

【1】IT从业者

【2】会议室

【3】狗

【4】卡车

【5】商品（两个类依赖）

【6】图书

【7】学生

【8】银行存户

【9】英雄和技能（两个类依赖）

【10】专业和学生（两个类依赖）

---

【1】IT从业者

要求：

1. 以面向对象的思想，编写自定义类描述IT从业者。
2. 设置属性的私有访问权限，通过公有的get，set方法实现对属性的访问
3. 限定IT从业人员必须年满15岁，无效信息需提示，并设置默认年龄为15
4. 限定“技术方向”是只读属性
5. 设计构造函数实现对属性赋值
6. 工作方法通过输入参数，接收工作单位和职务，输出个人工作信息  编写测试类，测试IT从业者类的对象及相关方法（测试数据信息自定）

参考分析思路：

IT从业者类：

属性包括：姓名，年龄，技术方向，工作年限；

方法包括：工作。

运行效果：

 源码:

public class IT {
    String name;
    private int age;
    String jishu;
    int year;

    public IT(String name, int age, String jishu, int year) {
        this.name = name;
        this.setAge(age);
        this.jishu = jishu;
        this.year = year;
    }
    public void work(String work,String zhiwu){
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("技术方向："+jishu);
        System.out.println("工作年限："+year);
        System.out.println("目前就职于："+work);
        System.out.println("职务是："+zhiwu);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {//赋值
        if (age<15){
            this.setAge(15);
            System.out.println("年龄信息无效！已修改默认年龄为15");
        }else {
            this.age=age;

        }
    }

    public String getJishu() {
        return jishu;
    }



    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}



/*

测试类
*/
public class ITTest {
    public static void main(String[] args) {
        IT it=new IT("马未龙",35,"数据库维护",10);
        it.work("腾讯实业","数据库维护工程师");
        System.out.println("=====================================");
        IT it2=new IT("张凯",10,"Java开发",1);
        it2.work("鼎盛科技","Java开发工程师");

    }
}

【2】会议室

要求：

1. 请使用面向对象的思想，编写自定义类描述会议室信息。
2. 设置属性的私有访问权限，通过公有的get，set方法实现对属 性的访问
3. 设计构造函数实现对所有属性赋值
4. 预定的方法通过输入参数，接收申请人姓名，检查会议室使用 状态，如果空闲则完成预定流程
5.  编写测试类，测试会议室类的对象及相关方法（测试数据信息 自定）

参考思路分析：

会议室类：

属性包括：会议室编号，会议室名称，使用状态（预定，空闲）；

方法包括：预定 

运行效果：

 源码：

public class MeetingRoom {
    String id;
    String name;
    String state;

    public MeetingRoom(String id, String name, String state) {
        this.id = id;
        this.name = name;
        this.state = state;
    }

    public void zhuangtai(String names){




        if (state=="预定"){
            System.out.println(name+"已被预订");
        }else {
            System.out.println(names+"成功申请"+name);
        }

    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}





/**
 * 测试类
 */
public class MeetingRoomTest {
    public static void main(String[] args) {

        MeetingRoom mt=new MeetingRoom("001","第一会议室","预定");
        System.out.println("请输入姓名");
        Scanner input=new Scanner(System.in);
        String names=input.next();
        MeetingRoom mt2=new MeetingRoom("002","第二会议室","空闲");
        mt.zhuangtai(names);
        mt2.zhuangtai(names);

    }
}

【3】狗

要求：

1. 使用面向对象的思想，编写自定义类描述狗的信息。
2. 设置属性的私有访问权限，通过公有的get，set方法实现对属性的访问
3. 限定心情只能是“心情好”和“心情不好”两种情况，如果无效需进行提示 ，默认设置“心情好”
4. 设计构造函数实现对属性赋值
5. 叫和跑的方法，需要根据心情好坏，描述不同的行为方式
6. 编写测试类，测试狗类的对象及相关方法（测试数据信息自定）

参考分析思路：

狗类：

属性包括： 品种，年龄，心情，名字；

方法包括： 叫，跑

运行效果：

源码：

public class Dog {
    private String pinzhong;
    private  int age;
    private  String xq;
    private String name;

    public Dog(String pinzhong, int age, String xq, String name) {
        this.pinzhong = pinzhong;
        this.age = age;
        this.setXq(xq);
        this.name = name;
    }

    public void call() {
        if ("心情好".equals(xq)) {
            System.out.println("名字叫" + name + "的" + pinzhong + xq + ",开心的汪汪叫");
        } else {
            System.out.println("名字叫" + name + "的" + pinzhong + xq + ",伤心的呜呜叫");
        }
    }

    public void run() {
        if ("心情好".equals(xq)) {
            System.out.println("名字叫" + name + "的" + pinzhong + xq + ",开心的为着主人身边转");
        } else {
            System.out.println("名字叫" + name + "的" + pinzhong + xq + ",伤心的一动不动");
        }
    }

    public String getPinzhong() {
        return pinzhong;
    }

    public void setPinzhong(String pinzhong) {
        this.pinzhong = pinzhong;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getXq() {
        return xq;
    }

    public void setXq(String xq) {
        if ("心情好".equals(xq) || "心情不好".equals(xq)) {
            this.xq = xq;
        } else {
            System.out.println("输入信息有误，这只狗狗今天心情很好");
            this.xq = "心情好";
        }

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}




/**
 * 测试类
 */
public class DogTest {
    public static void main(String[] args) {
        Dog d=new Dog("贵宾犬",8,"心情一般好","甜心");
        d.run();
        d.call();
        System.out.println("===================================");
        Dog d2=new Dog("德国牧羊犬",9,"心情一般好","太子");
        d2.run();
        d2.call();


    }
}

【4】卡车

要求：

1. 请用面向对象的思想设计卡车类。
2. 设置属性的私有访问权限，通过公有的get，set方法实现对属 性的访问
3. 租赁方法通过输入参数，接收租车人姓名和租赁时间，描述租 赁状态，要求判断租赁时间的有效性
4. 设计构造函数实现属性赋值
5.  编写测试类，测试卡车类的对象及相关方法（测试数据信息自定）

参考分析思路：

卡车类：

属性包括：车牌号、车型、颜色、日租金、载重量

方法包括：租赁

运行效果：

源码：

public class Kache {
    private String carNumber;
    private String model;
    private String colour;
    private double zujin;
    private double weight;

    public Kache(String carNumber, String model, String colour, double zujin, double weight) {
        this.carNumber = carNumber;
        this.model = model;
        this.colour = colour;
        this.zujin = zujin;
        this.weight = weight;
    }

    public void fangfa(String name, double time) {
        if (time > 0) {

            System.out.println("租凭信息");
            System.out.println("车牌号：" + carNumber);
            System.out.println("车型：" + model);
            System.out.println("颜色：" + colour);
            System.out.println("载重量：" + weight);
            System.out.println("租车人：" + name);
            double money = getZujin() * time;
            System.out.println("应付租金：" + money);
        }else {
            System.out.println("无效的时间");
        }

    }

    public String getCarNumber() {
        return carNumber;
    }

    public void setCarNumber(String carNumber) {
        this.carNumber = carNumber;
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public String getColour() {
        return colour;
    }

    public void setColour(String colour) {
        this.colour = colour;
    }

    public double getZujin() {
        return zujin;
    }

    public void setZujin(double zujin) {
        this.zujin = zujin;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}






/**
 * 测试
 */
public class KacheTest {
    public static void main(String[] args) {
        Kache k=new Kache("京D1111","东风","蓝色",20,500);
        System.out.println("请输入租车人姓名：");
        Scanner input=new Scanner(System.in);
        String name=input.next();
        System.out.println("请输入租凭天数：");
        double time=input.nextInt();
        k.fangfa(name,time);
    }
}

【5】商品（两个类依赖）

要求：

1. 请使用面向对象的思想设计描述商品信息
2. 分析商品类别和商品详细信息的属性和方法，设计商品类别类 和商品详细信息类
3. 在商品详细信息类中通过属性描述该商品所属类别
4. 设置属性的私有访问权限，通过公有的get，set方法实现对属 性的访问
5. 编写测试类，测试商品类别类和商品详细信息类的对象及相关 方法（测试数据信息自定）
6.  创建包info---存放商品类别类和商品详细信息类，创建包 test---存放测试类

参考思路分析：

商品类别类：

 属性：类别编号，类别名称  

商品详细信息类：

属性：商品编号，商品名称，所属类别、商品数量(大于0)，商品价格(大于0)，

方法：盘点的方法，描述商品信息。内容包括商品名称，商品数量，商品价格，现有商品总价以及所属类别信息

运行效果：

 

源码：

/**
 * 商品类别类
 */
public class Shangpin {
    private String leiid;
    private String leiname;

    public Shangpin(String leiid, String leiname) {
        this.leiid = leiid;
        this.leiname = leiname;
    }

    public String getLeiid() {
        return leiid;
    }

    public void setLeiid(String leiid) {
        this.leiid = leiid;
    }

    public String getLeiname() {
        return leiname;
    }

    public void setLeiname(String leiname) {
        this.leiname = leiname;
    }
}




/*
商品详细信息类
 */
public class Shangpiniformation {
    private String shangid;
    private String shangname;

     private Shangpin leiname;
    private int shangnumber;
    private double price;

    public Shangpiniformation(String shangid, String shangname, Shangpin leiname,int shangnumber,double price) {
        this.shangid = shangid;
        this.shangname = shangname;
        this.leiname = leiname;
        this.shangnumber = shangnumber;
        this.price = price;
    }
    public void pandian(){
       if (shangnumber>0){
           System.out.println("商品名称："+shangname);
           System.out.println("所属类别："+leiname.getLeiname());
           System.out.println("商品售价："+price);
           System.out.println("库存数量："+shangnumber);
           System.out.println("商品总价："+price*shangnumber);
           System.out.println("=================================");
       }else {
           System.out.println("库存异常，请联系管理员");
           System.out.println("商品名称："+shangname);
           System.out.println("所属类别："+leiname.getLeiname());
           System.out.println("商品售价："+price);
           System.out.println("库存数量："+shangnumber);
           System.out.println("商品总价："+price*shangnumber);
           System.out.println("=================================");
       }


    }


    public String getShangid() {
        return shangid;
    }

    public void setShangid(String shangid) {
        this.shangid = shangid;
    }

    public String getShangname() {
        return shangname;
    }

    public void setShangname(String shangname) {
        this.shangname = shangname;
    }

    public Shangpin getLeiname() {
        return leiname;
    }

    public void setLeiname(Shangpin leiname) {
        this.leiname = leiname;
    }

    public int getShangnumber() {
        return shangnumber;
    }

    public void setShangnumber(int shangnumber) {
        this.shangnumber = shangnumber;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}



//测试



public class ShangpinTest {
    public static void main(String[] args) {
        Shangpin sp=new Shangpin("001","洗发水");
        Shangpin sp2=new Shangpin("002","洗发水");
        Shangpiniformation s=new Shangpiniformation("001","潘婷洗发水400ml",sp,16,40.5);
        Shangpiniformation s2=new Shangpiniformation("002","蜂花洗发水250ml",sp2,0,11.5);
        s.pandian();
        s2.pandian();
    }
}

【6】图书

要求：

1. 以面向对象的思想，编写自定义类描述图书信息。
2. 设置属性的私有访问权限，通过公有的get，set方法实现对属性的访问
3. 限定价格必须大于10，如果无效需进行提示
4. 限定作者、书名均为只读属性
5. 设计构造函数实现对属性赋值
6. 信息介绍方法描述图书所有信息
7. 编写测试类，测试图书类的对象及相关方法（测试数据信息自定）

参考思路分析：

图书信息类：

属性包括：书名，作者，出版社名，价格；

方法包括：信息介绍

运行效果：

 源码:

/*
图书信息类
 */
public class Book {
    private String name;
    private String author;
    private String publish;
    private double money;

    public Book(String name, String author, String publish, double money) {
        this.name = name;
        this.author = author;
        this.publish = publish;
        this.setMoney(money);
    }
    public void information(){

        System.out.println("书名："+name);
        System.out.println("作者："+author);
        System.out.println("出版社："+publish);
        System.out.println("价格："+money+"元");
    }

    public String getName() {
        return name;
    }



    public String getAuthor() {
        return author;
    }


    public String getPublish() {
        return publish;
    }

    public void setPublish(String publish) {
        this.publish = publish;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        if (money>10){
            this.money=money;
        }else {
            System.out.println("错误信息！");
        }
    }
}



//测试



public class BookTest {
    public static void main(String[] args) {
        Book b=new Book("鹿鼎记","金庸","人民文学出版社",120);
        b.information();
        System.out.println("====================================");
        Book b2=new Book("绝代双骄","古龙","中国长安出版社",55.5);
        b2.information();
    }
}

【7】学生

要求：

1. 以面向对象的思想，编写自定义类描述学生。
2. 设置属性的私有访问权限，通过公有的get，set方法实现对属性的访问
3. 设计构造函数实现对所有属性赋值
4. 学习方法通过输入参数，接收就读学校和所学专业，输出个人的学习信息
5. 编写测试类，测试学生类的对象及相关方法（测试数据信息自定）

参考思路分析：

学生类：

属性包括：姓名，年龄，性别，学号；

方法包括：学习

运行效果：

源码：

public class Student {
    private String name;
    private int age;
    private String sex;
    private String id;

    public Student(String name, int age, String sex, String id) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.id = id;
    }
    public void xue(String xuexiao,String zhuanye){
        System.out.println("大家好！我叫"+name+",今年"+age);
        System.out.println("我现在就读于"+xuexiao+"---"+zhuanye);
        System.out.println("我的学号是"+id);

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}






public class StudentTest {
    public static void main(String[] args) {
        Student s=new Student("阿宝",25,"男","s23401");
        Scanner input=new Scanner(System.in);
        System.out.println("请输入学校");
        String xuexiao=input.next();
        System.out.println("请输入专业");
        String zhuanye=input.next();
        s.xue(xuexiao,zhuanye);
        System.out.println("======================================");
        Student s2=new Student("郭美美",21,"女","y12302");
        System.out.println("请输入学校");
        String xuexiao2=input.next();
        System.out.println("请输入专业");
        String zhuanye2=input.next();
        s2.xue(xuexiao2,zhuanye2);
    }

}

【8】银行存户

要求：

1. 请使用面向对象的思想，设计银 行的储户信息
2. 分析储户的属性和方法，设计储户类
3. 设置属性的私有访问权限，通过公有的get，set方法实现对属 性的访问
4. 编写测试类，测试储户类的对象及相关方法（测试数据 信息自定）
5. 创建包info---存放储户类，创建包test---存放测试类

参考思路分析：

储户类：

属性: 用户姓名、密码、身份证号、账号、帐户余额

方法：

1. 存款：验证账号是否有效，存款金额是否有效，如果有 效修改账户余额
2.  取款：验证账号是否有效，取款金额是否有效，余额是 否够用，如果有效修改余额

运行效果：

源码：

public class Bank8 {
    private String name;
    private String mima;
    private String idcard;
    private String account;
    private double money;

    public Bank8(String name, String mima, String idcard, String account, double money) {
        this.name = name;
        this.mima = mima;
        this.idcard = idcard;
        this.account = account;
        this.money = money;
    }

    public void inmoney(String account, double inmoney) {
        if (getAccount().equals(account) && inmoney > 0) {
            System.out.println("请输入账户："+account);
            System.out.println("请输入存款金额："+inmoney);
            System.out.println("存款成功！");
            System.out.println("储户姓名："+name);
            System.out.println("账号："+account);
            money=money+inmoney;
            System.out.println("可用金额："+money);
        }else {
            System.out.println("无效的输入！");
        }
    }
    public void outmoney(String account,double outmoney){
        if (getAccount().equals(account) && outmoney > 0){
            System.out.println("请输入取款金额"+outmoney);
            if (outmoney>money){
                System.out.println("当前账户余额不足！");
            }else {
                System.out.println("取款成功！");
                System.out.println("储户姓名："+name);
                System.out.println("账号："+account);
                money=money-outmoney;
                System.out.println("可用金额："+money);
            }
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMima() {
        return mima;
    }

    public void setMima(String mima) {
        this.mima = mima;
    }

    public String getIdcard() {
        return idcard;
    }

    public void setIdcard(String idcard) {
        this.idcard = idcard;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}


//测试类

public class Bank8Test {
    public static void main(String[] args) {
        Bank8 b=new Bank8("王丽丽","123456","654321","179708064356",2000);
        b.inmoney("179708064356",1500);
        System.out.println("=========================================");
        b.outmoney("179708064356",5000);
    }
}

【9】英雄和技能（两个类依赖）

要求：

1. 请用面向对象的思想设计英雄类和技能类。
2. 设置属性的私有访问权限，通过公有的get，set方法实现对属性的访问
3. 学习新技能的方法，需要判断新技能等级是否大于已经掌握技能等级，如果不满足条件则放弃学习
4. 攻击方法描述攻击状态。内容包括英雄名字，生命值、攻击力。其中攻击力=个人攻击力+技能攻击力
5. 防御方法通过输入参数接收攻击力。需要判断，如果攻击力小于防御力，伤害值=0；反之，伤害值=攻击力-防御力。 根据伤害值情况显示不同的防御信息，内容包括英雄名字， 防御力，防御后的生命值。其中防御力=个人防御力+技能防御力
6.  编写测试类，构造技能对象和英雄对象，并调用相关方法（测试数据信息自定）

参考思路分析：

技能类： 

属性包括：技能名称、攻击力、防御力、技能等级  

英雄类：

属性包括：英雄名字、生命值、攻击力、防御力、掌握的技能

方法包括：学习新技能的方法、攻击的方法，防御的方法

运行效果：

源码：

/*
英雄类
 */
public class Heroes {
    private String heroesname;
    private int sming;
    private int gjili;
    private int fyuli;
    private Skills masterskill;

    public Heroes(String heroesname, int sming, int gjili, int fyuli, Skills masterskill) {
        this.heroesname = heroesname;
        this.sming = sming;
        this.gjili = gjili;
        this.fyuli = fyuli;
        this.masterskill = masterskill;
    }

    public void xuexi(int skilllevel, String skillname) {//学习新技能的方法
        if (masterskill.getSkilllevel() > skilllevel) {
            System.out.println(skillname+"等级过低，不需要学习！");
        } else {
            masterskill.setSkilllevel(skilllevel);
            masterskill.setSkillname(skillname);
            System.out.println("学习新技能成功！");

        }
    }

    public void gjifa() {//攻击的方法
        System.out.println("英雄" + heroesname + "展开攻击");
        System.out.println("生命值：" + sming);
        System.out.println("攻击力：" + (gjili + masterskill.getGjili()));
        System.out.println("===========================================");
    }

    public void fyufa(int gjili) {//防御的方法
        int shanghaizhi = 0;
        if (gjili + masterskill.getGjili() < fyuli + masterskill.getFyuli()) {
            shanghaizhi = 0;
            System.out.println("防御成功！");
            System.out.println("=====================================");
        } else {
            shanghaizhi = gjili + masterskill.getGjili() - fyuli - masterskill.getFyuli();
            System.out.println("英雄" + heroesname + "以" + (fyuli + masterskill.getFyuli()) + "的防御力未能抵御进攻！");
            System.out.println("当前生命值：" + (sming - shanghaizhi));
            System.out.println("=====================================");
        }
    }


    public String getHeroesname() {
        return heroesname;
    }

    public void setHeroesname(String heroesname) {
        this.heroesname = heroesname;
    }

    public int getSming() {
        return sming;
    }

    public void setSming(int sming) {
        this.sming = sming;
    }

    public int getGjili() {
        return gjili;
    }

    public void setGjili(int gjili) {
        this.gjili = gjili;
    }

    public int getFyuli() {
        return fyuli;
    }

    public void setFyuli(int fyuli) {
        this.fyuli = fyuli;
    }

    public Skills getMasterskill() {
        return masterskill;
    }

    public void setMasterskill(Skills masterskill) {
        this.masterskill = masterskill;
    }
}





/*
技能类
 */
public class Skills {
    private String skillname;
    private int gjili;
    private int fyuli;
    private int skilllevel;

    public Skills(String skillname, int gjili, int fyuli, int skilllevel) {
        this.skillname = skillname;
        this.gjili = gjili;
        this.fyuli = fyuli;
        this.skilllevel = skilllevel;
    }

    public String getSkillname() {
        return skillname;
    }

    public void setSkillname(String skillname) {
        this.skillname = skillname;
    }

    public int getGjili() {
        return gjili;
    }

    public void setGjili(int gjili) {
        this.gjili = gjili;
    }

    public int getFyuli() {
        return fyuli;
    }

    public void setFyuli(int fyuli) {
        this.fyuli = fyuli;
    }

    public int getSkilllevel() {
        return skilllevel;
    }

    public void setSkilllevel(int skilllevel) {
        this.skilllevel = skilllevel;
    }
}







/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        Skills s=new Skills("霸王刀",50,10,2);
        Heroes h=new Heroes("李小侠",300,30,20,s);
        h.gjifa();
        h.fyufa(30);
        h.xuexi(1,"死神镰刀");
    }
}

【10】专业和学生（两个类依赖）

要求：

1. 请使用面向对象的思想， 描述专业信息和学生信息
2. 分析专业和学生的属性和方法，设计专业类和学生类
3. 在学员类中通过属性描述所学习的专业
4. 设置属性的私有访问权限，通过公有的get，set方法实现对属 性的访问
5. 编写测试类，测试专业类和学生类的对象及相关方法（测试数 据信息自定）
6.  创建包info---存放专业类和学生类，创建包test---存放测试类

参考思路分析：

专业类：

属性：专业编号，专业名称 、学习该专业的人数

方法：介绍情况的方法，描述专业信息。描述内容包括专业名称以及学习该专业的人数  

学生类：

属性：学号，姓名，年龄(大于18岁)，所学习的专业

方法：学习的方法，描述学习状态。描述内容包括姓名、学号、年龄、所学习的专业信息

运行效果：

源码：

/*
专业类
 */
public class Major {
    private String majorid;
    private String majorname;
    private int majornumber;

    public Major(String majorid, String majorname, int majornumber) {
        this.majorid = majorid;
        this.majorname = majorname;
        this.majornumber = majornumber;
    }
    public void informationzhuanye(String majorname){
        System.out.println(majorname+"目前有"+majornumber+"名学生");
    }

    public String getMajorid() {
        return majorid;
    }

    public void setMajorid(String majorid) {
        this.majorid = majorid;
    }

    public String getMajorname() {
        return majorname;
    }

    public void setMajorname(String majorname) {
        this.majorname = majorname;
    }

    public int getMajornumber() {
        return majornumber;
    }

    public void setMajornumber(int majornumber) {
        this.majornumber = majornumber;
    }
}







/*
学生类
 */
public class Student {
    private String id;
    private String name;
    private int age;
    private Major Majorname;

    public Student(String id, String name, int age, Major majorname) {
        this.id = id;
        this.name = name;
        this.setAge(age);
        Majorname = majorname;
    }
    public void information(){
        System.out.println("我叫"+name+"今年"+age+"岁");
        System.out.println("现在就读于"+Majorname.getMajorname()+"我的学号是"+id);
        System.out.println("=======================================");
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<18){
            this.age=18;
            System.out.println("本大学只收取18岁以上的学生");
        }else{
            this.age = age;
        }

    }

    public Major getMajorname() {
        return Majorname;
    }

    public void setMajorname(Major majorname) {
        Majorname = majorname;
    }
}




/*
测试
 */
public class Test {
    public static void main(String[] args) {
        Major m1 = new Major("001", "计算机科学与技术专业", 2);
        Major m2 = new Major("001", "计算机科学与技术专业", 2);

        Student s = new Student("00101", "刘新雨", 17,m1);
        s.information();
        Student s2 = new Student("00102", "宝强", 21, m2);
        s2.information();
       m2.informationzhuanye("计算机科学与技术专业");

    }
}