• java面向对象的三大特性之封装和继承（配视频讲解）

    🍅程序员小王的博客：程序员小王的博客
    🍅程序员小王的资源博客：http://wanghj.online/
    🍅 欢迎点赞 👍 收藏 ⭐留言 📝
    🍅 如有编辑错误联系作者，如果有比较好的文章欢迎分享给我，我会取其精华去其糟粕
    🍅java自学的学习路线：java自学的学习路线

    • 封装，继承，多态

      一、封装

    • 博客封装知识点配套视频：

      java中面向对象的三大特性之封装

    • 尽可能的隐藏对象内部实现细节，控制用户的修改和访问权限，保障内部属性（成员变量）的安全

    • 生活中的封装

      image-20221204121705566

    • 不安全的设计

      /**
 * 创建一个类，创建一个模板
 */
public class Account {
    String no;   //卡号
    String password;  //密码
    double balance;  //余额

    public Account() {
    }

    public Account(String no, String password, double balance) {
        this.no = no;
        this.password = password;
        this.balance = balance;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

    • 创建对象

      public class TestAccount {
    public static void main(String[] args) {
        //1. 创建对象
        Account account = new Account();
        //2.设置属性
        account.no="171727213891278"; //非法的卡号
        account.password="123456";    //非法的密码
        account.balance=10000000;   //非法的余额
       //3.访问属性
        System.out.println(account.balance);
    }
}


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13

    • 出现的问题：可以随意访问属性，修改属性，破坏我们对象原有状态，设计不安全

    1、private修饰符

    • public 公共的 private 私有的

    • 概念：修饰程序中的各个组件，被修饰的组件拥有不同的特点与权限

    • 例：用户去银行取钱，有知道账号，密码，余额的权限，但是没有修改余额和账号的权限，银行工作（柜台）人员，他有知道银行卡账号的权限，查看账号余额的权限，重置密码的权限

    • private的特点：

      1. private表示私有的可以修饰属性和方法
       private String no;   //卡号
2. 被修饰的组件只能在本类中使用，对外不可见

      • 1
      • 2
      • 3

    • 例

      public class MyClass {
    int a;
    private  int b;//被private修饰的属性、成员变量 。只能在本类中使用
    public void ma(){
        System.out.println("ma");
    }
    private  void mb(){   //被private修饰的方法/函数,只能在本类中使用
        System.out.println("mb");
    }
}

class TestMyClass{
    public static void main(String[] args) {
        MyClass mc = new MyClass();
        mc.a=1;
        mc.b=2;//编译出错，无权限访问
        mc.ma();
        mc.mb();//编译出错，无权限访问
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20

    2、私有化属性和方法【重点应用】

    • 使用private修饰属性，将属性或方法私有化，控制访问权限

    • 不合理的过度安全

      1. 如果一个类所有的属性或方法都是私有的，那么该类的对象就没有存在的价值了 //比如捡到一张银行卡，就算存十个亿也和你没关系
2. 控制访问权限不是一刀切，有些情况下也是需要访问属性或修改属性的 //疫情下比如生孩子，没做核酸检测也是可以进医院的

      • 1
      • 2

    3、提供访问或修改私有的成员的途径（get/set方法）【重点应用】

    • 成员指属性和方法

    • get/set方主要解决过度安全问题，合理的控制内部属性的安全

    • set方法的语法

      public void set属性名(形参类型 形参名){
    this.属性名=形参名
}
// 1. 形参类型和属性类型必须一致
// 2. 形参名与属性名一致
// 3. 方法中的属性名必须大写

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

    • get方法的语法

    public 返回值类型 get属性名(){
    return 属性;
}
//1. 返回值类型与属性类型一致
//2. 方法中的属性名必须大写

    • 1
    • 2
    • 3
    • 4
    • 5

    • 案例：

      package com.tjcu.whj.account;

/**
 * @author Wanghj
 * @version 1.0
 * @date 2022/12/4 9:14
 * 创建一个类，创建一个模板
 */
public class Account {
    private String no;   //卡号
    /*set方法：
    public void set属性名(形参类型 形参名){
        this.属性名=形参名
    }
    1. 形参类型和属性类型必须一致
    2. 形参名与属性名一致
    3. 方法中的属性名必须大写
    * */
    public void setNo(String no) {
        this.no = no;
    }

    /*
        public 返回值类型 get属性名(){
            return 属性;
        }
        //1. 返回值类型与属性类型一致
        //2. 方法中的属性名必须大写
    * */
    public String getNo() {
        return no;
    }
}
//访问属性或修改属性均改为了调用get.set方法的形式
class TestAccount {
    public static void main(String[] args) {
        //1. 创建对象
        Account account = new Account();
        //2.设置属性
      account.setNo("123455");
        //3.访问属性
        System.out.println(account.getNo());
    }
}



      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46

    4、get、set方法的实际作用

    • 赋值前需要先验证数据的合法性

          private String no;   //卡号
    private String password;  //密码
    private double balance;  //余额

    /*set方法：
    public void set属性名(形参类型 形参名){
        this.属性名=形参名
    }
    1. 形参类型和属性类型必须一致
    2. 形参名与属性名一致
    3. 方法中的属性名必须大写
    * */
    public void setNo(String no) {
        this.no = no;
    }

    /*
        public 返回值类型 get属性名(){
            return 属性;
        }
        //1. 返回值类型与属性类型一致
        //2. 方法中的属性名必须大写
    * */
    public String getNo() {
        return no;
    }
//    get方法
    public String getPassword(){
        return  password;
    }
    //set方法  赋值前需要先验证数据的合法性
    public  void setPassword(String password){//设置密码
        if(password.length()!=8){
            System.out.println("温馨提示：设置密码必须为六位");
            return;// 如果密码不等于8我们则退出，不复制
        }
        this.password=password;
    }

}

class TestAccount {
    public static void main(String[] args) {
        //1. 创建对象
        Account account = new Account();
        //2.设置属性
      account.setNo("123455");
      account.setPassword("12345678");
        //3.访问属性
        System.out.println(account.getNo());
        System.out.println(account.getPassword());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53

    • 封装的意义

      1. 没有封装： 超市没有看守，无人管理，无法保护客户与商品的安全
2. 属性私有： 封住超市的所有入口，大家都不能进超市
3. 封装后：   设置了出口（get）与进口(set),在出入口增加了扫描仪器等设备，保障客户与商品的安全

      • 1
      • 2
      • 3

    image-20221204121837201

    • 设置只读属性：只提供get方法，不提供set方法

      package com.tjcu.whj.account;

/**
 * @author Wanghj
 * @version 1.0
 * @date 2022/12/4 9:14
 * 创建一个类，创建一个模板
 */
public class Account {
    private String no;   //卡号
    private String password;  //密码
    private double balance=1000;  //余额

    /*set方法：
    public void set属性名(形参类型 形参名){
        this.属性名=形参名
    }
    1. 形参类型和属性类型必须一致
    2. 形参名与属性名一致
    3. 方法中的属性名必须大写
    * */
    public void setNo(String no) {
        this.no = no;
    }

    /*
        public 返回值类型 get属性名(){
            return 属性;
        }
        //1. 返回值类型与属性类型一致
        //2. 方法中的属性名必须大写
    * */
    public String getNo() {
        return no;
    }
//    get方法
    public String getPassword(){
        return  password;
    }
    //set方法  赋值前需要先验证数据的合法性
    public  void setPassword(String password){//设置密码
        if(password.length()!=8){
            System.out.println("温馨提示：设置密码必须为六位");
            return;// 如果密码不等于8我们则退出，不复制
        }
        this.password=password;
    }
    //只对余额提供get方法，不提供set
    public double getBalance(){
        return  balance;
    }

}

class TestAccount {
    public static void main(String[] args) {
        //1. 创建对象
        Account account = new Account();
        //2.设置属性
      account.setNo("123455");
      account.setPassword("12345678");
        //3.访问属性
        System.out.println(account.getNo());
        System.out.println(account.getPassword());
        System.out.println(account.getBalance());
    }
}



      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69

    • 私有方法更加安全，仅供内部调用

    public class Computer {
    public void on(){
        startFun();
    }//开机

    private void startFun(){
        System.out.println("供电，检测系统有误故障，主机是否烧坏");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    5、总结

    • 意义： 竟尽可能的隐藏内部对象的实现细节，控制用户对对象的修改和访问权限，保障内部属性的安全

    • 实现方式

      1. 属性私有 private
2. 根据需要提供get/set方法，无特殊情况，两个方法都要提供。

      • 1
      • 2

    二、继承

    • 博客封装知识点配套视频：https://www.bilibili.com/video/BV1ve411N7Ay/?spm_id_from=333.999.0.0

    1、is关系

    • 概念

      is a :爷爷==》爸爸==》我==》儿子==》孙子

      • 1

    • 什么是一种什么。例;

      image-20221204121910788

    • 前者一定具备后者的特征与行为

    2、计算机里面的is a关系

    • 计算机的is a关系叫继承，是一种类与类之间的关系，前者称为父类，后者称为子类（派生类），当继承关系建立时，子类也能拥有父类中的特性（属性）与方法（方法）

    • 语法

    class 类名 extends 父类名{
    
}

    • 1
    • 2
    • 3

    • 举例： hp继承电脑的开机功能

      public class Computer {
    public void on(){
        startFun();
    }//开机

    private void startFun(){
        System.out.println("供电，检测系统有误故障，主机是否烧坏");
    }
}
class Hp extends Computer {

}

class  testHp{
    public static void main(String[] args) {
        Hp hp = new Hp();
        hp.on();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19

      3、继承效果

    • 子类可以继承父类的属性和方法

      package com.tjcu.whj.account;

/**
 * @author Wanghj
 * @version 1.0
 * @date 2022/12/4 10:28
 */
public class Computer {
    public void on() {
        startFun();
    }//开机

    private String name;

    public String getName() {
        return name;
    }

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

    private void startFun() {
        System.out.println("供电，检测系统有误故障，主机是否烧坏");
    }
}

class Hp extends Computer {

}

class testHp {
    public static void main(String[] args) {
        Hp hp = new Hp();
        hp.on();
        hp.setName("惠普");
        System.out.println(hp.getName());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39

    • 继承的传递性：子类可以有父类，父类可以有父类，父类的父类可以还有父类，所以属性和方法会一直向下传递

      package com.tjcu.whj;

/**
 * @author Wanghj
 * @version 1.0
 * @date 2022/12/4 11:07
 */
public class TestIntan {
    public static void main(String[] args) {
        MyClassF myClassF = new MyClassF();//孙子
        System.out.println(myClassF.);
    }
}
class MyClassA{//祖祖
    int a;
}
class MyClassB extends  MyClassA{//爷爷
    int b;
}
class MyClassC extends MyClassB{//爸爸
    int c;
}
class MyClassD extends  MyClassC{//我
    int d;
}
class MyClassE extends  MyClassD{//儿子
    int e;
}
class MyClassF extends  MyClassE{//孙子
    int f;
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31

    • java中的继承关系为单继承（符合中国原来的独生子女政策），一个类只能有一个直接父类，但是可以间接继承（多层继承）

    3、访问修饰符（必须掌握）

    • 作用组件作用范围

      修饰符本类同包其他包的子类任意位置解释
      private❤️只能在同类中使用
      default(什么也不写)❤️❤️只能一个类中或者一个包中访问
      protected(被保护的)❤️❤️❤️
      public❤️❤️❤️❤️都可以访问

    • 当什么都不写的时候，默认为default

    4、方法的覆盖

    • 使用于子类父类之间，子类可以继承父类的方法也可以覆盖掉父类的方法

      public class Father  {
    protected void eat(){
        System.out.println("吃饭");
    }
}


class  My extends  Father{
//覆盖：访问权限修饰符必须相同或更宽，返回值类型，方法名，参数表必须相同
   public void eat(){
       System.out.println("王恒杰喜欢吃烧烤");
    }
}

class testMy{
    public static void main(String[] args) {
        My my = new My();
        my.eat();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20

    • 覆盖定义：访问权限修饰符必须相同或更宽，返回值类型，方法名，参数表必须相同

    • 重载：方法名相同，返回值类型相同，参数列表不同（个数，顺序，类型）

    三、复习

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VP14EaUy-1670127776630)(C:\Users\王恒杰\AppData\Roaming\Typora\typora-user-images\image-20221204121612674.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pcihfm5D-1670127776630)(C:\Users\王恒杰\AppData\Roaming\Typora\typora-user-images\image-20221204121626995.png)]

    四、面向对象封装和继承课后习题（答案版本）

    考察知识点：

    • 类的定义

    • 类的组成​

    • 对象的创建

    客观题

    1. （类与对象的概念）下列描述错误的是（ c ）
      a. 类是对象的模板
      b. 对象是类的实例
      c. 面向对象思想是将功能拆分为若干小步，逐步求精解决问题
      d. 面向对象是从对象入手，把涉及到的所有对象找到，借助于对象和对象间相互配合，实现需求

    2. （实例变量） 下列关于属性描述不正确的是( c )

      a. 属性定义在类以内，方法以外
      b. 属性又称为成员变量
      c. 属性的作用范围从定义开始，到定义它的代码块结束
      d. 属性定义后可以在本类中直接使用

    3. （方法重载）有关方法重载描述错误的是( d )

      a. 方法名相同
      b. 返回值类型相同
      c. 参数列表不同
      d. 参数列表相同

    4. （方法重载）下列和 public void method(){}不能构成方法重载的是( d )

      a. public void method(double d){}
      b. public void method(int n){}
      c. public int method(int n){}
      d. public int method(){}

    5. （构造方法）下列对构造方法描述不正确的是( c )
      a. 构造方法是特殊的方法，允许重载
      b. 方法名必须和类名相同
      c. 一个类必须手动提供构造方法
      d. 构造方法不允许手动调用

    6. （重载，构造方法）已知有以下代码：

      public class ClassA{
    public void ClassA(String str){}
    public void test(){}
}    

      • 1
      • 2
      • 3
      • 4

      对以上程序描述正确的是( c )

      a. 编译报错
      b. ClassA类中定义了有参数的构造方法
      c. ClassA类中只有一个默认的无参数的构造方法
      d. test方法不允许手动的调用

    7. （创建对象） 已知有以下代码：

      public class Test{
    public static void main(String[] args){
        Worker w = new Worker();
        w.work();
    }
}
class Worker{
    String name;
    public Worker(String n ){
        name = n;
    }
    public void work(){
        System.out.println("working.....");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15

      对以上程序描述正确是的（ a ）

      a. 没有无参构造方法，编译报错
      b. 没有为name属性赋值，编译报错
      c. 输出 working…
      d. 编译成功，运行报错

    8. （构造方法）构造方法什么时候会被使用( b )
      a. 类定义时
      b. 创建对象时
      c. 调用对象方法时
      d. 使用对象引用时

    9. （重载，实例变量）根据以下代码，请选择正确结果（ c ）

      class ClassA{
    public void method(int value){
        System.out.println( value );
    }
    public void method(){
        System.out.println( value );
    }
    int value;
}
public class TestClassA{
    public static void main(String[] args){
        ClassA ca = new ClassA();
        ca.value = 10;
        ca.method();
        ca.method(20);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

      a. 编译不通过
      b. 输出10 10
      c. 输出10 20
      d. 输出0 20

    10. (方法重载)有以下代码

      class ClassA{
    public void method(){
        System.out.println("method()");
    }
    public void method(int i){
        System.out.println("method(int)");
    }
    public static void main(String[]args){
        ClassA ca = new ClassA();
        ca.method();
        ca.method( 10 );
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13

      该程序是否能编译通过？
      如果可以，写出该程序运行结果，如果不能，请说明理由，以及如何修改。

      可以 运行结果为：

      method()
method(int)

      • 1
      • 2

    11. (构造方法)关于构造方法，下列说法正确的是（ b d ）[多选]
      a. 每个类中都有至少需要写一个构造方法
      b. 一个类中可以有多个构造方法
      c. 构造方法可以有返回值
      d. 构造方法可以有多个参数

    12. (构造方法)有以下代码：

      class ClassA{
    int value;
}
public class TestMyClass{
    public static void main(String[]args){
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass(10);
        System.out.println( mc1.value );
        System.out.println( mc2.value );
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

      这个程序能否编译通过？如果可以，输出结果是什么；如果不可以，应该如何修改？
      不正确，应改为

      class MyClass{
    int value;
    public MyClass(){}
    public MyClass(int a){
        value = a;
    }
}
public class TestMyClass{
    public static void main(String[]args){
        MyClass mc1 = new MyClass();
        MyClass mc2 = new MyClass(10);
        System.out.println( mc1.value );
        System.out.println( mc2.value );
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15

    主观题

    1. (面向对象基础)根据注释，把//1//2//3//4//5//6处代码补充完整

      class Dog{
    //定义一个name属性，该属性为String类型
    String name;
    //定义一个sex属性，该属性为boolean类型
    boolean sex;
    public Dog(){}
    public Dog(String n,boolean s){
        //分别根据参数，设置Dog类的属性
        name = n;
        sex =  s;
    }
    public void play(){
        System.out.println(name+"play");
    }
    public void play(int n ){
        System.out.println(name+"play"+n+"minutes");
    } 
}
public class TestDog{
    public static void main(String[]args){
        Dog d;
        //使用有参构造方法创建一个Dog对象，名字为joy,性别为公(false)
        d = new Dog("joy",false);
        //调用Dog对象的无参play方法
        d.play();
        //调用Dog对象的有参play方法，参数为30
        d.play(30);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29

    2. 编程：(面向对象基础–工人类)写一个Worker类，并创建多个Worker对象

      ①为Worker类添加三个属性:

      String类型的name,表示工人的姓名
      int类型的age，表示工人的年龄
      double类型的salary,表示工人的工资

      ②为Worker类添加两个构造方法：

      公开无参构造方法
      接受三个参数的构造方法，三个参数分别为String、int和double

      ③为Worker类添加两个work(工作) 方法:

      无参的work方法，打印工人在工作
      带有整数参数的方法，表示工人工作的时间（单位：小时），打印工人工作了几小时
      代码示例：

      class Worker{
    String name;//姓名
    int age;//年龄
    double salary;//工资
    //构造方法
    public Worker(){}
    public Worker(String n,int a, double s){
        name = n;
        age = a;
        salary = s;
    }
    //普通方法
    public void work(){
        System.out.println("工人在工作");
    }
    public void work(int hours){
        System.out.println("工人工作了"+hours+"小时");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19

    3. 编程：(面向对象基础–地址类)创建一个Address类，定义两个属性，String类型的address表示地址，String类型的zipCode表示邮编，并提供有参、无参构造方法
      代码示例：

      class Address{
    String address;//地址
    String zipCode;//邮编
    //构造方法
    public Address(){}
    public Address(String a,String z){
        address = a;
        zipCode = z;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10

    4. 编程：定义一个Teacher类，姓名(String) 年龄(int) 性别(boolean),要求如下：
      ① 提供无参数、有参数的构造方法
      ② 功能方法teach(),返回值类型为void，打印姓名+“正在上课”
      ③ 编写测试类，创建年龄为16岁的小小老师，调用teach方法
      代码示例：

      //教师类
class Teacher{
    String name;//姓名
    int age;//年龄
    boolean sex;//性别（false=男、true=女）
    //构造方法
    public Teacher(){}
    public Teacher(String n,int a,boolean s){
        name = n;
        age = a;
        sex = s;
    }
    public void teach(){
        System.out.println(name+"正在上课");
    }
}

//测试类
public class TestTeacher{
    public static void main(String[]args){
        //创建对象
        Teacher t = new Teacher("小小",18,true);
        //调用方法
        t.teach();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    5. 编程：定义一个网络用户类(User 类)，需要处理的信息有用户 id、用户密码 password、邮箱地址(email)，要求如下：

      ① 提供带有两个参数的构造方法，为用户 id 和用户密码赋值，此时 email 采用默认的：id加上"@zparkhr.com.cn"赋值;
      ②提供带有三个参数的构造方法
      ③提供一个show 方法，用于展示用户的信息，密码处理为 *** 形式显示
      ④定义一个测试类，创建对象，并展示用户的信息

      代码示例：

      //用户类
class User{
  String id;//用户id
  String password;//密码
  String email;//邮箱
  //构造方法
  public User(String i,String p){
      id = i;
      password = p;
      //邮箱默认为id+@zparkhr.com.cn
      email = id+"@zparkhr.com.cn";
  }
  public User(String i,String p,String e){
      id = i;
      password = p;
      email = e;
  }
  //普通方法
  public void show(){
      System.out.println("用户id："+id);
      System.out.println("密码：******");
      System.out.println("邮箱："+email);
  }
}
//测试类
public class TestUser{
    public static void main(String[]args){
        //创建对象
        User u = new User("zhangsan","123456");
        //调用show方法
        u.show();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33

    6. 编程：定义一个 Book 类(代表教材)，具有属性名称(title)、页数(pageNum)，要求如下：
      ① 提供无参数和有参数的构造方法
      ② 编写一个测试类，创建对象并为属性赋值，将对象的信息展示在控制台上
      代码示例：

      //教材类
class Book{
    String title;//名称
    int pageNum;//页数
    //构造方法
    public Book(){}
    public Book(String t,int n){
        title = t;
        pageNum = n;
    }
}
//测试类
public class TestBook{
    public static void main(String[]args){
        //创建对象
        Book b = new Book("CoreJava从入门到跑路",5000);
        //打印各个属性
        System.out.println( b.title );
        System.out.println( b.pageNum );
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21

    7. 编程：定义一个 Student 类，具有属性有名字（name）、年龄（age）、地址（address）、 邮编（zipcode）、电话（mobile）
      ① 为 Student 类添加一个 getPostAddress 方法，要求返回 Student 对象的地址和邮编
      ②定义一个测试类，创建对象并为属性赋值，将用户的信息进行展示

      代码示例：

      class Student{
    String name;
    int age;
    String address;
    String zipCode;
    String mobile;
    public Student(String n,int a,String ad,String z, String m){
        name = n;
        age = a;
        address = ad;
        zipCode = z;
        mobile = m;
    }
    //返回地址与邮编，地址与邮编都是String类型，采用字符串拼接并返回
    public String getPostAddress(){
        return address + zipCode;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    8. 编程：模拟简单的计算器，定义一个类(Number)，类中定义两个整数类型的属性值 double v1和double v2；
      ①提供两个构造方法，可以为属性赋值
      ②提供加( add() )、减( subtration() )、乘( multip() )、除( division() )功能方法
      ③定义一个测试类，创建该类对象，并通过调用方法完成两个数值的加、减、乘、除运算
      代码示例：

      class Number{
    double v1;
    double v2;
    //构造方法
    public Number(){}
    public Number(double a,double b){
        v1 = a;
        v2 = b;
    }
    //加方法
    public double add(){
        return a+b;
    }
    //减方法
    public double subtration(){
        return a-b;
    }
    //乘方法
    public double multip(){
        return a*b;
    }
    //除方法
    public double division(){
        return a/b;
    }
}
//测试类
public class TestNumber{
    public static void main(String[]args){
        //创建对象
        Number n = new Number(10,2);
        //调用方法获取结果
        double r1 = n.add();
        double r2 = n.subtration();
        double r3 = n.multip();
        double r4 = n.division();
        //打印输出结果
        System.out.println( r1 );
        System.out.println( r2 );
        System.out.println( r3 );
        System.out.println( r4 );
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43

    提高题

    1. 编程：在编程题3、4题的基础上为工人类中添加属性地址addr，该属性的类型为Address类型
      要求：
      ①创建工人对象，其姓名为“zhangsan”，年龄为25，工资为2500
      ②创建地址对象，家庭住址为“北京市海淀区清华园1号”，邮政编码为100084。
      ③使用地址对象为工人对象中的addr属性赋值，表示工人的地址

      代码示例：

      //1.创建Worker对象
Worker worker = new Worker("zhangsan", 25, 2500D);
//2.创建地址对象
Address address = new Address("北京市海淀区", "100094");
//3.为worker对象中的addr属性赋值
//方式一：创建好对象后再为属性赋值
worker.addr = address;
//方式二：创建对象时使用构造方法为属性赋值
Worker worker2 = new Worker("lisi",28,5000D,address);

//打印输出worker中的信息与地址信息
System.out.println(worker.name);
System.out.println(worker.age);
System.out.println(worker.salary);
        
//链式访问，获取worker对象中的addr属性，再访问addr对象中的address属性
System.out.println(worker.addr.address);
System.out.println(worker.addr.zipCode);
  double r4 = n.division();
        //打印输出结果
        System.out.println( r1 );
        System.out.println( r2 );
        System.out.println( r3 );
        System.out.println( r4 );
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    提高题

    1. 编程：在编程题3、4题的基础上为工人类中添加属性地址addr，该属性的类型为Address类型
      要求：
      ①创建工人对象，其姓名为“zhangsan”，年龄为25，工资为2500
      ②创建地址对象，家庭住址为“北京市海淀区清华园1号”，邮政编码为100084。
      ③使用地址对象为工人对象中的addr属性赋值，表示工人的地址

      代码示例：

      //1.创建Worker对象
Worker worker = new Worker("zhangsan", 25, 2500D);
//2.创建地址对象
Address address = new Address("北京市海淀区", "100094");
//3.为worker对象中的addr属性赋值
//方式一：创建好对象后再为属性赋值
worker.addr = address;
//方式二：创建对象时使用构造方法为属性赋值
Worker worker2 = new Worker("lisi",28,5000D,address);

//打印输出worker中的信息与地址信息
System.out.println(worker.name);
System.out.println(worker.age);
System.out.println(worker.salary);
        
//链式访问，获取worker对象中的addr属性，再访问addr对象中的address属性
System.out.println(worker.addr.address);
System.out.println(worker.addr.zipCode);

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
  • 相关阅读:
    Spark - Task 与 Partition 一一对应与参数详解
    Nginx入门+实战
    【中国电工技术学会主办】2022年能源，电力与电气工程国际研讨会（CoEEPE 2022）
    SRDenseNet
    详解：取地址操作符（&）及解引用操作符（*）
    【设计模式】桥接模式在开发中的应用
    【QT】Dialog对话框
    Object.defineProperty方法
    Failed to find a valid digest in the 'integrity' attribute for resource
    数据结构知识点总结11-(第六章.图)-图的基本概念
  • 原文地址：https://blog.csdn.net/weixin_44385486/article/details/128171102