面向对象的知识点

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。

抽象

三大特性

• 封装

• 继承

• 多态

  创建与初始化对象

  • 使用new关键字创建对象

  • 使用new关键字创建的时候，除了分配空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用。

  • 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的，并有2个特点。

    1.必须和类的名字相同。

    2.必须没有返回类型，也不能写void.

    构造器的作用：

    1.new本质在调用构造器

    2.初始化对象的值

    注意点：

    1.定义了有参构造之后，如果想使用无参构造，显示的定义一个无参的构造。

    1.类与对象

    类是一个模板：抽象，对象是一个具体的实例

    2.方法

    定义，调用

    3.对应的引用

    引用类型：基本类型（8）

    对象是通过引用来操作的：栈----->堆

    4.属性：字段Filed 成员变量

    默认初始化：

    数字：0 0.0

    char:u000

    boolean:false

    引用：null

    修饰符 属性类型 属性类型=属性值！

    5.对象的创建和使用

    必须使用new关键字创造对象，构造器 Person p=new Person();

    对象的属性：p.name

    对象的方法：p.sleep()

    6.类：

    静态的属性 属性

    动态的行为 方法

    封装

  • 该露的露，该藏的藏

  • 高内聚，低耦合

  • 属性私有get/set

    封装的优点

    • 1.提高程序的安全性，保护数据。

    • 2.隐藏代码的实现细节

    • 3.统一接口

    • 4.系统可维护增加了

      继承

      • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

      • extends的意思是扩展，子类是父类的扩展

      • JAVA中只有单继承，没有多继承

      • 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等。

      • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends

  • 子类和父类之间，从意义上将应该具有“ is a”的关系

    • 子类继承父类，就会拥有父类所有的方法!

    • object类

    • super ：

      1.调用父类的构造器，比须要在子类构造器的第一行。

      2.super只能出现在子类的方法或者构造方法中

      3.super和this不能同时调用构造方法。

      VS this:

      代表的对象不同：

      this：本身调用者这个对象。

      super：代表父类对象的应用。

      前提：

      this:没有继承也可以。

      super:只能在继承条件下才能使用

      构造方法：

      this（）：本类的构造

      super();父类的构造

    • 方法重写

      1.需要有继承关系，子类继承父类的方法

      2.方法名必须相同

      3.参数列表必须相同

      4.修饰符：范围可以扩大，public>protected>default>private

      4.抛出异常：范围可以被缩小，但不能被扩大

      重写：子类和父类的必须一致，方法体不同！

      为什么需要重写：

      1.父类的功能，子类不一定需要或者不一定满足

      多态

      • 动态编译：类型：可扩展

      • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

      • 一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多。

      • 多态存在的条件

        1.有继承关系

        2.子类重写父类方法

        3.父类引用指向子类对象

      • 注意：多态是方法的多态，属性没有多态性。

      • instanceof：

      • 多态的案例：

        public class Person {
        public void run(){
                System.out.println("run");
        }
        }
        ​
        ​
        public class Student extends Person {
        ​
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("son");
            }
        public void eat(){
            System.out.println("eat");
        }
        }
        ​
        public class test {
        ​
            public static void main(String[] args) {
                //一个对象的实际类型是确定的
                //new Student();
                //new Person
                //可以指向的引用对象的类型是不确定的
                
                //Student 能调用的方法都是自己的或者继承父类的！
                Student s1=new Student();
                //Person 父类型，可以指向子类，但是不能调用子类独有的方法
                Person s2=new Student();
                Object s3   =new Student();
                //对象能执行哪些方法，主要看对象左边的类型，和对象右边的关系不大
                s2.run();//子类重写父类的方法，执行子类的方法
                s1.run();
                s1.eat();
            
            }
        ​
        }
        ​
            son
            son
            eat