Java基础笔记(5)

1.1、面向对象的三大特征：
    封装
    继承
    多态

    有了封装，才有继承，有了继承，才能说多态。

1.2、面向对象的首要特征：封装 。什么是封装？有什么用？
    现实生活中有很多现实的例子都是封装的，例如：
        手机，电视机，笔记本电脑，照相机，这些都是外部有一个坚硬的壳儿。
        封装起来，保护内部的部件。保证内部的部件是安全的。另外封装了之后，
        对于我们使用者来说，我们是看不见内部的复杂结构的，我们也不需要关心
        内部有多么复杂，我们只需要操作外部壳儿上的几个按钮就可以完成操作。

    那么封装，你觉得有什么用呢？
        封装的作用有两个：
            第一个作用：保证内部结构的安全。
            第二个作用：屏蔽复杂，暴露简单。
        
    在代码级别上，封装有什么用？
        一个类体当中的数据，假设封装之后，对于代码的调用人员来说，
        不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。
        另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，
        来保证数据的安全性。
    
1.3、怎么进行封装，代码怎么实现？
 

第一步：属性私有化

第二步：1个属性对外提供两个set和get方法。外部程序只能通过set方法修改，只能通过get方法读取，
可以在set方法中设立关卡来保证数据的安全性。

在强调一下：
    set和get方法都是实例方法，不能带static。
    不带static的方法称为实例方法，实例方法的调用必须先new对象。

 

2、继承extends

2.1、什么是继承，有什么用？

继承：在现实世界当中也是存在的，

继承的作用： 基本作用：子类继承父类，代码可以得到复用。

主要(重要)作用：因为有了继承关系，才有了后期的方法覆盖和多态机制。

2.2、继承的相关特性
    ① B类继承A类，则称A类为超类(superclass)、父类、基类，
      B类则称为子类(subclass)、派生类、扩展类。
        class A{}
        class B extends A{}
       
​
    ② java 中的继承只支持单继承，不支持多继承
​
    ③ 虽然 java 中不支持多继承，但有的时候会产生间接继承的效果，
    例如：class C extends B，class B extends A，也就是说，C 直接继承 B，
    其实 C 还间接继承 A。
​
    ④ java 中规定，子类继承父类，除构造方法不能继承之外，剩下都可以继承。
    但是私有的属性无法在子类中直接访问。(父类中private修饰的不能在子类中
    直接访问。可以通过间接的手段来访问。)
​
    ⑤ java 中的类没有显示的继承任何类，则默认继承 Object类，Object类是 
    java 语言提供的根类，也就是说:一个对象与生俱来就有Object类型中所有的特征。
​
    ⑥ 继承也存在一些缺点，例如：CreditAccount 类继承 Account 类会导致它
    们之间的耦合度非常高，Account 类发生改变之后会马上影响到 CreditAccount 类

3、继承extends

测试：子类继承父类之后，能使用子类对象调用父类方法吗？
    可以，因为子类继承了父类之后，这个方法就属于子类了。
    当然可以使用子类对象来调用。
​
​
任何一个类，没有显示继承任何类，默认继承Object
    
    你现在能看懂以下代码了吗？
        System.out.println("Hello World!");
        System.out 中，out后面没有小括号，说明out是变量名。
        另外System是一个类名，直接使用类名System.out，说明out是一个静态变量。
        System.out 返回一个对象，然后采用“对象.”的方式访问println()方法。
    
    我们研究了一下Object类当中有很多方法，大部分看不懂，其中有一个叫做toString()
    的，我们进行了测试，发现：
        System.out.println(引用);
        当直接输出一个“引用”的时候，println()方法会先自动调用“引用.toString()”，然后
        输出toString()方法的执行结果。

4、多态在开发中有什么作用？

多态在开发中的作用是：
    降低程序的耦合度，提高程序的扩展力。
​
    public class Master{
        public void feed(Dog d){}
        public void feed(Cat c){}
    }
    以上的代码中表示：Master和Dog以及Cat的关系很紧密（耦合度高）。导致扩展力很差。
​
    public class Master{
        public void feed(Pet pet){
            pet.eat();
        }
    }
    以上的代表中表示：Master和Dog以及Cat的关系就脱离了，Master关注的是Pet类。
    这样Master和Dog以及Cat的耦合度就降低了，提高了软件的扩展性。
​
面向对象的三大特征：
    封装、继承、多态
​
    真的是一环扣一环。
​
    有了封装，有了这种整体的概念之后。
    对象和对象之间产生了继承。
    有了继承之后，才有了方法的覆盖和多态。
​
这里提到了一个软件开发原则：
    七大原则最基本的原则：OCP（对扩展开放，对修改关闭）
    目的是：降低程序耦合度，提高程序扩展力。
    面向抽象编程，不建议面向具体编程。

2、解释之前遗留的问题

私有方法无法覆盖。
​
方法覆盖只是针对于“实例方法”，“静态方法覆盖”没有意义。（这是因为方法覆盖通常和多态联合起来）
​
总结两句话：
    私有不能覆盖。
    静态不谈覆盖。
​
在方法覆盖中，关于方法的返回值类型。
    什么条件满足之后，会构成方法的覆盖呢？
        1、发生具有继承关系的两个类之间。
        2、父类中的方法和子类重写之后的方法：
            具有相同的方法名、相同的形式参数列表、相同的返回值类型。
    
    学习了多态机制之后：
        “相同的返回值类型”可以修改一下吗？
            对于返回值类型是基本数据类型来说，必须一致。
            对于返回值类型是引用数据类型来说，重写之后返回值类型可以变的更小.

3、super关键字

super能出现在实例方法和构造方法中。
​
super的语法是：“super.”、“super()”
​
super不能使用在静态方法中。
​
super. 大部分情况下是可以省略的。
​
super.什么时候不能省略呢？
    父类和子类中有同名属性，或者说有同样的方法，
    想在子类中访问父类的，super. 不能省略。
​
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中
的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。
​
super的使用：
    super.属性名               【访问父类的属性】
    super.方法名(实参)       【访问父类的方法】
    super(实参)                   【调用父类的构造方法】