一、面向对象：封装
1、面向对象最基本的操作：
1、 如何创建对象：通过class对象，创建类名
2、如何设置属性以及属性的作用：属性是对象内的参数，我们可以动态设置参数变量。
3、如何设置对象中的方法：对象中的方法，就是给别人调用使用的。方法有返回值和方法没有返回值的区别。通过关键字，void和其他的返回类型定义。
4、方法中小括号的作用：小括号的作用就是参数的传递，我们方法中小括号内的参数一般命名为：形参。形参中，可以定义多个参数，参数与参数间使用逗号相隔。
2、面向对象封装之构造方法
1、什么是构造方法：构造方法，就是创建对象的时候所调用的方法，称之为是构造方法
2、当前对象如果通过关键字new来创建对象，其实在对象中调用的是一个构造方法，来帮助我们完成对象的创建工作。
3、构造方法的书写：如果当前对象内没有写任何的构造方法，默认会存在一个构造方法，但是当前的构造方法是空参构造方法。
注意：构造方法，是没有返回值类型的，方法名称必须和类名保持一致。
构造方法：空参构造方法
构造方法：有参构造方法：说白了就是在构造方法中的小括号中，设置传递的参数，变成了有参构造方法。
4、有参与空参构造方法的区别与作用
作用：创建对象过程中，调用的方法。
区别：
空参构造方法，创建对象，创建出来的对象是一个空对象，不带有任何参数，如果不设置参数，那么调用的参数都是默认值。
有参构造方法，创建对象，在创建的过程中将需要的参数值，直接给对象内的属性赋值，所以我创建完成后的对象，就可以直接拿到值了。
5、在同一个对象中，创建相同名称的方法是可以得，但是需要在小括号中将参数类型与参数的数量，进行区分。我们称之这个做法为：方法的重载。
方法重载：
方法一（）：1.0版本的，功能比较小。
方法二 (String str)：1.1版本的，功能增加了一点。
方法三 （String str int i）：1.2版本的，功能再增加了一点。
方法的重载只能发生在相同对象中，方法名相同，参数类型不同，或者参数 数量不同。
调用查看：有几个重载方法就会显示多少个相同的方法。
6、构造方法中，如果没写那么对象会存在一个空参的构造方法，但是一旦写了构造方法那么默认存在的空参构造方法就会失去，如果没有空参构造方法，还依然使用空
参构造方法创建对象的话，就会报错。
7、如果不写构造方法，空参创建对象是可以的，但是不能使用有参构造方法，否则就报错，推荐大家可以写2个构造方法，分别是空参与有参。
快捷键生成有参与空参：alt + shift + s
8、封装其实就是对对象进行封装工作
1、封装属性：对属性的访问权限进行了封装，私有的只能自己用，公共的谁都可以用。
2、封装方法：普通方法也可以使用关键字进行封装，效果一样，私有的方法别人不能用
3、对私有的属性，可以封装一套获取方法和设置方法，分别是set和get
Set别人设置我当前的私有属性的数据。
Get别人获取使用我当前的私有属性的数据。
4、在创建对象的时候进行封装：构造方法
创建对象的过程中，我需要创建出来的对象是空对象，那么就用空参构造方法。
创建对象的过程中，我需要创建出来的对象是带有数据的对象，不是一个空对象，那么我们就使用有参构造方法来创建
如果对象中不写构造方法，默认就有空参，如果写了那么就使用写了的，如果只写有参不写空参，那么就无法使用空参创建对象。默认的空参在你写了有参的 时候就会消失，需要手动在再写空参才能正常使用。
5、构造方法和普通方法一样，可以方法名相同，但是参数数据类型与数量不能相同，必须在同一个对象中，我们称之为是方法的重载。
重载：方法名必须相同，参数类型不同。
重载：可以修改方法的访问修饰符，可以修改返回类型，无返回还是有返回。
3、输出对象名称显示地址
1、当前我们输出对象的名称，显示的是地址值，出现的原因在于当前我们打印出了对象的HashCode值
2、解决办法如何完成：我们需要在对应的对象内，设置输出格式才能解决，需要通过方法：toString完成（进入Student对象中，设置toString方法）
toString方法，我们依然可以通过快捷键生成：alt + shift + s
4、关键字：this
This代表着本身对象的引用，它是关键字，一般使用它可以调用自己的属性，和调用自己的方法。
二、面向对象：继承
1、继承
1、 什么是继承：子类可以通过继承的手段，去继承一个父类，继承后，当前父类中的所有非私有的属性与方法子类都能够随意使用了。
2、继承的作用：父类可以作为一个基类（抽取出所有对象的共性。），抽取出基类后，子类中的对象就可以不用重复的写相同的方法了。
2、重写
1、方法的重写，就是对父类的方法进行升级，如果子类和父类都有相同方法的时候，默认就会调用子类的重写方法。
重写方法，为什么上面要有一个：@Override：其实是注解，帮助我们检测当前的方法，是否是重写方法，如果不是，那么就报错。
Override注解的功能：说白了，就是帮助我们检查方法是否是重写方法，如果不是就报错，其实我们也可以删除当前的注解，删除后就没有检查功能了。
方法的重写，需要注意事项：
1、方法名必须相同。
2、必须是继承或者实现关系。
3、重写方法传递的形参必须与父类的方法保持一致，不能设置其他形参。
4、重写的方法，访问权限封装关键字：子类的访问权限可以修改，但是权限的大小一定要比父类大。不能比父类小。
父类是：受保护的，子类可以使用：受保护的和公共的。不能使用默认的，和私有的。
5、父类和子类重写方法的返回值，要保持一致。
2、 继承：在Java中是单继承。可以多重继承，父类可以有多个儿子，但是儿子只能有1个爹。
1、 重写与重载的区别：
|
区别点 |
重载方法 |
重写方法 |
|
参数列表 |
必须修改 |
一定不能修改 |
|
返回类型 |
可以修改 |
一定不能修改 |
|
异常 |
可以修改 |
可以减少或删除，一定不能抛出新的或者更广的异常 |
|
访问 |
可以修改 |
一定不能做更严格的限制（可以降低限制） |
总结
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
-
- (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
- (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
- (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
3、面向对象：继承，使用构造方法
1、有一种情况：父类抽取共性，子类还有自己的特性，我们可以在创建子类的时候，将数据设置到父类中
方法一：使用this关键字，调用父类的方法进行设置。
方法二：使用super关键字，调用父类的构造方法存储。
2、 super关键字
1、 在构造方法中，引用super就是去到父类的对应构造方法中。
2、 在普通方法中，引用super，那么就是父类对象的引用。
3、 区分：看super调用的时候是否带有小括号。
Super带有小括号：引用构造方法。
Super不带小括号：父类对象的引用。
4、父类对象如何没有继承，那么能否使用super，是可以使用super关键字的。
5、父类如果没有继承，super引用引用到哪去了呢？
父类如果没有继承，默认都是指向的Object对象
4、final关键字的使用
1、final关键字：最终的，不可更改的。
2、具体使用：（面试原题）
1、final可以修饰对象：但是修饰后，当前的对象是不能够被继承的。
2、final可以修饰属性：但是修饰后，属性就会变成常量，不能够修改。
3、final可以修饰方法，但是修饰后，方法不能够被重写。
3、final的作用是什么
1、每个用户都会存在一个用户id，这个属性后期任何人都不能修改，所以用户的属性我们后期要设置final变成常量。
2、方法呢：有些重要的方法，比如支付方法和退款方法，我们是不允许随便修改的，所以我们当前支付的方法，是不允许重写的。只要和钱打交道的方法，我们都 需要严谨对待。
3、对象，有些对象是不允许被继承的，如果一旦继承了，那么当前对象里面的方法以及操作，我不需要任何的判断和权限，就能够直接使用了。如果是特殊对象， 和高加密对象等等，我们是不允许他被继承的。
4、后期大家遇见面试题问final，和笔试题问答题final。我们就需要如下回答
1、属性使用final：变常量，让用户权限等数据，变成不可修改的数据。
2、方法使用final：敏感操作的方法，一般情况下是不予许被重写的，那么我们就需要在方法上使用final。
3、对象使用final：项目的核心对象，敏感对象，一般情况下都是不需要继承的，一旦继承，里面的所有非私有的方法和属性都能够直接被调用，。非常不安全。我 们需要将对象设置为final修饰的，这样对象就不能直接被继承了。
5、static关键字的使用
1、static是什么：static是静态的意思，它的主要作用就是让程序的生命周期拉长，让属性可以不通过new关键字创建就能直接使用。让方法能够不通过关键字就可以直接调用。
2、static修饰的属性和方法，我们可以不通过new对象，通过对应的类名直接调用
3、原理：当前对象如果设置了static修饰的关键字，那么对象在new之前，静态的属性和方法，其实就已经加载到了内存中，加载是通过.class文件生成的时候就加载进入了。
4、static修饰的优点：访问的权限比较大，可以不通过new关键字创建对象就能直接使用了。而且数据，访问的权限是全局的。
多个方法之间可以共享数据，但是不能再多个程序中共享。
成员变量，如果使用static，那么多个方法之间，拿到的数据就是共享的。
方法也是同理。
方便对象的使用，快捷。减少new的使用。
5、static修饰的缺点：
1、共享的数据，有一个方法进行修改了，其他的方法拿到的数据都是修改后的。
2、共享的数据，声明周期又长。也就意味着内存回收周期就长，长期使用比较占用内存。
6、静态代码块使用：我们对象在创建前就会直接调用
7、查看谁先调用
8、静态代码块不管是在上面还是下面，都会先构造方法执行，原因就是静态.class文件的时候就已经在了，准备执行了。而构造方法是new关键字运行的时候才会调用。
9、在当前的程序工作空间中，bin文件夹里面都是class文件，但是需要注意，程序中的代码，一旦出现错误，class文件就会自动删除。没有错误的情况下后，文件又会自动生成。
三、面向对象：多态
1、多态：多态就是多种形态，一个事物，可以是多种创建形态。
1、使用多态必须要有继承关系：电器区：父类；电脑、电视、冰箱等等就是子类。
动物类：父类；猫类、狗类、鸟类等等，都是子类。
2、使用多态创建出对象：
父类类型 名称 = new 子类类型();
当前创建的两种方法，第一种是常规创建，第二种是多态创建。
3、多态调用方法我们需要注意细节：
1、多态创建出来的对象，可以执行调用父类的非私有的属性和方法。
2、使用多态，如果要想调用子类的方法，那么子类的方法，必须是父类重写的方法。否则无法调用。
当前使用多态创建出来的对象，如果当前的方法，是子类重写父类的方法，那么就优先调用执行。如果当前的方法，子类没有重写父类的方法，那么调用的 就是父类的方法。
3、多态调用执行：
1、多态优先调用子类重写父类的方法。
2、多态可以调用父类的非私有方法。
3、多态可以调用父类的非私有属性。
4、多态不能调用子类的非私有属性。
5、多态不能调用子类的非私有方法。
4、解决多态不能调用子类的非私有属性和方法。
如果使用多态想要调用子类的特有属性和方法的话。我们需要将多态创建出来的对象，进行强制类型转换。将父类转换成子类。
4、多态使用的细节总结：
1、使用多态必须是有继承或者实现关系的。
2、使用多态我们如果需要调用子类的方法，必须是重写方法，重写方法的权限最大。
3、使用多态创建出来的对象，不能调用子类的特有属性和方法，如果真想调用，我们就需要使用到强转。
注意：在强转的过程中，大家很有可能会出现一个异常：ClassCaseException：类型转换异常。
注意：为了避免后期大家出现类型转换的错误，我们事先可以先测试判断一下类型转换是否正确：instanceof
当前我们可以使用到，关键字进行判断，判断出来的结果，就是正确或者错误，我们判断当前转换的类型，是否合格，如果合格我们就转换，如果不合格我们 就不转换，就能解决类型异常的问题。
5、多态在后期的使用
1、使用多态，后期代码会变得更加的灵活了。
比如：用户进入对应的商场，我可以先创建出一个购物车，空的，用户买谁，购物车就装谁！
2、使用完成后，在最后查看用户的选择
2、抽象类
1、什么是抽象类：什么是抽象？光说不做。让人感觉不着地。光说不做，就是抽象的意思。抽象类：光定义方法但不实现方法。
2、抽象方法，只能出现在抽象类或者是接口中，不能出现在普通方法中。抽象方法：当前只定义，不实现。例：父亲的愿望需要儿子去实现（俗称：负债子还）。
3、创建一个抽象类：关键字：abstract。
抽象类，其实和普通类类似，可以有属性、构造方法、普通方法、get方法set方法等等。
但是，抽象类中还可以定义抽象方法。
4、在抽象类中，定义抽象方法
5、子类如果实现的是抽象类，那么必须实现抽象方法（一定要对抽象方法进行重写）
如果子类不重写父类的抽象方法，就会一直报错。
6、创建对象的过程中，抽象类是不允许被创建出来的
抽象的对象，是不允许直接被new创建的。
抽象类，如果要想创建，我们就需要使用对应的实现类（儿子创建）
7、抽象类的出现：抽象类当中存在抽象方法，如果要想实现，那么就需要子类完成。但是抽象类，又不能直接初始化，还是得用多态来初始化。
多态的产生，其实有两部分的原因：
1、 多态让创建对象，变的更加的灵活，根据用户的选择可以动态的进行创建。
2、 抽象类与接口是不能直接被创建的，而是需要通过多态的创建方式，让子类具体实现，完成创建工作。
8、抽象类总结：
1、抽象类不能被final修饰，因为抽象类必须要有儿子。
2、抽象类不能在方法中使用 final修饰，因为抽象类的抽象方法必须要被重写。
3、抽象类可以继承抽象类，所有的抽象方法需要在实现类中一起实现。
4、抽象类中可以有抽象方法，也可以有普通方法、属性、构造方法。
3、接口
1、接口：接口是提供给别人使用的一套规范，具体规范，在接口中我们可以自己定义。
2、接口的作用：充电器和耳机以前是五花八门的，后来定义了充电器和耳机的接口规范。
3、定义接口关键字：interface
4、接口中方法都是抽象方法，不能有方法体。不能有普通方法，不能有构造方法。当前的接口中，只能有抽象方法，不能有实体方法。
1 package cn.aurn.demo03; 2 3 /* 4 5 * 定义充电器接口 6 7 */ 8 9 public interface Usb { 10 11 //充电方法 12 13 public void chongdian(); 14 }
5、定义接口中的属性：接口中不能有变量，只能存在常量。当前的属性也可以使用静态来修饰。
使用静态修饰的好处：接口对象名称调用属性可以直接调用。
//属性
public String name = "充电器";
6、接口能否被final修饰？
1、接口是不能被final修饰的。
2、接口中的方法不能被final修饰。
3、接口中的属性可以被final修饰，因为默认就是使用的final。
7、使用接口：接口是不能直接被new出来的。所以当前必须先有实现类。
8、Java的关系映射：单继承、多实现。
单继承：对象与对象间，继承只能继承1次。
多实现：对象与接口，一个对象可以实现多个接口。
9、接口和抽象类的区别：
1、抽象类可以有普通方法和抽象方法。
2、抽象类中定义的属性是变量。
3、抽象类可以继承抽象类或者普通类。
4、抽象类可以实现接口，但是没有必要。
5、抽象类不能直接创建，需要用多态的方法创建。
1、 接口中只能有抽象的方法。
2、 接口中属性是常量定义。
3、 接口可以继承接口，但不能实现。
4、 接口继承是多继承，抽象类继承是单继承。
5、 不管是接口还是抽象类，对象不能使用final修饰。方法不能使用final修饰。
因为后期在Java中开发项目，项目后期肯定要维护升级的，我们如果使用抽象类，就只能单继承，不方便维护，让项目加大了局限性。而使用接口的话，实现的接口 数量不限，可以多实现，解决了项目后期更新的局限性问题。
理解：
抽象类就相当于是领导，领导定义任务，员工完成。
接口就相当于是规范，接口制定规范，所有员工需要遵守。
4、面向对象：枚举
1、枚举：枚举的意思，就是规定了一定的范围，让用户能够选择使用。
比如性别：可以使用枚举规定，用户选择：男、女。
2、枚举：enum，与class一致创建，但是关键字不能使用class而是需要使用enum
3、枚举和接口定义的属性都一样，是常量，命名规范。
常量属性的名称，都要设置为全大写名称。
当前的命名，区分大小写，记住不能混用，命名完成后，调用中一定要和命名保持一致，否则无法找到，或者调用错误。
4、枚举中，定义方法与属性
1、枚举中能否定义构造方法：可以
2、枚举中能否定义属性：可以
3、枚举中能否定义方法：可以
5、内部类
1、内部类：在当前的对象内，再创建一个对象，称之为内部类
2、我们创建内部类对象规则：
内部类，必须在类对象的括号内创建，命名不能带有小括号。
3、初始化内部类。
注意：因为当前的对象是内部对象，所以先要将外部对象创建出来，再来创建内部对象，外部对象创建内部对象中，使用到了调用，所以创建内部对象的时候，前 面需要带上小点，进行调用。
4、内部对象，是否会生成.class文件：会生成一个Animal$Cat.class文件，因为是否生成class文件，取决于是否使用了class关键字
5、内部类一样和外部类使用，只是内部类是写在对象内的。一样也可以封装、继承、多态
6、匿名对象：就是没有名字的对象，一般使用在创建对象的时候。
注意：当前调用的方法与创建的对象，只会执行一次，它是一次性写法。因为没有给对象在创建的时候命名，所以方法执行完，对象也会随着消失销毁在内存中。 所以如果需要再次调用方法，那么就需要重新再次创建对象。
7、匿名内部类：在当前类中创建一个类，但是不给名称。（因为抽象类与接口不能直接被new，要先直接初始化其实也有方法，我们当前就需要使用匿名内部类）
8、匿名内部类，也会生成一个class文件，虽然没有明文写出，生成的class文件还是会出来，命名使用的是1命名。
9、抽象类和接口能否直接被初始化？
1、正常情况下是不允许直接创建初始化接口和抽象类的。
2、但是也可以使用匿名内部类创建。