JAVA面向对象-0基础学JAVA

面向对象

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

面向对象的三大特性：封装，继承，多态

实际参数和形式参数的类型要对应！

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

类中的构造器也成为了构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void

一个项目应该只存在一个main方法，一个类即使什么都不写，他也会存在一个方法

构造器
1. 和类名相同
2. 没有返回主

无参构造：使用new关键字，本质是在调用构造器
有参构造：一旦定义了有参构造，无参就必须显示定义

alt+ insert 自动生成构造器

1. 类与对象
   类是一个模板；抽象，对象是一个具体的事例
2. 方法
   定义，调用
3. 对应的引用
   引用的类型：基本类型（8种）
   对象是通过引用来操作的：栈–>堆
4. 属性：字段Field 成员变量
   默认初始化：
   数字：0 0.0
   char： u0000
   boolean：false
   引用：null
   修饰符 属性类型 属性名 = 属性值
5. 对象的创建和使用
   1. 必须使用new 关键字创造对象，构造器 Person kuangshen = new Person
   2. 对象的属性 kuangshen.name
   3. 对象的方法 kuangshen.sleep()
6. 类：
   静态的属性 属性
   动态的行为 方法
7. 封装，继承，多态

封装

1. 高内聚，低耦合(该露的露，该藏的藏)
   我们程序设计要追求 高内聚，低耦合。高内聚就是累的内部数据操作细节自己完成，不允许外部干涉；低耦合，仅暴露少量的方法给外部使用
   属性私有，get/set
2. 封装的意义：
   1. 提高程序的安全性，保护数据
   2. 隐藏代码的实现细节
   3. 统一接口
   4. 系统可维护增加了

继承

继承的本质是对某一批类的抽象

extends的意思是“扩展”。子类是父类的扩展

子类继承了父类，就会拥有父类的全部方法！

ctrl + H 打开继承树

在java中，所有的类 都默认直接或者间接继承object

//public    可以继承给子类的
//protected  受保护的
//default   默认的
//private   私有的  无法继承的

JAVA中类只有单继承，没有多继承！一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

Vs this：
代表的对象不同：
this：本身调用者 这对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法
this（）；本类的构造
super；父类的构造

方法重写

重写都是方法的重写，与属性无关

方法的调用之和左边的 定义的数据类型有关

静态的方法和费静态的方法区别很大
静态方法：方法的调用只和左边的 定义的数据类型有关
非静态方法：重写

重写：需要有继承关系，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符范围可以扩大，但不能缩小 Public>Protected>Ddfault>private
4. 抛出的异常：范围可以被缩小，但不能扩大

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

为什么需要重写：

父类的功能，子类不一定需要，或者不一定满足
Alt + Insert----override

多态

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

一个对象的时机类型是确定的，但他可以指向对象的引用的类型有很多（父类，有关系的类）

子类重写了父类的方法，执行子类的方法

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大

子类能调用的方法都是自己的或者继承父类的
父类可以指向子类，但是不能调用子类独有的方法

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 有关系才能进行类型转换，否则数据转换异常：ClassCastException
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象

不能重写：
static 静态方法，属于类，不属于事例
final 常量
private方法

instanceof 引用类型。判断一个对象是什么类型

父类转化为子类，可能会丢失自己本来的一些方法

多态存在的条件：

1. 父类的引用指向子类的对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型，需要强制转换，会丢失方法
4. 方便方法的调用，减少重复的代码

{
    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();
}

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，呢么该类就是抽象类

抽象类的所有方法，继承了他的子类，都必须必要实现他的方法，除非他的子类也是抽象的

java的类是单继承，但接口是多继承

1. 不能new这个抽象类，只能靠子类去实现它，只能去约束
2. 抽象类里面可以写普通方法，但抽象方法必须在抽象类中
3. 抽象的抽象：约束

接口

普通类：只有具体的实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，专业的约束。约束和实现分离：面向接口编程

接口的本质是契约

接口的作用

1. 约束
2. 它可以定义一些方法，让不同的人实现
3. 所有的方法都是public abstract
4. 所有的常量都是public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 实现接口，必须要重写接口中的方法

内部类

内部类就是在一个类的内部再定义一个类

没有名字初始化类,不用将事例保存在变量中

一个java类中可以有多个class类，但是只能有一个public class

这是看的B站的狂神说的java学的 附上链接
https://www.bilibili.com/video/BV12J41137hu?p

但是 面向对象这一块真的是学的有点懵逼