面向对象
1.面向对象
1.1 什么是面向对象？
就是把现实问题抽象化，用类组成
1.2 和面向过程有什么区别和优点
过程更接近实际
优点：耦合性更高，更遵循ocp原则（ocp原则是减少对代码更改，增加代码拓展性）
2 类与对象
2.1 类和对象定义
类：类是现实中不存在的，是我们定义的一个模板，所有对象的共同特征！
格式：
[修饰符列表] class 类名{}
类=属性+方法
//属性在代码上以“变量”的形式存在
//方法描述动作/行为
对象：是实际存在的个体，对象是类创造出来的
3 实例变量,实例方法（对象里的变量就是实例变量，方法同此）
3.1 静态变量/常量
类里的静态方法中的方法体不能使用实例变量
3.1属性是引用类型怎么访问？
在主函数中创造该类型对象，然后用引用.的方式访问，
4 空指针异常
当创建对象被赋予null时，该引用在栈中找不到堆中的对象了，这就是空指针异常！
5 构造方法
格式
PS：当类中没有设任何构造方法时，JAVA自己会设一个无参类型的构造方法，当类中设置了有参构造方法时，默认无参构造方法会被抵消掉，所以当你设置有参构造方法时，也需要把无参构造方法写上！
5.1 构造方法的调用
ps： 构造方法没有数据类型！
构造方法名和类名必须一样！
6.1类的封装
7 静态代码块和实例代码块
7.1 静态代码块：在类加载时执行，在main函数前执行，一个类可以定义多个静态代码块，遵循自上而下原则，只执行一次
格式： static{
JAVA语句；
}
7.2 实例代码块：在构造方法前执行（对象构建时机）
格式：
{
JAVA语句；
JAVA语句；
}
面向对象-三大特征：
1.封装
1.1如何封装？
1.1.1首先要实现属性的私有化private（本类中访问）
这样就不能直接引用了把数据保护起来了
那我们访问时怎么办呢？
1.1.2 seter和geter
多态机制：返回值类型是基本数据类型的话，必须一致，但如果数据类型是引用数据类型，重写之后返回类型可以变的更小，Pet可以换成Cat；
封装的目的？
减少代码与代码之间的影响，降低耦合度；
2.继承 extends
格式 【修饰符列表】 类名 extends 父类名（）{}；
2.1 什么是继承？
继承就是把父类所有的属性转接到子类中，就是说可以在子类直接访问父类的方法！！
就像你父亲是富二代，你也是富二代一样
基本作用：子类继承父类，代码可以复用
主要作用：有了继承关系，才有了后期的方法覆盖和多态机制！！
2.2什么时候继承？
当一个类与另一个类是包含关系时；
pet和狗就是包含
2.3 方法覆盖（重写/实现）
2.3.1 什么是方法覆盖呢？
方法覆盖就是当子类继承父类中的方法不适合子类使用时，我们可以直接在子类中改写；
public class text05 { public static void main(String[] args) { BB b=new BB(100); AA a=new AA(); a.adad(); } } class BB{ private int anInt; public BB(){}//无参构造函数 public BB(int anInt){//有参构造函数 this.anInt=anInt; } public void setAnInt(int anInt){//set this.anInt=anInt; } public int getAnInt(){//get return anInt; } public void adad(){ System.out.println("这是父类！！！"); } } class AA extends BB{ public void adad(){ System.out.println("这是子类！！！"); } }//这是子类！！！
2.3.2
发生方法重写的条件：
1.两个类之间必须是继承关系
2.重写的方法，返回值类型相同，方法名相同，形参列表相同
3.访问权限不能更低，可以更高
4.重写后的异常要比之前的方法异常更少
2.3.3
注意：方法覆盖只针对方法，与属性无关，
私有方法无法覆盖
构造方法不能被继承，所以也不能被覆盖
方法覆盖只针对实例方法，静态方法覆盖没有意义！
3.多态
为什么要用多态？多态为了降低代码与代码之间的耦合度，提高扩展性！
3.1 向上转型和向上转型的概念
向上转型：子——>父（自动类型转换）
Animal a=new Cat（）；
向下转型：父——>子（强制类型转换）
Cat c=（Cat）a；
当需要调用子类当中特有的方法时，用向下转型！
前提是两类间有继承关系
向下转型有风险，转型时需要用if（instance）来判断
例如：
1 class Master { 2 public static void main(String[] args) { 3 4 Master zhangsan = new Master(); 5 zhangsan.feed(new Dog());//狗狗吃的很开心
//这里顶如向下转型，pet d=new Dog（）；
6 7 8 Master lisi = new Master(); 9 lisi.feed(new Cat());//猫咪吃的很开心
//同上 pet d=new Cat（）；
10 11 } 12 public void feed(Pet d) { 13 14 if (d instanceof Dog) {//判断这个d是哪个类的对象的引用 15 Dog dog = (Dog) d; 16 dog.eat(); 17 } else if (d instanceof Cat) {//同上 18 Cat cat = (Cat) d; 19 cat.eat(); 20 } 21 22 23 24 25 26 27 } 28 29 30 31 32 33 } 34 35 class Pet { 36 public void eat() { 37 System.out.println("宠物吃的很开心"); 38 } 39 40 } 41 42 class Dog extends Pet { 43 public void eat() { 44 System.out.println("狗狗吃的很开心"); 45 } 46 } 47 48 class Cat extends Pet { 49 public void eat() { 50 System.out.println("猫咪吃的很开心"); 51 } 52 }
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
JAVA进阶！
1 抽象类 -基础语法（以后能用多态就用多态）
什么是抽象类？
抽象类就是对于两个或者多个类中的共同特征所抽象出来的一个类，与类不同的是，类是抽象的对象，而抽象类是抽象的类！
格式：
【修饰符列表】 abstract class 类名{};
注意：abstract 和final冲突，抽象类的子类可以是抽象类也可以是非抽象类
虽然抽象类无法实例化，但是我们可以用子类继承的方式体现出来
抽象类不一定有抽象方法，但是抽象方法在一定是抽象类（抽象方法必须出现在抽象类中！）
抽象方法定义：
public abstract 返回值类型 方法名()；（不能有主体{}）//方法前加个abstract（类也是）
重点：当子类继承的父类中含有抽象方法且子类为非抽象类时，需要在子类将抽象方法覆盖（去掉abstract）
如下：这样编译才能通过！
public class Text06 { public static void main(String[] args) { Card c = new Bankcard();//多态，面相抽象编程 c.id(); } } class Bankcard extends Card{ public void id(){} } abstract class Card{ abstract void id(); }
面向抽象编程：
和面向对象很像，原理一样，使用的多态机制！
public class Text06 { public static void main(String[] args) { Card c = new Bankcard();//多态，面相抽象编程！！向下转型；因为抽象类中不能创建对象，但是可以用多态来得到 c.id(); } } class Bankcard extends Card{ public void id(){ System.out.println("这是一个银行类！！"); } } abstract class Card{ public void id(){ System.out.println("这是一个抽象类！！"); } }
//JAVA底层代码是c++编的！
================================================================================================================================================
2 接口
2.1 接口基础语法：
格式： 【修饰符列表】 interface 接口名{}
2.1.1：接口也是一种引用数据类型
2.1.2： 接口是完全抽象的
2.1.3 ：接口支持多继承，类可以同时使用继承和实现，extends在先，再implement
2.1.4：接口中只存常量和抽象方法
2.1.5 ：
2.1.4 接口中只有常量和抽象方法
2.1.5接口中的修饰符列表可以省略
2.1.6 非抽象类实现接口时，需要将接口中的抽象方法实现
2.1.7 使用接口时，类中可以用多态 父——》子
2.1.6、7如下：
public class Text06 { public static void main(String[] args) {//多态，面向抽象编程 Arr2 a=new B2(); a.methon1(); int C=a.b; System.out.println(C); Arr1 a1=new B2(); a1.methon(); int B=a1.a; System.out.println(B); } } class B2 extends B3 { public void methon(){ System.out.println("methon"); } public void methon1(){ System.out.println("methon1"); } public void methon4(){ System.out.println("methon4"); } } abstract class B3 implements Arr1,Arr2{//类可以继承和实现同时进行，extends在前！ public void methon5(){ System.out.println("methon5"); } } interface Arr1 { int a = 100; void methon(); } interface Arr2 { int b = 100; void methon1(); }
3 面向接口编程：
3.1 降低程序耦合度，提高程序扩展力，（ocp）
3.2 接口可以解耦合，解开谁是谁的耦合
3.3 任何一个接口都有调用者和实现者
3.4 调用者面向接口调用
3.5 实现者面向接口编写实现
作用：
可以将程序分为多个模块，使用接口衔接（降低耦合度），提高程序开发效率
=================================================================================================================================================
4 抽象类和接口区别
抽象类是半抽象的
接口时完全抽象的
抽象类有构造方法
接口没有构造方法
接口与接口间支持多继承
类与类只能单继承
一个类可以实现多个接口
一个抽象类只能继承一个类（单继承）
接口中只能出现常量和抽象方法
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
了解一下包和import
================================================================================================================================================
如下：object中tostring重写
//equals重写 public class Text07 { public static void main(String[] args) { A2 A = new A2(); A2 A1 = new A2(); System.out.println(A.equals(A1)); } } class A2 { int a = 94; String name = "lengbo"; String id = "2022"; public boolean equals(Object obj) { if (obj == null || !(obj instanceof A2)) return false; if (this == obj) return true; A2 A = (A2) obj; A2 A1 = (A2) obj; if ((this.name == A1.name) && (this.id == A1.id)) return true; return false; } }
匿名内部类
