面向对象

Posted 2021-03-21 qjc-hll-520

一、面向对象：封装

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、但是也可以使用匿名内部类创建。