3.1_7 JavaSE入门 P6 【面向对象】概述&封装

相关链接

  • Excel目录

目录

  • Part6 【面向对象】概述&封装
    • 1 面向对象概述
      • 1.1 面向对象思想
        • 1.1.1 面向过程思想与面向对象思想
        • 1.1.2 面向过程特点与面向对象特点
      • 1.2 类与对象概述
    • 2 对象的内存图
      • 2.1 一个对象的内存图
      • 2.2 两个对象的内存图(共用方法区)
      • 2.3 两个对象的内存图(两个引用指向同一个堆内存)
      • 2.4 成员变量和局部变量区别
    • 3 private、this关键字和封装
      • 3.1 private关键字的概述和特点
      • 3.2 private修饰后的标准类代码
      • 3.3 封装的概述和好处
      • 3.4 this关键字的概述和使用
    • 4 面向对象之构造方法
      • 4.1 构造方法的概述和使用
        • 4.1.1 构造方法作用概述
        • 4.1.2 构造方法格式
      • 4.2 构造方法的注意事项
    • 5 课后练习
      • 5.1 练习1 求长方形周长面积
      • 5.2 练习2 显示员工信息
      • 5.3 练习3 键盘录入学员信息并打印
      • 5.4 练习4 调用老师类和学生类的成员方法


Part6 【面向对象】概述&封装


1 面向对象概述


1.1 面向对象思想

  • 我们回想一下,前面我们完成一个需求的步骤:首先是搞清楚我们要做什么,然后在分析怎么做,最后我们再代码体现。一步一步去实现,而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作,完成我们的需求。
  • 在上面的每一个具体步骤中我们都是参与者,并且需要面对具体的每一个步骤和过程,这就是面向过程最直接的体现。
  • 那么什么是面向过程开发呢? 面向过程开发,其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。
  • 面向过程的代表语言:C语言
  • 当需求单一,或者简单时,我们一步一步去操作没问题,并且效率也挺高。可随着需求的更改,功能的增多,发现需要面对每一个步骤很麻烦了,这时就开始思索,能不能把这些步骤和功能在进行封装,封装时根据不同的功能,进行不同的封装,功能类似的用一个类封装在一起,这样结构就清晰了很多。用的时候,找到对应的类就可以了。这就是面向对象的思想。

1.1.1 面向过程思想与面向对象思想
  • A:什么是面向过程

    • 面向过程,其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。
    • 例如:吃煎饼果子利用面向过程的思想:
      • 1.学习摊煎饼的技术
      • 2.买材料鸡蛋,油,葱等等
      • 3.开始摊
      • 4.吃
      • 5.收拾
  • B:什么是面向对象

    • 面向对象思想就是不断的创建对象,使用对象,指挥对象做事情。(如果有对象,直接用对象,对我们直接提供服务)
    • 例如:吃煎饼果子利用面向对象的思想
      • 1.找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
      • 2.调用其摊煎饼的技能(功能),传递进去钱参数
      • 3.返回给我们一个煎饼
      • 4.吃

1.1.2 面向过程特点与面向对象特点
  • A:面向过程:
    • 强调的是过程,所有事情都需要自己完成
  • B:面向对象:
    • 是一种更符合我们思想习惯的思想(懒人思想,我把事情自己不做,交给别人去做)
    • 可以将复杂的事情简单化(对使用者来说简单了,对象里面还是很复杂的)
    • 将我们从执行者变成了指挥者角色发生了转换

1.2 类与对象概述

  • A:我们学习编程是为了什么
    • 为了把我们日常生活中实物用学习语言描述出来
  • B:我们如何描述现实世界事物
    • 属性 就是该事物的描述信息(事物身上的名词)
    • 行为 就是该事物能够做什么(事物身上的动词)
  • C:Java中最基本的单位是类,Java中用class描述事物也是如此
    • 成员变量 就是事物的属性
    • 成员方法 就是事物的行为
  • D:定义类其实就是定义类的成员(成员变量和成员方法)
    • a:成员变量 和以前定义变量是一样的,只不过位置发生了改变。在类中,方法外
    • b:成员方法 和以前定义方法是一样的,只不过把static去掉,后面在详细讲解static的作用。
  • E:类和对象的概念
    • a:类:是一组相关的属性和行为的集合(我们班所有的同学都具备相同的属性和行为,比如:姓名,年龄,学习,这样就把所有的学生成为学生类)
    • b:对象:是该类事物的具体体现(说某个同学时,他都具备自己特有的属性和行为)
    • c:举例:
      • 学生
      • 对象 具体的某个学生就是一个对象
    • 比如:车是一个类,具体的开的奔驰、宝马,就是对象

