OOP（狂神）

面向对象：以class的方式组织代码，以object的方式组装（封装）数据

OOP的核心思想是抽象

OOP的三大特性：封装，继承，多态

class包含的两个东西：属性和method

Java是值传递，也就是说当调用某个method时，调用时传入的参数，实际是把这个参数的值了传进去，而不是把这个参数的地址传进去

public static void change(int a ){
    a=10;
}

public static void main(String[] args){
    int a=1;
    System.out.println(a);//a=1
    change(a);
    System.out.println(a);//a=1,a不会变为10，因为上一句code只会把a的值也就是1传入到change这个方法中，不会对a这个变量产生影响
}

---

一个包下的所有文件，可以相互之间互通，所以可以把main（主程序）放在一个单独的文件里，需要import的是包与包之间，同一个包下的文件与文件之间可以直接相互随便用

---

constructor：用来初始化值

constructor也可以重载多个，只要参数列表不一样就行

constructor没有返回值

---

初始化时，数字默认值为0，boolean默认值为false，其余的默认值全是null

---

封装

程序设计追求“高内聚，低耦合”；高内聚是指class的内部数据操作细节自己完成，不允许外部干涉；低耦合是指仅暴露少量的方法给外部使用

属性私有：将属性前的public都改成private

属性私有后，如何access到这些属性：get和set方法（避免了直接访问内部，但仍可以对数据进行操作

this.属性这个操作的可用范围是在整个class内，一般用在class中定义的method里

alt+insert 是自动生成get与set方法的快捷键

封装的意义：提高程序安全性，保护数据；隐藏代码的实现细节；统一接口；提高系统可维护性

---

继承的本质是拓展，子类是父类的拓展，所以子类的功能比父类多

继承是类与类之间的关系

子类不能继承父类中private的东西

ctrl+H 可以显示当前的继承层级关系

Java中，所有的类都默认继承object这个类，这个最大的类

Java中只有单继承，没有多继承：一个子类只能有一个父类，一个父类可以有多个子类

当需要在子类中调用父类中被重写的method时，要用到super关键字。super与this相对，this取的是当前类里的属性/method，super取的是父类里的属性/method；但若该属性/method是private的，则无法通过super 去access；用super去access的方法：super.

子类的constructor中默认也包含了父类无参constructor的内容，且在子类constructor中，父类无参constructor（即super（）；）的内容在子类constructor内容之上，在第一行

父类中没有无参constructor，则子类中也不能有无参constructor

super和this不能同时去调用constructor（super（）；和this（）；）

super这个字眼只能出现在子类中

带final关键字的不能被继承

---

method的重写（override）：子类父类里有重名，重参数列表method

override只存在于非static method中，static的method没有override这一说

父类 var=new 子类（）；//这种语句是成立的，当var去调用一个在子类父类里都存在的method时，var会调用的是子类的那个方法；但若这两个method都是static的，则var会调用的是父类里的方法，static的method调用只看定义时的类型是什么；若var想调用属性，则调用的是父类里的属性

成员变量：编译看左边（基类），运行看左边（基类）；无论如何都是访问基类的成员变量。

成员方法：编译看左边（基类），运行看右边（派生类），动态绑定。

Static方法：编译看左边（基类），运行看左边（基类）。

override时，修饰符的范围只能扩大但不能缩小，public>proteceted>default>private 

抛出的异常，范围可被缩小，但不能扩大；ClassNotFoundException < Exception（大）

为什么要override：

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

alt+insert，选中override，这是override的快捷键

哪些不能被override：static，final，private

---

多态：同一方法可以根据发送对象的不同而采取不同的行为方式

多态是method的多态，属性没有多态

多态的存在条件：有继承关系，method需要重写，父类引用指向子类object

即 父类 var=new 子类（）；

一个object的实际类型（new右边的类型）是确定的，但可以指向的引用类型（等号左边的类型）就不确定了，可以通过父类去new子类，即等号左边的类型>=new右边的类型

一个object能执行哪些方法，主要看等号左边的类型，和new右边的类型关系不大

子类：可以用子类和父类的东西

父类：可以用父类的，虽然可以指向子类，但不能调用子类独有的东西

继承中的强转：当父类想转成子类时，跟八大类型的强转一样，在父类的object前加（子类）就行

//person为父类，student为子类


Student stu=new Student();
Person per = stu;//子类转化为父类，直接转即可

==================================================
Person per=new Student ();//per的实际类型为student，per的引用类型为person
Student perrr=(Student) per;//强转，父类转化为子类，用括号

---

instanceOf：

object instanceOf class；会判断object是否是class的一个实例或者类型父集的一个实例，返回true/false，看的是object的实际类型

在编译状态中，class可以是object的父类，自身类，子类。在这三种情况下Java编译时不会报错。（只要object与class是存在层级关系的，就不会编译报错）

在运行转态中，class可以是object对象的父类，自身类，不能是子类。在前两种情况下result的结果为true，最后一种为false。

---

static的属性，可以直接通过classname.属性去access，区别于以往的需要用object去access

class的定义里，以下为静态代码块，和class一起加载，执行时是最开始被执行的，且只执行一次

static{

}

静态导入包

---

抽象类：class与class 里定义的method，前面都带abstract关键字（放public后就行），class里定义的method叫抽象method（结尾不是{ },而是；），只有名，没有body；其他class可以继承这个class

抽象类不能new出来object

每个去继承抽象类的字类，需要把抽象类中的所有抽象方法都实现（也就是每个抽象方法都要被填满，有功能）

抽象类中可以有普通方法（有body的method），但抽象方法不能存在于普通类下

---

接口

普通类：只有具体实现

抽象类：具体实现和抽象方法都可以有

接口：只有抽象方法（可以实现约束和实现分离）

接口的关键词是interface，顺序为 public interface 接口名{ }

接口中的方法默认都是public abstract的，在接口中定义抽象方法时，可以直接写

返回类型 method名（参数列表）；

实现接口的类，用关键词implements

public class impl implements interfacename {

}

每个实现接口的类必须填满每个接口里的method

接口可以多继承，一个class可以继承多个接口，只需把所有要继承的接口名按逗号隔开即可

接口中没有constructor

接口不能被实例话

接口的作用：

1. 约束
2. 定义一些方法，让不同的人去实现
3. 企业中其实大部分就是去定义很多很多接口，然后去实现它

---

内部类：即在一个类的内部再定义一个类。比如A类中定义了一个B类，那么B类就是A类的内部类，A类就是B类的外部类

如何去创建一个内部类的object：先创建一个外部类的object，然后通过这个外部类的object去new一个内部类的object 

//Outer是外部类，Inner是内部类，inner是我们要的内部类的object
Outer.Inner inner=outer.new Inner();

内部类可以使用外部类的属性和方法，private的属性也可以

一个Java文件中只能有一个public class，但可以有多个class

局部内部类：可以在method里去建一个类