Javax小白成长日记之面向对象三大特性

面向对象三大特性

封装

理解：

比如生活中我们的背包，我们总想着把一些东西放在背包里，怕把他弄丢了，或者说可以放在背包李更方便。封装呢就是把一些功能封装在方法里。

概念：

程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴
露少量的方法给外部使用。利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立
实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。
系统的其他部分只有通过包裹在数据外面的被授权的操作来与这个抽象数据类型交流与交互。也就是说，用户无需
知道对象内部方法的实现细节，但可以根据对象提供的外部接口(对象名和参数)访问该对象。

作用：

a)、实现了专业的分工。将能实现某一特定功能的代码封装成一个独立的实体后，各程序员可以在需要的时候调
用，从而实现了专业的分工,即工作中的分模块、分功能开发。
b)、隐藏信息，实现细节。通过控制访问权限可以将可以将不想让客户端程序员看到的信息隐藏起来，如某客户的
银行的密码需要保密，只能对该客户开发权限

访问权限：

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

当然想要访问私有变量我们需要set，get方法。

继承

继承

继承：子承父业

继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。同时使用
继承可以提高代码的复用性。（事实上，利用组合可以更好的实现代码复用！）extends的意思是“扩展”。子类是
父类的扩展

语法规则:

java中使用extends关键字实现类的继承机制

class [extends ]{}

作用:

实现代码的复用，延续+扩展父类信息。
通过继承，子类自动拥有了基类的所有成员（成员变量和成员方法）。

注意:

java 中只有单继承，没有像 c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。 “一个
孩子只有一个亲爸爸” 。
即 Java只支持单继承，不允许多继承：一个子类只能拥有一个直接基类，但是一个基类可以派生出多个子类

重写

父类不满足子类的要求，按需改写。注意 方法签名必须相同
“==”：方法名、形参列表相同。
“≤≤”：返回值类型(基本类型必须相同)和异常类型，子类小于等于父类。
“≥”：访问权限，子类大于等于父类

    @Override
    public void work() {
        System.out.println("我是一名学生");
    }

注意属性不会重写 注意以下方法不会重写
1、静态方法不会重写 ，父类为静态，子类只能为静态，否则编译错误
2、final 修饰方法 否则编译错误
3、私有方法不会重写

Object继承链

Object 类是所有 Java 类的根基类
如果在类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类

public class Ye {

    int num = 10;

    public void work() {
        System.out.println("书法家");
    }

}

public class Fu extends Ye {

    // 覆盖 Ye 类中的属性 num
    int num = 20;

    // 重写父类的方法
    @Override
    public void work() {
        System.out.println("钢琴家");
    }

}
public class Zi extends Fu {

    // 方法可以重写 ，属性不行
    int num = 30;

    // 重写父类
    @Override
    public void work() {
        System.out.println("电竞游戏玩家");
    }

}

实例化过程

public class Fu {

    int num = 20;

    public Fu() {
        System.out.println("我是父类的无参构造器。");
    }

    public Fu(int num) {
        this.num = num;
        System.out.println("我是父类的有参构造器。");
    }

    public void method() {
        System.out.println("我是父类的方法。");
    }

}

public class Zi extends Fu {

    int num = 10;
    int age;

    public Zi() {
        // 调用了父类的无参构造器
        //super(18);
        //super();
        this(18);
        System.out.println("我是子类的无参构造器。");
    }

    public Zi(int age) {
        this.age = age;
        System.out.println("我是子类的有参构造器。");
    }

    @Override
    public void method() {
        this.getNum();
        System.out.println("我是子类的方法。");
    }

    public void getNum() {
        int num = 30;
        System.out.println("局部变量：" + num);
        System.out.println("本类的成员变量：" + this.num);
        System.out.println("父类的成员变量：" + super.num);
    }

}
public class Demo07 {

    public static void main(String[] args) {
        Zi zi = new Zi();// 默认他成年
        zi.method();
    }

}

切记：一定遵守加载顺序才能分析清楚具体的顺序，例如上面的先进入构造器，然后有参构造器进入父类构造器再回来

继承关系中的类加载顺序：先父类后子类，先静态后成员。
super 关键字的使用:
    1. 加载构造器
        a. 子类的构造器会默认加载父类的构造器，通过 super();
        b. 构造器只能调用一次，不可调用多次
        c. 调用构造器的行为必须写在第一行
    2. 调用父类成员变量 super.变量
    3. 调用父类成员方法 super.方法()

this 关键字的使用：
    1. 加载构造器
    2. 调用自己成员变量 this.变量
    3. 调用自己成员方法 this.方法()

多态

1. 静态绑定与动态绑定

静态绑定(静态联编): 在编译期完成，可以提高代码执行速度。静态绑定的方法包括：

1. 静态方法
2. 构造器
3. private方法
4. 用关键字super 调用的方法
   **动态绑定(动态联编)：**指在“执行期间（而非编译期间）” 判断所引用对象的实际类型，根据其实际的类型调用其相
   应的方法。 这虽然让我们编程灵活，但是降低了代码的执行速度。p>
   这也是JAVA比C/C++速度慢的主要因素之一。

2.多态

多态，polymorphism 即多种形态，模糊策略，以不变应万变，使用多态可以编写更加通用的代码。u
多态的概念发展出来，是以封装和继承为基础的。子类以父类的身份出现，但做事情时还是以自己的方法实现。
相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。

3.实现多态的条件

多态，polymorphism 即多种形态，模糊策略，以不变应万变，使用多态可以编写更加通用的代码。 多态是建立
在继承和重写的基础上，是一个运行期的动态绑定行为。
要发生多态有三个必要条件：要有继承，要有重写，父类引用指向子类对象

public class Animal { 
  public void eat(){ 
    System.out.println("eat....."); 
 } 
  public void shout(){ 
    System.out.println("shout....."); 
 }
}
public class Dog extends Animal {
     //重写
  public void shout(){
    System.out.println("主人我是旺财.....");
  }
}
public class Pig extends Animal{
//重写
  public void shout(){
  System.out.println("我是世界最聪明的动物.....");
 }
 //新增
  public void gongDi(){
    System.out.println("拱地.........");
 }
}

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

由于使用的是父类的引用，使用父类型进行编译，所以发生多态是对新增方法不可见，要使用新增方法必须强制类型

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

4.分析四大原则

1）、继承链，自己没有找父亲；
2）、编译看类型+确定方法表，运行找对象
3）、就近最优原则：自己没有找父亲
4）、发生多态，基类对子类的新增方法不可见