案例代码一  类与对象案例 【1.a 学生类】

package com.groupies.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类    案例
 *
 * 类的定义:类是用来描述现实世界事物的
 * 事物:
 * 		属性
 * 		行为
 * 类如何和事物进行对应的呢?
 * 		类:
 * 			成员变量
 * 			成员方法
 *
 * 成员变量:和我们学习过的变量的定义是一样的,有两个小区别。
 * 		位置不同:类中,方法外
 * 		初始化值:成员变量不需要给初始化值也可以使用,因为它有默认值
 * 成员方法:和我们学习过的方法的定义是一样的,有一个小区别。
 * 		去掉了修饰符中的static关键字
 *
 * 需求:定义一个学生类。
 *
 * 学生事物:
 * 		属性:姓名,年龄...
 * 		行为:学习,吃饭...
 *
 * 学生类:
 * 		成员变量:姓名,年龄...
 * 		成员方法:学习,吃饭...
 */
public class OperatorDemo1POJO {
    /*成员变量*/
    //姓名
    String name;
    //年龄
    int age;

    /*成员方法*/
    //学习的方法
    public void study() {
        System.out.println(name + " 好好学习,天天向上");
    }

    //吃饭的方法
    public void eat() {
        System.out.println(name + " 学习饿了要吃饭");
    }
}

案例代码一  类与对象案例 【1.b 学生类的测试类】

package com.groupies.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类的测试类    类与对象案例
 *
 * 类的使用:
 * 		使用一个类,其实就是使用该类的成员。(成员变量和成员方法)
 * 而我们要想使用一个类的成员,就必须先拥有该类的对象。
 * 那么我们如何拥有一个类的对象呢?
 * 		创建对象就可以了
 * 我们如何创建对象呢?
 * 		格式:
 * 			类名  对象名  = new 类名();
 * 对象如何访问成员呢?
 * 		成员变量:
 * 			对象名.成员变量
 * 		成员方法:
 * 			对象名.成员方法(...)
 */
public class OperatorDemo1 {
    public static void main(String[] args) {
        //类型 对象名 = new 类名();
        OperatorDemo1POJO student = new OperatorDemo1POJO();
        //实例对象地址:student:com.groupies.day06.OperatorDemoPOJO@23fc625e
        System.out.println("student:" + student);

        //使用成员变量
        System.out.println("姓名" + student.name);
        System.out.println("年龄" + student.age);
        System.out.println("-------------------");

        //给成员变量赋值
        student.name = "林青霞";
        student.age = 30;

        //再次使用成员变量
        System.out.println("姓名:" + student.name);
        System.out.println("年龄:" + student.age);
        System.out.println("-------------------");

        //调用成员方法
        student.study();
        student.eat();
    }
}

案例代码二  类与对象案例 【2.a 手机类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 手机类
 */
public class OperatorDemo2POJO {
    /*成员变量*/
    //品牌
    String brand;
    //价格
    int price;
    //颜色
    String color;

    /*成员方法*/
    //打电话
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
    //发短信
    public void sendMessage(String name) {
        System.out.println("给" + name + "发短信");
    }
}

2 对象的内存图


2.1 一个对象的内存图


案例代码二  对象的内存图 【2.b 手机类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 手机类的测试类
 */
public class OperatorDemo2 {
    public static void main(String[] args) {
        //创建对象
        OperatorDemo2POJO phone = new OperatorDemo2POJO();

        //给成员变量赋值
        phone.brand = "锤子";
        phone.price = 2999;
        phone.color = "棕色";

        //输出成员变量的值
        System.out.println("品牌:" + phone.brand);//锤子
        System.out.println("价格:" + phone.price);//2999
        System.out.println("颜色:" + phone.color);//棕色
        System.out.println("------------");

        //调用成员方法
        phone.call("林青霞");
        phone.sendMessage("林青霞");
    }
}

一个对象的内存图图解

3.1_7 JavaSE入门 P6 【面向对象】概述&封装_第1张图片


2.2 两个对象的内存图(共用方法区)


案例代码二  对象的内存图 【2.c 手机类的测试类(两个对象共用一个方法区)】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 手机类的测试类(两个对象共用一个方法区)
 */
