3.封装和继承

最新推荐文章于 2024-07-15 22:27:18 发布

程序员阿磊

最新推荐文章于 2024-07-15 22:27:18 发布

阅读量76

点赞数

分类专栏： # 2.Java面向对象文章标签： java 后端 intellij-idea jvm

本文链接：https://blog.csdn.net/m0_62112791/article/details/125894340

版权

2.Java面向对象专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.封装(set,get)

面向对象三大特征之一

1.1、封装的概念

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
把尽可能多的东西藏起来，对外提供便捷的接口

1.2、访问修饰符

使用访问修饰符修饰不想让别人知道的，和一定让别人知道的

[default | public | protected | private] 其中，default就是没有任何修饰符词

private:表示私有及这个类所有，这个类之外的任何代码都不可以访问
public:表示公开的，所有地方都可以访问
protected：表示受保护的，是在子类中可以访问的，即便不在同一个包下

1.3、封装的好处

便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性
提高软件的可重用性
降低了构建大型系统的风险

2.包(package)

包：有效的管理类，解决类的命名冲突问题。
package 包名称
package:包的定义，包存在，是以目录形式表现
包定义只能在源代码中的第一行位置出现
只允许有一个package语句

包的命名规范

包名由小写字母组成，不能以圆点开头或结尾
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
包名后续部分依不同机构内部的规范不同而不同
部门名.项目名例如：com.bigdata09.day01

理解了import的作用

3.继承(extends)

面向对象三大特征之二

继承的关键字：extends
Java只支持单继承，也就是最多继承一个父类。
子类与父类是is-a关系

解决问题

不劳而获
is-a 的现象

带来的问题

耦合强了

开发中如何取舍？

4.面向对象的设计原则(8种)：

开闭原则：

面向对象可复用设计原则中最基础的原则便是开闭原则（Open-Closed Principle，OCP）。开闭原则指的是在设计一个对象（类、模块、函数）时，应遵循或做到对扩展开放、对修改关闭，其核心思想是面向接口/抽象进行编程。比如第四方支付平台，集成微信支付服务时，遵循开闭原则的话，正常的做法就是先抽象设计一个支付接口，然后微信支付类实现该支付接口。以后平台集成更多如支付宝、华为、苹果等支付服务时，只需要扩展一个对应支付方式的支付类即可，这样既扩展了新的支付服务，同时避免了修改现有的支付接口以及微信支付类，最大限度保证了新代码不会影响现有的业务代码。这就是对扩展（新对象）开放，对修改（现有对象）关闭。

对代码修改时，那些是可以修改，那些是不建议修改。

在类的继承过程中，子类可以继承父类public的东西(构造方法除外) ，和 protected 和同包下defaule修饰级别的东西

5.方法重写(Override)

在类的继承过程中：子类不满意父类的方法怎么办？ 方法重写重写的关键字：Override

方法重写：是发生在继承中，子类重新定义了父类方法的现象

5.1、super关键字

super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员

super 和 this 一样，是一个伪引用
super 父类对象的引用
this 表示当前对象的引用

当前阶段回顾总结：封装，继承，方法重写，访问修饰符，包定义和规范(包的名字中不建议出现大写字母)

6.final 关键词

final 修饰类时，类不可以继承
final 修饰方法时，方法不可以被重写
final 修饰变量时，变量只允许赋值一次

后续课程学习：泛化和多态

案例：累加App
方式一：

public class AddApp {
    public static void main(String[] args) {
        // 在控制台不断输入数字并回车，直到输入bye结束程序，此时程序输出你在控制输入的所有数字之和
        Scanner scanner = new Scanner(System.in);
        System.out.println("请不断输入数字：");
        int sum = 0;
        String shang = "0";
        String s = "0";
        while (true){
            shang = s;
            s = scanner.nextLine();
            if (s.equals("bye")){
                System.out.println("累计总数之和是："+sum);
                break;
            }
            if (s.equals("back")){
                System.out.println("返回上一步！");
                sum -= Integer.parseInt(shang);
                continue;
            }
            sum += Integer.parseInt(s);
        }
    }
}

方式二：

public class Add {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入数字：");

        SupperAddOr addOr = new SupperAddOr();

        while (true){
            String s = scanner.nextLine();
            //addOr.sum = 0;
            if (s.equals("bye")){
                System.out.println("综合："+addOr.show());
                break;
            }
            if (s.equals("back")){
                addOr.back();
                continue;
            }

            addOr.put(s);
        }
    }
}

public class SupperAddOr extends AddOr {

    // 代码复用 不是只有继承一种方式，在不能使用继承手段复用代码的时候，我们使用组合手段复用代码
    //private AddOr addOr = new AddOr();
    // 存档副本
    private int bak;

    public void back() {
        this.setSum(bak);
        //addOr.setSum(bak);   // 就是把上一次累加时的存档副本，设置为当前累加
    }

    // 方法重写
    @Override
    public void put(String s) {
        this.bak = super.getSum();  // 每次累加时记录累加之前的副本
        super.put(s);   // 调用的父类的代码

    }
}

复制public class AddOr {
    // 成员变量
    private int sum;

    public int getSum() {
        return sum;
    }

    public void setSum(int sum) {
        this.sum = sum;
    }

    public int show() {

        return sum;
    }

    public void put(String s) {
        sum += Integer.parseInt(s);
    }
}