【狂神说Java】学习笔记16：面向对象编程（中）

【狂神说Java】学习笔记16：面向对象编程（中）

[01] 初识面向对象

[02] 方法回顾和加深

[03] 对象的创建分析

[04] 面向对象三大特征(重点)

[05] 抽象类和接口

[06] 内部类和OOP实战

--------------------------------------------------------------------

[03] 对象的创建分析

类与对象

类是一个抽象的数据类型。描述抽象特征，而非具体实例。

​ 类是一个模板，较抽象。静态的表述（属性），动态的行为（方法）

​ 属性：字段field 成员变量。有默认的初始化。

对象是抽象概念的具体化实例。对象是通过引用来操作的，从栈到堆。

​ 对象的创建和使用，new来创造。

创建对象

实体化一个类并调用

学生类里有属性（姓名，年龄）和方法（学习）

main方法里实例化学生类，并给实例化的对象赋予姓名和年龄，然后调用学习的方法。

实体化是如何实现的？？

实例化new具体是如何操作的，看如下的简易内存图加深理解。

栈里存放main方法（放在最底行来执行），和引用变量名（cat，dog）

堆里放内存地址（new出来的旺财的信息，cat的信息来让栈调用）和方法区。

总结：平常说的引用变量名，其实都是通过栈里的变量名，来引用堆里的内存信息。

方法区里的静态方法static，是和类一起加载的，所以所有的对象都可以用到静态方法。

代码实例

图解代码实例

[04] 面向对象三大特征(重点)

三大特性有：封装，重写和多态

1.封装 （属性私有，get/set）

类比简介：就像看电视，不需要了解构造和原理，只需要遥控器就可以看电视换台。

设计要遵循 高内聚，低耦合 的设计观念。

​ 高内聚：类的内部数据操作细节自己完成，不允许外部干涉。

​ 低耦合：仅暴露少量的方法给外部使用。

封装的好处：1.提高程序的安全性，保护数据安全性。2.隐藏代码实现细节。3.统一接口。4.提高可维护性。

封装类的实例

student类里私有属性name和age，外部无法student.name() 直接调用。
因此需要在类里写外部接口get/set，让外部可以调用。如student.setName()，student.getName()
※小技巧：Alt + ins键可以快速生成属性的get/set方法。

2.继承 extends

继承的本质是对一批类的抽象，让代码实现建模。

子类继承的是父类的public的，父类的私有的Private类无法被继承，除非父类写get/set取到

Java里的所有类都继承Object类

#### super

super是访问父的类。

实例：父类Person，子类student，运行程序Application，在子类写个test方法，令输出name的值完全不同。

System.out.println(name); →→name=Application里定义的值。

System.out.println(this.name); →→this.name=this所在类的属性值

System.out.println(super.name); →→super.name=父类的属性值

无参构造

执行main方法的时候，调用了student类的无参构造方法，但前提是最先调用了父类的无参构造方法。

并且父类的调用首先执行（隐藏了 super(); 这个写法。），再执行子类student类的无参构造方法。

并且super(); 必须放在子类构造器的第一行。放下面则报错。

super的注意点总结

super注意点：

​ 1.super调用父类的构造方法，必须在构造方法的第一个。

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

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

this VS super:

	代表的对象	前提	构造方法
this	代表本身这个对象	没有继承也可以使用	this()调用本类的构造
super	代表父类对象的应用	必须在继承条件下才能使用	super()调用了父类的构造

#### Override 方法的重写

Override是重写，是方法的重写，和属性无关所以在此不写。

Static静态方法的重写。

子类A重写了父类B的test方法，然后调用之后有自己的方法体和输出内容。与父类不一样。

注意点：此处 B b=new A(); 容易迷惑。AB产生父子的继承关系之后，父类B的引用b指向了子类A()。（此处涉及多态的概念）

Override

非静态方法下（无static）重写时，public共有的可以重写，private私有的无法重写。

上面的代码，父类B和子类A的static都去掉之后会发现代码行标出有 o 的标志，就是override。

alt+ins键找到「override method」，然后就自动生成重写的方法 @Override，这是功能性注释。

非静态方法下用Override来使子类重写了父类的方法，因此调用的父类的方法也变成了子类的方法，结果都是一样的。

重写的注意事项：

​ 前提是需要有继承关系，子类重写父类的方法。
​ 1.方法名必须相同
​ 2.参数列表必须相同。
​ 3.修饰符：范围可以扩大。public > Protected > Default > Private
​ 4.抛出异常：范围可以被缩小，但是不能被扩大。ClassNotFoundException

为什么需要重写：父类的功能子类不一定需要，或者无法满足。

### 3.多态 instanceof

父类的引用指向子类的对象。

把子类转化为父类，向上转型

把父类转化为子类，向下转型，强制转换会丢失方法。

附录1：static总结（静态方法，静态属性）

类里的静态变量可以直接调用，而非静态变量则需要实例化才能调用。

类里的静态方法可以以类名的方法直接被调用，而非静态方法也是需要实例化才能调用。

package oop.demo07;

// static  静态的属性和静态方法的总结
public class Student {
    private static int age;     //1.静态变量
    private double score;       //1.非静态变量

    public static void main(String[] args) {
        Student s1 = new Student();
        // 2.属性的调用。
        //Student.age 是类名的静态变量，在类的内存中只有一个，可以被类内共享调用，推荐使用。
        System.out.println(Student.age);    //类名的静态变量。无需new，就可以用
        System.out.println(s1.age);         //对象的静态变量。必须new才能用。


        //3.方法的调用。
        //run(); 非静态方法的run直接用的话报错，需要实例化run方法。
        new Student().run();       //必须写明  对象().方法() 才可以使用。
        read();                    //直接用。无需写对象，默认是类名里read方法。
    }

    // run方法
    public void run(){

    }
    // 静态方法
    public static void read(){

    }

}

## 附录2：代码块的应用。

package oop.demo07;

//  代码块
/*
    1.依次创建以下匿名代码块和静态代码块，构造方法。
    2.写一个main方法，实例化person后并执行，
    3.看输出顺序和输出结果
    总结：静态代码块。随着程序执行一起执行，只执行一次。其他的随着实例的创建一遍遍执行。

 */

public class Person {
    // 匿名代码块，一般会赋初始值。
    {
        System.out.println("匿名代码块");
    }
    // 静态代码块。
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==============================");
        Person person2 = new Person();
    }
}

-------------------------------------------------------------------
静态代码块
匿名代码块
构造方法
==============================
匿名代码块
构造方法