public class OperatorDemo2_1 {
    public static void main(String[] args) {
        //创建对象
        OperatorDemo2POJO phone = new OperatorDemo2POJO();

        //给成员变量赋值
        phone.brand = "小米5s";
        phone.price = 1999;
        phone.color = "银色";
        //小米5s---1999---银色
        System.out.println(phone.brand+"---"+phone.price+"---"+phone.color);
        phone.call("林青霞");
        phone.sendMessage("林青霞");

        //创建对象
        OperatorDemo2POJO phone2 = new OperatorDemo2POJO();

        //给成员变量赋值
        phone2.brand = "IPhone7S";
        phone2.price = 7999;
        phone2.color = "土豪金";
        //IPhone7S---7999---土豪金
        System.out.println(phone2.brand+"---"+phone2.price+"---"+phone2.color);
        phone2.call("张曼玉");
        phone2.sendMessage("张曼玉");
    }
}

两个对象的内存图(共用方法区)图解


2.3 两个对象的内存图(两个引用指向同一个堆内存)


案例代码二  对象的内存图 【2.d 手机类的测试类(两个引用指向同一个堆内存)】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 手机类的测试类(两个引用指向同一个堆内存)
 */
public class OperatorDemo2_2 {
    public static void main(String[] args) {
        //创建对象
        OperatorDemo2POJO phone = new OperatorDemo2POJO();

        //给成员变量赋值
        phone.brand = "OPPO";
        phone.price = 2999;
        phone.color = "白色";
        //OPPO---2999---白色
        System.out.println(phone.brand+"---"+phone.price+"---"+phone.color);

        //创建对象
        OperatorDemo2POJO phone2 = phone;

        //给成员变量赋值
        phone2.brand = "魅族";
        phone2.price = 1999;
        phone2.color = "蓝色";
        //魅族---1999---蓝色
        System.out.println(phone.brand+"---"+phone.price+"---"+phone.color);
        //魅族---1999---蓝色
        System.out.println(phone2.brand+"---"+phone2.price+"---"+phone2.color);
    }
}

两个对象的内存图(两个引用指向同一个堆内存)图解


2.4 成员变量和局部变量区别


案例代码三  对象的内存图 【3.a 成员变量和局部变量区别】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 成员变量和局部变量区别
 *
 * 成员变量和局部变量的区别:
 * 		A:在类中的位置不同
 * 			成员变量:在类中,方法外
 * 			局部变量:在方法中或者方法声明上(形式参数)
 * 		B:在内存中的位置不同
 * 			成员变量:在堆内存
 * 			局部变量:在栈内存
 * 		C:生命周期不同
 * 			成员变量:随着对象的创建而存在,随着对象的消失而消失
 * 			局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
 * 		D:初始化值不同
 * 			成员变量:有默认值
 * 			局部变量:没有默认值,必须先定义,赋值,最后使用
 */
public class OperatorDemo3 {
    /**成员变量*/
    int x;

    public void show() {
        //局部变量
        int y = 10;

        System.out.println(x);
        System.out.println(y);
    }
}

3 private、this关键字和封装


3.1 private关键字的概述和特点

  • private关键字:
    • a:是一个权限修饰符;
    • b:可以修饰成员(成员变量和成员方法);
    • c:被private修饰的成员只在本类中才能访问。

案例代码四  private关键字 【4.a 学生类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类 private关键字的概述和特点
 *
 * 直接使用对象名访问成员变量,会存在数据的安全问题
 * 这个时候,我们就应该思考能不能让外界不要直接访问成员变量?    能
 * 如何实现呢?   用private关键字
 * private:
 * 		是一个修饰符
 * 		可以修饰成员变量,也可以修饰成员方法
 * 		被private修饰的成员只能在本类中被访问
 *
 * 针对被private修饰的成员变量,我们会相应的给出getXxx()和setXxx()用于获取和设置成员变量的值,
 * 方法用public修饰
 */
public class OperatorDemo4POJO {
    String name;

    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int a) {
        if (a < 0 || a > 200) {
            System.out.println("输入年龄有误");
        } else {
            age = a;
        }
    }

    public void show() {
        System.out.println("【name:"+name + "】 【age:" + age+"】");
    }
}

案例代码四  private关键字 【4.b 学生类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类的测试类    private关键字的概述和特点
 *
 * 直接使用对象名访问成员变量,会存在数据的安全问题
 * 这个时候,我们就应该思考能不能让外界不要直接访问成员变量?    能
 * 如何实现呢?   用private关键字
 * private:
 * 		是一个修饰符
 * 		可以修饰成员变量,也可以修饰成员方法
 * 		被private修饰的成员只能在本类中被访问
 *
 * 针对被private修饰的成员变量,我们会相应的给出getXxx()和setXxx()用于获取和设置成员变量的值,
 * 方法用public修饰
 */
