OO面向对象

一、类、对象

1、对象：软件中真实存在的单个个体/东西

​ 类：类别/类型，代表一类个体

2、类是对象的模子，对象是类的具体的实例

3、类中可以包含：

（1）对象的属性/特征-----------------------成员变量

（2）对象的行为/动作-----------------------方法

4、一个类可以创建多个对象

5、访问对象

数据类型  引用类型变量   指向       对象
Student     zs         =    new Student();

6、成员变量：写在类中，方法外--------有默认值

局部变量：方法中------------------------没有默认值

java规定：成员变量和局部变量是可以同名的，使用的时候默认采取的是就近原则

二、方法的重载(overload）

1、发生在同一类中，方法名相同，参数列表不同

2、编译器在编译时会根据方法的签名自动绑定方法

3、方法的签名：方法名+参数列表

三、默认值规则：

byte,short,int,long,char-------------0
float,double-------------------------0.0
boolean------------------------------false
引用类型------------------------------null  

四、构造方法：构造函数、构造器、构建器

1、作用：给成员变量赋初始值

2、与类同名，没有返回值类型(连void都没有)

3、在创建(new)对象时被自动调用

4、若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默认提供

5、构造方法可以重载

五、this

1、指代当前对象，哪个对象调用方法它指的就是哪个对象

​ 只能用在方法中，方法中访问成员变量之前默认有个this.

2、this的用法：

（1）this.成员变量名-------------访问成员变量

​ 注：成员变量与局部变量同名时，若想访问成员变量则this不能省略

（2）this.方法名()-----------------调用方法(了解)

（3）this()---------------------------调用构造方法(了解)

六、null

表示空，没有指向任何对象，若引用的值为null，则该引用不能进行任何点操作了，若操作则发生NullPointerException空指针异常

七、引用类型数组

1、给元素赋值需要去new个对象

2、若想访问对象的数据，需要通过数组元素去打点

八、继承

1、作用：代码复用

2、通过extends来实现继承

3、超类/父类：共有的属性和行为

​ 派生类/子类：特有的属性和行为

4、派生类既能访问自己的，也能访问超类的，但超类不能访问派生类的

5、一个超类可以有多个派生类，一个派生类只能有一个超类-----------单一继承

6、具有传递性

7、java规定：构造派生类之前必须先构造超类

（1）派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法

（2）派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

​ 注：super()调用超类构造方法，必须位于派生类构造方法的第一行

8、泛化：将共有的抽出来的过程，泛化是设计层面的概念，从代码实现层面来说咱们就是继承，泛化就是继承

九、super：指代当前对象的超类对象

super的用法：

（1）super.成员变量名----------------------访问超类的成员变量

（2）super.方法名()---------------------------调用超类的方法

（3）super()-------------------------------------调用超类的构造方法

十、向上造型

1、超类型的引用指向了派生类的对象

2、能点出来什么，看引用的类型

class Eoo{
    Eoo o1 = new Eoo();
}
class Doo extends Eoo{
    Doo o1 = new Doo();
}
public class Test{
    public static void main(String[] args) {
        Eoo o3 = new Doo() //向上造型
    }
}

十一、方法的重写(override)

1、发生在父子类中，方法名相同，参数列表相同

2、重写方法被调用时，看对象的类型

3、当派生类觉得超类的行为不够好时，可以重写

4、重写的规则：两同两小一大

（1）两同：方法名相同，参数列表相同

（2）两小：

​ 1）派生类方法的返回值类型小于或等于超类方法的

​ ①void和基本类型必须相等

​ ②引用类型必须小于和等于

​ 2）派生类方法抛出的异常必须小于超类的

（3）一大：派生类方法的访问权限必须大于超类方法的

5、重写与重载的区别

（1）重写：发生在父子类中，方法名相同，参数列表相同，一般用于在派生类中修改超类的方法。

（2）重载：发生在同一类中，方法名相同，参数列表不同，是完全不同的方法，只是方法名相同而已。

十二、package和import

1、package：声明包

（1）作用：避免类的命名冲突

（2）同包中的类不能同名，不同包中的类可以同名

（3）类的全称：包名.类名，包名常常有层次结构

（4）建议：包名所有字母都小写

（5）说明：package声明包必须位于第一行

2、import：导入类

（1）同包中的类可以直接访问，不同包的类不能直接访问，若想访问：先import导入类，再访问类

（2）说明：import导入类必须位于声明包的下一行

十三、访问控制修饰符

1、public：公开的，任何类

2、private：私有的，本类

3、protected：受保护的，本类、派生类、同包类

4、默认的：什么也不写，本类、同包类

5、类的访问权限只能是public或默认的，类中成员的访问权限如上四种都可以

十四、static：静态的

1、静态变量：

（1）由static修饰

（2）属于类，存储在方法区中，只有一份

（3）常常通过类名点来访问

（4）何时用：所有对象所共享的数据(图片、音频、视频等)

2、静态方法：

（1）由static修饰

（2）属于类，存储在方法区中，只有一份

（3）常常通过类名点来访问

（4）静态方法没有隐式this传递，所以不能直接访问实例成员

（5）何时用：方法的操作与对象无关

3、静态块：

（1）由static修饰

（2）属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次

（3）何时用：初始化/加载静态资源(图片、音频、视频等)

十五、成员变量

1、实例变量：没有static修饰，属于对象的，存储在堆中，

​ 有几个对象就有几份，通过引用打点来访问，在构造方法中给实例变量做初始化

2、静态变量：有static修饰，属于类的，存储在方法区中，

​ 只有一份，通过类名打点来访，在静态块中给静态变量做初始化

十六、内存管理

1、堆

（1）存储new出来的对象(包括实例变量)

（2）垃圾：没有任何引用所指向的对象

垃圾回收器(GC)不定时到内存堆中清扫垃圾，回收的过程中透明的(看不到的)，不一定一发现垃圾就立刻回收，通过调用System.gc()建议虚拟机尽快调度GC来回收

（3）实例变量的生命周期：创建对象时存储在堆中，对象被回收时一并被回收

（4）内存泄漏：不再使用的对象没有被及时的回收，严重的泄漏会导致系统的崩溃，建议：不再使用的对象应及时将引用设置为null

2、栈：局部变量

（1）存储正在调用的方法中的局部变量(包括方法的参数)

（2）调用方法时，会为该方法在栈中分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除。

（3）局部变量的生命周期：

​ 调用方法时存储在栈中，方法调用结束时与栈帧一并被清除

3、方法区

（1）存储.class字节码文件(包括静态变量、所有方法)

（2）方法只有一份，通过this来区分具体的调用对象

4、实例变量和局部变量的区别：

（1）实例变量：写在类中、方法外；创建对象时存储在堆中，对象被回收时一并被回收；有默认值

（2）局部变量：写在方法中；调用方法时存储在栈中，方法调用结束时与栈帧一并被清除；没有默认值

5、java只有值传递，基本类型传递的是具体的数，引用类型传递的是具体的地址

十七、final：最终的，不可改变

1、修饰变量：变量不能被改变

class Aoo{
    final int num = 5;
    void show(){
        //num = 55; //编译错误，final的变量不能被改变
    }
}

2、修饰方法：方法不能被重写

class Boo{
    final void show(){}
}
class Coo extends Boo{
    //void show(){} //编译错误，final修饰的方法不能被重写
}

3、修饰类：类不能被继承

final class Doo{}
//class Eoo extends Doo{} //编译错误，final的类不能被继承
class Foo{}
final class Goo extends Foo{} //不能当超类，但能当派生类

十八、static final常量：应用率高

1、必须声明同时初始化

2、通过类名点来访问，不能被改变

3、建议：常量名所有字母都大写，多个单词用_分隔

4、编译器在编译时会将常量直接替换为具体的值，效率高

5、何时用：数据永远不变，并且经常使用

十九、抽象方法：

1、由abstract修饰

2、只有方法的定义，没有具体的实现(连{}都没有)

3、抽象方法的存在意义

​ 保证当发生向上造型时，通过超类型的引用能点出来那个方法，若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写

4、设计规则：

（1）将派生类所共有的属性和行为，抽到超类中

（2）派生类的行为都一样，则设计为普通方法，派生类的行为不一样，则设计为抽象方法

（3）将部分派生类所共有的属性和行为，抽到接口中，接口是对继承的单根性的扩展---------------实现多继承

符合既是也是原则时，应使用接口

二十、抽象类：

1、由abstract修饰

2、包含抽象方法的类必须是抽象类

3、抽象类不能被实例化(new对象)

4、抽象类是需要被继承的，派生类：

（1）重写所有抽象方法

（2）也声明为抽象类（一般不这么做）

5、抽象类的意义：

（1）封装共有的属性和行为--------------------代码复用

（2）为所有派生类提供统一的类型-----------向上造型—代码复用

（3）可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，派生类的行为不同，但入口是一致的，同时相当于定义了一个标准

二十一、成员内部类&匿名内部类

1、成员内部类：应用率低

（1）类中套类，外面的称为外部类，里面的称为内部类

（2）内部类通常只服务于外部类，对外不具备可见性

（3）内部类对象只能在外部类中创建

（4）内部类中可以直接访问外部类的成员(包括私有的)，在内部类中有个隐式的引用指向了创建它的外部类对象------外部类名.this

class Mama{ //外部类
    private String name;
    Baby b = new Baby(); //内部类对象通常在外部类中创建
    class Baby{ //内部类
        void show(){
            System.out.println(name);
            System.out.println(Mama.this.name); //Mama.this指代它的外部类对象

2、匿名内部类：应用率高，大大简化代码

（1）若想创建一个类(派生类)的对象，并且对象只创建一个，此时该类不必命名，称为匿名内部类

（2）匿名内部类中不能修改外面变量的值，因为在此处该变量默认为final的

3、隐式对象：

（1）this：当前对象

（2）super：当前对象的超类对象

（3）外部类名.this：当前对象的外部类对象

4、做功能的套路

（1）先写行为/方法：

​ 若为某对象所特有的行为，就将方法设计在特定的类中

​ 若为所有对象所共有的行为，就将方法设计在超类中

（2）窗口调用：

​ 若为定时发生的，就在定时器中调用

​ 若为事件触发的，就在侦听器中调用

二十二、接口：

1、是一种引用数据类型

2、由interface定义

3、只能包含常量和抽象方法------默认权限是public

4、接口不能被实例化

5、接口是需要被实现/继承，实现/派生类：必须重写所有抽象方法

6、一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现，接口可以继承接口

interface Inter1{
    void show();
}
interface Inter2{
    void test();
}
interface Inter3 extends Inter1,Inter2{
    void say();
} 

7、接口的意义：

（1）封装部分派生类共有的属性和行为，实现多继承

（2）制定了一个标准，一种规范，可以向上造型为：超类+所实现的接口

8、类和类------------------------继承extends

接口和接口------------------继承extends

类和接口---------------------实现implements

二十三、多态：

1、表现：

（1）同一个对象被造型为不同的类型时，有不同的功能

（2）同一类型的引用指向不同的对象时，有不同的实现，行为的多态：所有抽象方法都是多态的

2、向上造型/自动类型转换：--------------------代码复用

（1）超类型的引用指向派生类的对象

（2）能点出来什么，看引用的类型

（3）能造型成为的数据类型有：超类+所实现的接口

3、强制类型转换，成功的条件只有如下两种：

（1）引用所指向的对象，就是该类型

（2）引用所指向的对象，实现了该接口或继承了该类

4、何时用：想访问的属性/行为在超类中没有

5、强转时若不符合如上条件

（1）则发生ClassCastException类型转换异常

（2）建议：在强转之前先通过instanceof来判断引用的对象是否是该类型

public class MultiTypeDemo {
    public static void main(String[] args) {
        Aoo o = new Boo();
        Boo o1 = (Boo)o;     //引用o所指向的对象，就是Boo类型
        Inter o2 = (Inter)o; //引用o所指向的对象，实现了Inter接口
        //Coo o3 = (Coo)o; //运行时ClassCastException类型转换异常
        if(o instanceof Coo){ //false
            Coo o4 = (Coo)o;
        }else{
            System.out.println("o不是Coo类型");
        }

二十四、注释

1、单行注释：//

2、多行注释：/* */

3、文档注释：/** */

​ 功能性注释，只在三个地方使用，分别是类上、方法上和常量上

/**
     * 为指定用户添加问候语
     * @param name 指定用户的名字
     * @return 含有问候语的字符串
     */
    public String sayHi(String name){
        return INFO+name;
    }
}