封装(生成getter和setter)

封装的必要性

  1. 在对象的外部,为对象的属性赋值,可能存在非法数据的录入
  2. 就目前的技术,并没有办法对属性的赋值加以控制

    什么是封装

  3. 在编程中,要求代码高内聚,当A对象被被B对象调用的时候,B对象就不需要了解A对象的细节

  4. 在面向对象设计中,用封装的手段来对对象的具体细节进行屏蔽

    类的封装

  5. 主要是针对类的属性、构造方法、一般方法

  6. 封装的过程
    1. 利用修饰符来调整属性、方法的可见性
    2. 对于需要开发的属性或者是方法,可以再次通过封装其他的开发方法进行暴露
  7. 公共访问方法:属性两个重要的封装方法、、作用:保证数据的正常录入

    1. 取值getter:通过对属性的封装,获取属性的具体值

      1. 返回的类型是被封装属性的类型
      2. 必须使用小写get开头
      3. 属性名称在get之后,且第一个字母大写
        1. private int money;
        2. public int getMoney(){//返回的类型一致,属性名称在get之后,且第一个字母大写
        3. return money;//具有返回值
        4. }
    2. 赋值setter:通过对属性的封装,获取属性的具体值

      1. 输入的参数类型要和封装变量的类型一致,没有返回值
      2. 必须使用小写get开头
      3. 属性名称在set之后,且第一个字母大写
      4. 在方法内部进行修改
        1. private int money;
        2. public void setMoney(int money){
        3. this.money=money;
        4. }
  8. 过滤有效数据

    1. 概念方法:在公共访问区,添加逻辑判断,对数据进行判断处理,进而过滤掉非法数据,确保数据的安全性
      1. private int money;
      2. public void setMoney(int money){
      3. if(money>5000){
      4. this.money=this.money-5000;
      5. }else{
      6. System.out.printIn("余额不足");
      7. }
  9. 方法不需要强制进行封装,主要更具业务需求来指定

    修饰符

    public:共有的,其他类可以调用
    private:私有的,其他类不可以调用,只有自己的方法才可以调用
    protected:受到保护的
    不写:默认的
    image.png
    image.png

    继承(extends)

    概念

    让一个类继承另一个类的方法和属性

    基本使用

  10. 创建一个父类,定义相关的属性和方法 ```java public class MyFather{//创建一个父类 private String name;//将姓名设置私有的修饰符 protected int money;//将金钱设置为受到保护的 } //方法 public MyFather(){ this.name=name; this.monry=10000; }

  1. 2. 创建一个子类,继承父类,使用extends关键字继承
  2. ```java
  3. public class MyChlid extends MyFather{//extends继承父类的属性和方法
  4. public int getMoney(){//设置getter封装方法进行取值
  5. return this.money;
  6. }
  7. }
  1. 在使用的时候,直接通过子类创建对象,就可以获取父类的属性和方法 ```java public static void main(String[] args) { MyChild myChild = new MyChild(); System. out. println(myChild. getMoney()); }
  1. 4. 子类在继承父类的时候,会默认继承无参构造方法,一旦父类没有无参构造方法,就会报错,
  2. 怎么去改:在子类继承处ctrl+enter,这时候会自动在子类创建构造方法将(this.money=money;)修改为(super(money));意为利用super指向父类的构造方法,获取money属性
  3. <a name="ICANx"></a>
  4. ### 方法的重写(override)
  5. 基本概念:属于一种多态,但是必须在继承的前提下才能使用
  6. 1. 子类在继承父类之后,将父类的方法重写
  7. 1. 可以使得不同的子类具备不同的特征
  8. 1. Java中,所有的类都有一个父类叫Object,常见的被重写的方法
  9. 1. toString();将对象属性转换成字符串,快捷键toString![image.png](https://cdn.nlark.com/yuque/0/2022/png/27938480/1651115667591-8d8f9dc8-c4d3-41f9-b59e-75c5996739c2.png#clientId=u056eed5e-5375-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=385&id=ubd37a354&margin=%5Bobject%20Object%5D&name=image.png&originHeight=385&originWidth=727&originalType=binary&ratio=1&rotation=0&showTitle=false&size=103849&status=done&style=none&taskId=ub593385c-4fe5-447f-9dd7-799bac6260c&title=&width=727)
  10. 1. equals();通过重写equals(Object obj),实现类判断相等功能![image.png](https://cdn.nlark.com/yuque/0/2022/png/27938480/1651116555453-6e8f92ff-79b0-4b8a-9c0c-3025572a58ef.png#clientId=u056eed5e-5375-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=546&id=uc8d0bfed&margin=%5Bobject%20Object%5D&name=image.png&originHeight=546&originWidth=910&originalType=binary&ratio=1&rotation=0&showTitle=false&size=191803&status=done&style=none&taskId=u0edc11c7-c776-4247-b312-2830f7cfe92&title=&width=910)
  11. <a name="hAZ0H"></a>
  12. ### Super
  13. <a name="c4yIe"></a>
  14. ### 概念
  15. 指向父类对象的引用,
  16. <a name="VXIBJ"></a>
  17. ### 两个作用
  18. 1. 可以调用父类的方法和属性![image.png](https://cdn.nlark.com/yuque/0/2022/png/27938480/1651125052180-44ee23e8-b1d4-41a9-bf50-7caef7386d30.png#clientId=u056eed5e-5375-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=185&id=uf2dd928c&margin=%5Bobject%20Object%5D&name=image.png&originHeight=185&originWidth=960&originalType=binary&ratio=1&rotation=0&showTitle=false&size=86201&status=done&style=none&taskId=u68ae50a3-7d2a-4d2a-97e7-624f096fe7d&title=&width=960)
  19. 1. 可以调用父类的构造方法
  20. 1. 每个类中都会带一个无参的构造方法,当无参的构造方法重载以后,默认的无参构造方法失效
  21. 1. 一个子类继承父类之后,在使用子类创建对象的时候,必须要调用父类的构造方法(默认情况下,是调用的父类的默认无参构造方法)![image.png](https://cdn.nlark.com/yuque/0/2022/png/27938480/1651126294065-95ba8a5e-2d89-4412-b6ef-91e200df7772.png#clientId=u056eed5e-5375-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=658&id=u29ea965d&margin=%5Bobject%20Object%5D&name=image.png&originHeight=658&originWidth=904&originalType=binary&ratio=1&rotation=0&showTitle=false&size=204459&status=done&style=none&taskId=u278f7ad9-62f1-4885-ad60-b82a580e288&title=&width=904)
  22. 1. 旦父类构造方法被重载之后,默认的构造方法失效了,那么子类默认情况下就无法调用到父类默认无参的构造方法(简单解决:给父类再加一个无参的构造方法)
  23. 1. 解决方法:
  24. 1. 给父类再加一个无参的构造方法
  25. 1. 在子类中通过super调用父类有参的构造方法
  26. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/27938480/1651126445626-0a744dbf-e418-4494-9a31-5e8d0484ffd6.png#clientId=u056eed5e-5375-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=196&id=u68233b7e&margin=%5Bobject%20Object%5D&name=image.png&originHeight=196&originWidth=736&originalType=binary&ratio=1&rotation=0&showTitle=false&size=58409&status=done&style=none&taskId=u87b94c2e-a1a1-4891-8f45-a7df9189391&title=&width=736)
  27. <a name="nSaYI"></a>
  28. ## 多态
  29. <a name="ujPhq"></a>
  30. ### 概念
  31. 1. 建立在继承的基础之上,父类引用指向子类对象,从而产生多次形态
  32. 1. 父类引用仅可调用父类所声明的属性和方法,不可调用子类独有的属性和方法
  33. 1. 如果子类重写了父类的方法,那么通过父类在调用方法的时候,不同的子类就会有不同的调用方式
  34. <a name="ogL7d"></a>
  35. ### 拆箱与装箱
  36. 装箱:向上转型,使用父类指向子类对象叫做装箱
  37. ```java
  38. Father f=new Hero;//Father是Hero的父类

拆箱:向下转型,将父类的引用强制转换成子类的类型

  1. hero h1=(hero)f;//hero是f的子类
  2. h1.skill();

image.png
image.png
拆箱和装箱不会对new出来的对象造成任何影响

类型转换异常

只有父子之间才能转换,兄弟之间不能转换

instance of关键字

向下转型前,应判断引用中的对象真实类型,保证类型转换的正确性。
语法:父类引用instance of类型//返回boolean类型结果
image.png