public class OperatorDemo4 {
    public static void main(String[] args) {
        //创建对象
        OperatorDemo4POJO student = new OperatorDemo4POJO();
        student.show();//【name:null】 【age:0】

        //给成员变量赋值
        student.name = "林青霞";
        //student.age=30; //不能赋值 报错
        student.setAge(-30);//输入年龄有误
        student.show();//【name:林青霞】 【age:0】
    }
}


3.2 private修饰后的标准类代码

  • private最常见的应用:

  • 把成员变量用private修饰;

    • 提供对应的getXxx()/setXxx()方法;
  • 使用快捷键 alt + insert;

    • 构造器:Constructor;
    • Get和Set方法: Getter And Setter

案例代码五  private修饰后的标准类代码 【5.a 学生类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类    private修饰后的标准类代码
 *
 * private最常见的应用:
 *  把成员变量用private修饰
 *  提供对应的getXxx()/setXxx()方法
 */
public class OperatorDemo5POJO {
    private String name;
    private String age;

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String a) {
        age = a;
    }
}

3.3 封装的概述和好处

  • A:封装概述
    • 是面向对象三大特征之一;
    • 是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。就像刚才说的年龄。
  • B:封装原则
    • 将不需要对外提供的内容都隐藏起来;
    • 属性隐藏提供公共方法对其访问;
    • 成员变量private,提供对应的getXxx()/setXxx()方法。
  • C:好处
    • 通过方法来控制成员变量的操作,提高了代码的安全性
    • 把代码用方法进行封装,提高了代码的复用性

3.4 this关键字的概述和使用

  • A:this:代表所在类的对象引用
    • 方法被哪个对象调用,this就代表那个对象;
  • B:什么时候使用this呢
    • 局部变量和成员变量重名。

案例代码六  this关键字的概述和使用 【6.a 学生类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类    this关键字的概述和使用
 *
 * 目前代码中的n和a没有做到见名知意,需要改进。
 * 如果局部变量名称和成员变量名称一致,在方法中使用的时候采用的是就近原则。
 *
 * 我们有没有办法把局部变量的name赋值给成员变量的name呢?
 *      有
 *
 * 有什么办法呢?
 * 		用this关键字就可以解决这个问题
 *
 * this:代表所在类的对象引用
 * 		方法被哪个对象调用,this就代表谁。
 *
 * 使用场景:
 * 		就是用于解决成员变量被隐藏的问题。
 */
public class OperatorDemo6POJO {
    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;
    }
}


案例代码六  this关键字的概述和使用 【6.b 学生类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类的测试类    this关键字的概述和使用
 *
 * 目前代码中的n和a没有做到见名知意,需要改进。
 * 如果局部变量名称和成员变量名称一致,在方法中使用的时候采用的是就近原则。
 *
 * 我们有没有办法把局部变量的name赋值给成员变量的name呢?
 *      有
 *
 * 有什么办法呢?
 * 		用this关键字就可以解决这个问题
 *
 * this:代表所在类的对象引用
 * 		方法被哪个对象调用,this就代表谁。
 *
 * 使用场景:
 * 		就是用于解决成员变量被隐藏的问题。
 */
public class OperatorDemo6 {
    public static void main(String[] args) {
        //创建对象
        OperatorDemo6POJO student = new OperatorDemo6POJO();
        //null---0
        System.out.println(student.getName() + "---" + student.getAge());

        student.setName("林青霞");
        student.setAge(30);
        //林青霞---30
        System.out.println(student.getName() + "---" + student.getAge());
    }
}

4 面向对象之构造方法


4.1 构造方法的概述和使用


4.1.1 构造方法作用概述
  • 给对象的数据进行初始化

4.1.2 构造方法格式
  • 方法名与类名相同
  • 没有返回值,连void都没有
  • 没有具体的返回值

案例代码七  构造方法格式 【7.a 学生类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类    面向对象之构造方法
 *
 * 构造方法:
 * 		给对象的数据进行初始化
 *
 * 格式:
 * 		方法名和类名相同
 * 		没有返回值类型,连void都不能写
 * 		没有具体的返回值
 *
 */
public class OperatorDemo7POJO {
    private String name;
    public OperatorDemo7POJO() {
        System.out.println("这是构造方法");
    }

    public OperatorDemo7POJO(String name) {
        this.name = name;
        System.out.println("这是带参构造方法");
    }
}

案例代码七  构造方法格式 【7.b 学生类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类的测试类    面向对象之构造方法
 *
 * 构造方法:
 * 		给对象的数据进行初始化
 *
 * 格式:
 * 		方法名和类名相同
 * 		没有返回值类型,连void都不能写
 * 		没有具体的返回值
 *
 */
public class OperatorDemo7 {
    public static void main(String[] args) {
        //如何调用构造方法呢
        //通过new关键字调用
        //无参格式:类名 对象名 = new 构造方法(...);
        OperatorDemo7POJO student1 = new OperatorDemo7POJO();
        //带参格式:类型 对象名 = new 构造方法(参数1,参数2,...)
        OperatorDemo7POJO student2 = new OperatorDemo7POJO("张三");
    }
}


4.2 构造方法的注意事项

如果你不提供构造方法,系统会给出默认构造方法

如果你提供了构造方法,系统将不再提供

构造方法也是可以重载的,重载条件和普通方法相同


案例代码八  构造方法的注意事项 【8.a 学生类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类    构造方法的注意事项
 *
 * 构造方法:用于给对象的数据进行初始化
 *
 * 格式:
 * 		方法名和类名相同
 * 		没有返回值类型,连void都不能写
 * 		没有具体的返回值
 *
 * 构造方法的注意事项:
 * 		A:如果我们没有给出构造方法,系统将给出一个默认的无参数构造方法供我们使用
 * 		B:如果我们给出了构造方法,系统将不再提供默认的构造方法供我们使用。
 * 			这个时候,我们如果还想使用无参数构造方法,就必须自己提供。
 * 			我们推荐:自己给出无参数构造方法。
 * 		C:构造方法也是可以重载的。
 *
 * 给成员变量赋值的方式:
 * 		A:通过setXxx()
 * 		B:通过构造方法
 */
public class OperatorDemo8POJO {
    private String name;
    private int age;

    public OperatorDemo8POJO() {
    }

    public OperatorDemo8POJO(String name) {
        this.name = name;
    }

    public OperatorDemo8POJO(int age) {
        this.age = age;
    }

    public OperatorDemo8POJO(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "---" + age);
    }
}

案例代码八  构造方法的注意事项 【8.b 学生类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 学生类的测试类    构造方法的注意事项
 *
 * 构造方法:用于给对象的数据进行初始化
 *
 * 格式:
 * 		方法名和类名相同
 * 		没有返回值类型,连void都不能写
 * 		没有具体的返回值
 *
 * 构造方法的注意事项:
 * 		A:如果我们没有给出构造方法,系统将给出一个默认的无参数构造方法供我们使用
 * 		B:如果我们给出了构造方法,系统将不再提供默认的构造方法供我们使用。
 * 			这个时候,我们如果还想使用无参数构造方法,就必须自己提供。
 * 			我们推荐:自己给出无参数构造方法。
 * 		C:构造方法也是可以重载的。
 *
 * 给成员变量赋值的方式:
 * 		A:通过setXxx()
 * 		B:通过构造方法
 */
public class OperatorDemo8 {
    public static void main(String[] args) {
        //如何调用构造方法呢?
        //其实通过new关键字就可以
        //格式:类名 对象名 = new 构造方法名(...);
        OperatorDemo8POJO student = new OperatorDemo8POJO();
        student.show();

        //public Student(String name)
        OperatorDemo8POJO student2 = new OperatorDemo8POJO("林青霞");
        student2.show();

        //public Student(int age)
        OperatorDemo8POJO student3 = new OperatorDemo8POJO(30);
        student3.show();

        //public Student(String name,int age)
        OperatorDemo8POJO student4 = new OperatorDemo8POJO("林青霞",30);
        student4.show();
    }
}

案例代码九  标准的类代码和测试 【9.a 学生类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 标准的学生类
 */
public class OperatorDemo9POJO {
    //成员变量
    private String name;
    private int age;

    public OperatorDemo9POJO() {
    }

    public OperatorDemo9POJO(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}


案例代码九  标准的类代码和测试 【9.b 学生类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/22
 * @introduction 标准的学生类的测试类
 */
public class OperatorDemo9 {
    public static void main(String[] args) {
        //无参构造方法+setXxx()
        OperatorDemo9POJO student = new OperatorDemo9POJO();
        student.setName("林青霞");
        student.setAge(30);
        System.out.println(student.getName()+"---"+student.getAge());

        //带参构造方法
        OperatorDemo9POJO student2 = new OperatorDemo9POJO("林青霞",30);
        System.out.println(student2.getName()+"---"+student2.getAge());
    }
}


5 课后练习


5.1 练习1 求长方形周长面积


练习1  【1.a 长方形类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 长方形类
 *
 * 需求:定义一个长方形类,定义求周长和面积的方法,然后定义一个测试类进行测试。
 * 	   长方形类:
 * 			属性:长、宽
 * 			行为:计算周长的方法、计算面积的方法
 * 		测试类:
 * 			测试长方形类中的每一个方法
 *
 * 要求:按照封装的原则进行定义。并提供无参和全参的构造方法。
 */
public class HomeWork1POJO {
    /**长*/
    private int length;
    /**宽*/
    private int wide;

    public HomeWork1POJO(int length, int wide) {
        this.length = length;
        this.wide = wide;
    }

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    public int getWide() {
        return wide;
    }

    public void setWide(int wide) {
        this.wide = wide;
    }

    /**
     * @introduction 计算面积的方法
     * @return 长方形面积
     */
    public int area() {
        return length * wide;
    }

    /**
     * @introduction 计算周长的方法
     * @return 长方形周长
     */
    public int perimeter() {
        return (length + wide) * 2;
    }

}

练习1  【1.b 长方形类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 长方形类的测试类
 *
 * 需求:定义一个长方形类,定义求周长和面积的方法,然后定义一个测试类进行测试。
 * 	   长方形类:
 * 			属性:长、宽
 * 			行为:计算周长的方法、计算面积的方法
 * 		测试类:
 * 			测试长方形类中的每一个方法
 *
 * 要求:按照封装的原则进行定义。并提供无参和全参的构造方法。
 */
public class HomeWork1 {
    public static void main(String[] args) {
        HomeWork1POJO rectangle = new HomeWork1POJO(3, 4);
        int area = rectangle.area();
        int perimeter = rectangle.perimeter();
        System.out.println("长方形面积为:" + area + "\r\n长方形周长为:" + perimeter);
    }
}

5.2 练习2 显示员工信息


练习2  【2.a 员工类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 员工类
 *
 * 需求:
 * 定义一个员工类:
 * 属性:姓名name,工号id,工资salary
 * 行为:一个显示所有成员信息的方法
 * 测试类:
 * 测试员工类中的每一个方法
 */
public class HomeWork2POJO {
    /**姓名*/
    private String name;
    /**工号*/
    private int id;
    /**工资*/
    private double salary;

    /**
     * @introduction 无参构造
     */
    public HomeWork2POJO() {
    }

    public HomeWork2POJO(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void information() {
        System.out.println("员工姓名:" + name + "\r\n员工工号:" + id + "\r\n员工工资:" + salary);

    }
}

练习2  【2.b 员工类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 员工类的测试类
 *
 * 需求:
 * 定义一个员工类:
 * 属性:姓名name,工号id,工资salary
 * 行为:一个显示所有成员信息的方法
 * 测试类:
 * 测试员工类中的每一个方法
 */
public class HomeWork2 {
    public static void main(String[] args) {
        HomeWork2POJO staff = new HomeWork2POJO("林青霞", 12512362, 1234.56);
        /*
            员工姓名:林青霞
            员工工号:12512362
            员工工资:1234.56
         */
        staff.information();
    }
}

5.3 练习3 键盘录入学员信息并打印

练习3  【3.a 学员类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 学员类
 *
 * 分析以下需求,并用代码实现
 * 1,实现从控制台接收一个学员信息,并存储到一个对象中
 * 2,打印这个对象的所有属性值。
 *
 *
 * 操作步骤描述
 * 1,设计,并定义一个学员类:Student,要求有以下属性:
 * 学员编号(String)
 * 姓名(String)
 * 性别(String)
 * 身高(double)
 * 年龄(int)
 * 使用封装的原则,并提供无参和全参的构造方法。
 * 2,定义MainApp类,并包含main()方法。
 * 3,程序启动后,应分别提示用户输入学员编号、姓名等信息。
 * 例如控制台显示:
 * C:\>请输入学员编号:
 * C:\>....
 * C:\>请输入学员姓名:
 * C:\>....
 * .................
 * 4,数据接收到程序中,并定义局部变量存储;
 * 5,创建Student对象,通过构造方法将所有数据存储到Student对象中;
 * 6,打印对象中的每个属性值。
 */

public class HomeWork3POJO {
    /**学员编号*/
    private String ID;
    /**姓名*/
    private String name;
    /**性别*/
    private String gender;
    /**身高*/
    private int height;
    /**年龄*/
    private int age;

    /**
     * @introduction 无参构造方法
     */
    public HomeWork3POJO() {
    }

    /**
     * @introduction 全参构造方法
     * @param ID 学员编号
     * @param name 姓名
     * @param gender 性别
     * @param height 身高
     * @param age 年龄
     */
    public HomeWork3POJO(String ID, String name, String gender, int height, int age) {
        this.ID = ID;
        this.name = name;
        this.gender = gender;
        this.height = height;
        this.age = age;
    }

    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 getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

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

    /**
     * @introduction 打印学员信息
     */
    public void information() {
        System.out.println("学生编号:" + ID);
        System.out.println("姓名:" + name);
        System.out.println("性别:" + gender);
        System.out.println("身高:" + height);
        System.out.println("年龄:" + age);
    }
}

练习3  【3.a 学员类的测试类】

package com.groupies.base.day06;

import java.util.Scanner;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 学员类的测试类
 *
 * 分析以下需求,并用代码实现
 * 1,实现从控制台接收一个学员信息,并存储到一个对象中
 * 2,打印这个对象的所有属性值。
 *
 *
 * 操作步骤描述
 * 1,设计,并定义一个学员类:Student,要求有以下属性:
 * 学员编号(String)
 * 姓名(String)
 * 性别(String)
 * 身高(double)
 * 年龄(int)
 * 使用封装的原则,并提供无参和全参的构造方法。
 * 2,定义MainApp类,并包含main()方法。
 * 3,程序启动后,应分别提示用户输入学员编号、姓名等信息。
 * 例如控制台显示:
 * C:\>请输入学员编号:
 * C:\>....
 * C:\>请输入学员姓名:
 * C:\>....
 * .................
 * 4,数据接收到程序中,并定义局部变量存储;
 * 5,创建Student对象,通过构造方法将所有数据存储到Student对象中;
 * 6,打印对象中的每个属性值。
 */

public class HomeWork3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学员编号");
        String ID = sc.next();

        System.out.println("请输入学员姓名");
        String name = sc.next();

        System.out.println("请输入学员性别");
        String gender;
        while (true) {
            gender = sc.next();
            if (!gender.equals("男") && !gender.equals("女")) {
                System.out.println("请重新输入学员性别(男/女)");
            } else {
                break;
            }
        }

        System.out.println("请输入学员身高(cm)");
        String height = sc.next();

        //正则表达式校验数值
        while (true) {
            if (!height.matches("\\d+")) {
                System.out.println("请输入学员身高(cm)");
                height = sc.next();
            } else if (Integer.valueOf(height) < 0 || Integer.valueOf(height) > 250) {
                System.out.println("请输入合理的身高");
                height = sc.next();
            } else {
                break;
            }
        }

        System.out.println("请输入学员年龄");
        String age = sc.next();
        //正则表达式校验数值
        while (true) {
            if (!age.matches("\\d+")) {
                System.out.println("请输入学员年龄");
                age = sc.next();
            } else if (Integer.valueOf(age) < 0 || Integer.valueOf(age) > 200) {
                System.out.println("请输入合理的年龄值");
                age = sc.next();
            } else {
                break;
            }
        }

        HomeWork3POJO student = new HomeWork3POJO(ID, name, gender, Integer.valueOf(height), Integer.valueOf(age));
        student.information();
    }
}

5.4 练习4 调用老师类和学生类的成员方法


练习4  【4.a 老师类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 老师类
 *
 * 分析以下需求,并用代码实现
 * 1.老师类Teacher
 * 属性:
 * 姓名name
 * 年龄age
 * 讲课内容content
 * 行为:
 * 吃饭
 * 讲课
 * 2.学生类Student
 * 属性:
 * 姓名name
 * 年龄age
 * 学习内容content
 * 行为:
 * 吃饭eat()
 * 学习study()
 * 要求:
 * 1.按照以上要求定义Teacher类和Student类,属性要私有,生成空参、有参构造,setter和getter方法
 * 2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
 * 3.调用成员方法,打印格式如下:
 * 年龄为30的周志鹏老师正在吃饭....
 * 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
 * 年龄为18的韩光同学正在吃饭....
 * 年龄为18的韩光同学正在专心致志的听着面向对象的知识....("面向对象"代表学生学习的内容)
 */
public class HomeWork4POJOTeacher {
    /**姓名*/
    private String name;
    /**年龄*/
    private int age;
    /**讲课内容*/
    private String content;

    /**
     * @introduction 无参构造方法
     */
    public HomeWork4POJOTeacher() {
    }

    /**
     * @introduction 全参构造方法
     * @param name 姓名
     * @param age 年龄
     * @param content 讲课内容
     */
    public HomeWork4POJOTeacher(String name, int age, String content) {
        this.name = name;
        this.age = age;
        this.content = content;
    }

    /**
     *  * 年龄为30的周志鹏老师正在吃饭....
     *  * 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
     */
    public void eat() {
        System.out.println("年龄为" + age + "的" + name + "老师正在吃饭....");
    }

    public void teach() {

        System.out.println("年龄为" + age + "的" + name + "老师正在亢奋的讲着" + content + "的知识........");
    }
}

练习4  【4.b 学生类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 学生类
 *
 * 分析以下需求,并用代码实现
 * 1.老师类Teacher
 * 属性:
 * 姓名name
 * 年龄age
 * 讲课内容content
 * 行为:
 * 吃饭
 * 讲课
 * 2.学生类Student
 * 属性:
 * 姓名name
 * 年龄age
 * 学习内容content
 * 行为:
 * 吃饭eat()
 * 学习study()
 * 要求:
 * 1.按照以上要求定义Teacher类和Student类,属性要私有,生成空参、有参构造,setter和getter方法
 * 2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
 * 3.调用成员方法,打印格式如下:
 * 年龄为30的周志鹏老师正在吃饭....
 * 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
 * 年龄为18的韩光同学正在吃饭....
 * 年龄为18的韩光同学正在专心致志的听着面向对象的知识....("面向对象"代表学生学习的内容)
 */
public class HomeWork4POJOStudent  {
    /**姓名*/
    private String name;
    /**年龄*/
    private int age;
    /**学习内容*/
    private String content;

    /**
     * @introduction 无参构造方法
     */
    public HomeWork4POJOStudent() {
    }

    /**
     * @introduction 全参构造方法
     * @param name 姓名
     * @param age 年龄
     * @param content 学习内容
     */
    public HomeWork4POJOStudent(String name, int age, String content) {
        this.name = name;
        this.age = age;
        this.content = content;
    }

    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 getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    /**
     * @introduction 行为:吃饭
     */
    public void eat() {
        System.out.println("年龄为" + age + "的" + name + "同学正在吃饭....");
    }

    /**
     * @introduction 行为:学习
     */
    public void study() {
        System.out.println("年龄为" + age + "的" + name + "同学正在专心致志的听着" + content + "的知识........");
    }
}

练习4  【4.c 老师类和学生类的测试类】

package com.groupies.base.day06;

/**
 * @author GroupiesM
 * @date 2021/3/23
 * @introduction 老师类和学生类的测试类
 *
 * 分析以下需求,并用代码实现
 * 1.老师类Teacher
 * 属性:
 * 姓名name
 * 年龄age
 * 讲课内容content
 * 行为:
 * 吃饭
 * 讲课
 * 2.学生类Student
 * 属性:
 * 姓名name
 * 年龄age
 * 学习内容content
 * 行为:
 * 吃饭eat()
 * 学习study()
 * 要求:
 * 1.按照以上要求定义Teacher类和Student类,属性要私有,生成空参 、有参构造,setter和getter方法
 * 2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
 * 3.调用成员方法,打印格式如下:
 * 年龄为30的周志鹏老师正在吃饭....
 * 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
 * 年龄为18的韩光同学正在吃饭....
 * 年龄为18的韩光同学正在专心致志的听着面向对象的知识....("面向对象"代表学生学习的内容)
 */
public class HomeWork4 {
    public static void main(String[] args) {
        HomeWork4POJOStudent student = new HomeWork4POJOStudent("林青霞", 66, "面向对象");
        HomeWork4POJOTeacher teacher = new HomeWork4POJOTeacher("周伯通", 99, "java基础");
        student.eat();//年龄为66的林青霞同学正在吃饭....
        student.study();//年龄为66的林青霞同学正在专心致志的听着面向对象的知识........
        teacher.eat();//年龄为99的周伯通老师正在吃饭....
        teacher.teach();//年龄为99的周伯通老师正在亢奋的讲着java基础的知识........
    }
}

21/03/22

M

你可能感兴趣的:(三.Java,java)