Java基础(四)——面向对象

认识面向对象编程

1. 面向对象编程的优点：

   • 凡是找对象的编程套路，更加符合人类思维习惯，编程也会更直观

2. 对象是啥？如何得到？

   • 对象就是一种特殊的数据结构。

   • 对象是用类new出来的，有了类就可以创建出对象

     public class 类名{
         1.变量，用来说明对象可以处理什么数据
         2.方法，描述对象有什么功能，也就是可以对数据进行什么样的处理
         ……
     }

     类名 对象名 = new 类名();

3. 面向对象编程这种套路是咋回事？

   • 祖师爷（詹姆斯·高斯林 ）认为万物皆对象，谁的数据谁处理

4. 面向对象编程的三大特性：继承、封装、多态

对象在计算机中的执行原理

1. 对象在计算机中的执行原理是怎么回事？
   • Student s = new Student();
   • 每次创建对象，就是在堆内存中开辟一块内存区域代表一个学生对象。
   • 对象变量里面记住的是学生对象的地址。
2. 如何识别引用类型的变量？
   • 变量中存储的是地址就是引用类型的变量

类和对象的一些注意事项

1. 类名建议用英文单词，首字母大写，满足驼峰模式，且要有意义，比如：Student、Car……

2. 类中定义的变量也称为成员变量（对象的属性），类中定义的方法也称为成员方法（对象的行为）。

3. 成员变量本身存在默认值。

4. 一个代码文件中，可以写多个class类，但只能一个用public修饰，且public修饰的类名必须称为代码文件名。

5. 对象与对象之间的数据不会相互影响，但多个变量指向同一个对象时就会相互影响了。

6. 如果某个对象没有变量引用它，则该对象无法被操作，该对象会变为所谓的垃圾对象。

   Java存在自动垃圾回收机制，会自动清除掉垃圾对象

this、构造方法

1. this关键字时什么？

   • this就是一个变量，可以用在方法里，用来拿到当前对象；哪个对象调用方法，this就指向哪个对象，也就是拿到哪个对象。

2. this关键字在实际开发中常用来干啥？

   • 用来解决对象的成员变量与方法内部变量的名称一样时，导致访问冲突问题。

3. 构造方法语法：与类名相同，没有方法类型

   public class Student(){
       /*构造方法*/
       public Student(){
           ……
       }
   }

4. 构造方法用途：

   • 对象创建时，我们可以指定对象去调用哪个构造方法执行。
   • 构造方法常用于完成对象初始化（给成员变量传值）

5. 构造方法在使用时的注意事项：

   • 类在设计时，如果不写构造方法Java会为类自动生成一个无参构造方法
   • 一旦定义了有参构造方法，Java就不会自动生成无参构造方法了，此时建议自己手写一个无参构造方法

封装、实体JavaBean

1. 什么是封装？
   • 封装就是用类设计对象处理某一个事物的数据时，应该把要处理的数据，以及处理这些数据的方法。设计到一个对象中去。
2. 封装的设计规范是什么样的？
   • 合理隐藏，合理暴露
3. 代码层如何控制对象的成员公开或隐藏？
   • 公开成员，可以使用public(公开)进行修饰。
   • 隐藏成员，使用private(私有、隐藏)进行修饰。
4. 什么是实体类？有什么特点？
   • 成员变量必须私有，且要为他们提供get、set方法；必须有无参数构造方法
   • 仅仅是一个用来保存数据的Java类，可以用它创建对象，保存某个事物的数据
5. 实体类的应用场景：
   • 实体类对应的是软件开发里现在比较流行的开发方式，数据和数据业务处理相分离

成员变量和局部变量的区别

区别	成员变量	局部变量
类中位置不同	类中，方法外	常见于方法中
初始化值不同	有默认值，不需要初始化赋值	没有默认值，使用之前必须完成赋值
内存位置不同	堆内存	栈内存
作用域不同	整个对象	在所属的大括号中
作用周期不同	与对象相同	随着方法调用而出现，随方法结束而结束

static

1. static叫静态，可以修饰成员变量、成员方法。
2. 成员变量按照有无static修饰，分为两类：
   • 类变量：
     • 有static修饰，属于类，在计算机中只有一份，会被类的全部对象共享
     • 应用场景：如果某一份数据只需要一份，且希望能够被共享（访问、修改），则建议使用类变量来记录
   • 实例变量（对象的变量）：
     • 无static修饰，每个对象都有一份
     • 应用场景：每个对象都要有一份，数据各不同
3. 成员方法按照有无static修饰，分为两类：
   • 类方法（静态方法）：
     • 属于类，可以直接用类名访问，也可以对象访问
     • 应用场景：可以用来设计工具类
   • 实例方法：
     • 属于对象，只能使用对象访问
   • 工具类
     • 工具类中的方法都是类方法，每个类方法都是用来完成一个功能的
     • 工具类提高了代码的复用性；调用方法，提高了开发效率
     • 工具类之所以使用类方法实现，是因为这样可以不用创建对象而浪费内存
     • 工具类不需要创建对象，建议将工具类的构造方法私有化
4. 注意事项：
   • 类方法可以直接访问类的成员，不可以直接访问实例成员
   • 实例方法既可以直接访问类成员，也可以直接访问实例成员
   • 实例方法中可以出现this关键字，类方法中不可以出现this关键字

static应用知识

代码块

1. 代码块概述
   • 代码块是类的5大成分之一（成员变量、构造方法、方法、代码块、内部类）
2. 代码块分为两种：
   • 静态代码块：
     • 格式：static{}
     • 特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次
     • 作用：完成类的初始化，例如：对类变量的初始化赋值
   • 实例代码块：
     • 格式：{}
     • 特点：每次创建对象时，执行实例代码块，并在构造方法前执行
     • 作用：和构造方法一样，都是用来完成对象的初始化，例如：对实例变量进行初始化赋值

单例设计模式

1. 什么是设计模式（Design pattern）？

   • 一个问题通常有很多种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
   • 设计模式有20多种，对应20多种软件开发中会遇到的问题。

2. 单例设计模式：确保一个类只有一个对象。

3. 写法：

   • 把类的构造方法私有
   • 定义一个类变量记住类的对象
   • 定义一个类方法，返回对象

4. 单例的应用场景：任务管理器对象、获取运行时对象

5. 单例设计模式的实现方式很多，如：饿汉式单例、懒汉式单例、……

6. 饿汉式单例设计模式：拿对象时，对象早就创建好了

   public class A{
       
       private static A a = new A();
       
       private A(){
       }
       
       public static A getObject(){
           return a;
       }
   }

7. 懒汉式单例设计模式：拿对象时，才开始创建对象（延迟加载对象）

   public class B{
       
       private static B b;
       
       private b(){
       }
       
       public static B getInstance(){
           if(b == null){
               b = new B();
           }
           
           return b;
       } 
   }

继承

认识继承

1. 什么是继承？继承后有什么有啥特点？

   • 继承就是用extends关键字，让一个类和另一个类建立起一种父子关系

   • 子类可以继承父类非私有成员

2. 带继承关系的类，Java会怎创建它的对象？对象创建出来后，可以直接访问哪些成员？

   • 带继承关系的类，Java会用类和其父类，这么多张设计图来一起创建类的对象。

   • 对象能直接访问什么成员，是由子父类这么多张设计图共同决定，这么多张设计图对外暴露了什么成员，对象就可以访问什么成员。

3. 继承的好处：减少重复代码的编写，提高了代码的复用性。

4. 权限修饰符：就是用来限制类中的成员（成员变量、成员方法、构造方法、代码块……）能够被访问的范围

   修饰符	同一个类	同一个包	子类	任意包
   private	√
   default	√	√
   protected	√	√	√
   public	√	√	√	√

5. 继承相关的两个注意事项：

   • Java是单继承：一个类只能继承一个直接父类；Java中的类不支持多继承，但是支持多层继承。

   • Object类是Java中的所有类的祖宗。

方法重写

1. 方法重写：子类写了一个方法名称、形参列表与父类某个方法一样的方法去覆盖父类的该方法。

2. 重写方法的注意事项：

   • 建议加上：@Override注解，可以校验重写是否正确，同样可读性好。

   • 子类重写父类方法时，访问权限必须大于或等于父类被重写的方法的权限。

   • 重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。

   • 私有方法、静态方法不能被重写。

3. 方法重写应用场景：当子类觉得父类的方法不好用，或者不满足自己需求时，就可以用方法重写

子类访问其他成员的规则、子类构造方法的特点

1. 在子类方法中访问其他成员（成员变量、成员方法），是依照就近原则的。

   • 先子类局部范围找

   • 然后子类成员范围找

   • 然后父类成员范围找，如果都没有找到就会报错

2. 如果子父类中，出现了重名的成员，会优先使用子类，那么该如何使用在子类中使用父类的成员呢？

   • 可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法;

3. 子类构造方法的特点：子类的全部构造方法，都会先调用父类的构造方法，再执行自己。

4. 子类构造方法是如何实现调用父类构造方法的：

   • 默认情况下，子类全部构造方法的第一行代码都是super();（写不写都存在），它会调用父类的无参构造方法。

   • 如果父类没有无参构造方法，则我们必须在子类构造方法的第一行手写super(……);，指定去调用父类的有参构造方法

5. this(……)：在构造方法中调用本类的其他构造方法

6. 注意：使用this()和super()时必须放在构造方法的第一行

多态

认识多态

1. 多态：多态是在继承/实现情况下的一种现象，表现为：对象多态、行为多态。

2. 多态的具体代码实现：

   //Student类和Teacher类均为People类的子类
   
   People p1 = new Student();
   p1.run();
   
   People p2 = new Teacher();
   p2.run();

3. 多态的前提：有继承/实现关系；存在父类引用子类对象；存在方法重写。

4. 注意事项：多态是对象、行为多态，Java中的属性（成员变量）不谈多态。

使用多态的好处

1. 使用代码有什么好处？存在什么问题？
   • 好处：可以解耦合，扩展性更强；使用父类类型的变量作为方法的形参时，可以接收一切子类对象。
   • 问题：多态下不能直接调用子类的独有方法

多态下的类型转换问题

1. 类型转换有几种类型？能解决什么问题？

   • 自动类型转换、强制类型转换

   • 可以把对象转换成其真正的类型，从而解决了多态下不能调用子类独有方法的问题

2. 强制类型转换需要注意什么？

   • 存在继承/实现时，就可以进行强制类型转换，编译阶段不会报错。

   • 但是，运行时，如果发现对象的真实类型与强转后的类型不同会报错（ClassCastException）

3. 强制转换类型前？Java建议我们做什么？

   • 使用instanceof判断当前对象的真实类型：对象 instanceof 类型

final

认识final

1. final关键字是最终的意思，可以修饰（类、方法、变量）
2. 修饰类：该类被称为最终类，特点是不能被继承了。
3. 修饰方法：该方法被称为最终方法，特点是不能被重写了。
4. 修饰变量：该变量只能被赋值一次。
5. final修饰变量的注意：
   • final修饰基本类型的变量，变量存储的数据不能被改变。
   • final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

补充知识：常量详解

1. 使用了static final修饰的成员变量就被称为常量

2. 作用：通常用于记录系统的配置信息。

   public class Constant{
       public static final String SCHOOL_NAME = "伽里敦大学";
   }

   注意：常量名的命名规范：建议大家使用大写英文单词，多个单词使用下划线连接起来。

3. 使用常量记录系统配置信息的优势、执行原理

   • 代码可读性更好，可维护性也更好。
   • 程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。

抽象类

认识抽象类

1. 抽象类、抽象方法是什么样的？

   • 都是用abstract修饰的；抽象方法只有方法签名，不能写方法体。

2. 抽象类有哪些注意事项和特点？

   • 抽象类中可以不写抽象方法，但抽象方法的类一定是抽象类。

   • 类有的成员（成员变量、方法、构造器）抽象类都具备。

   • 抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。

   • 一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象方法。

3. 抽象类的应用场景和好处是什么？

   • 应用场景：父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现。
   • 好处：我们抽出这样的抽象类，就是为了更好的支持多态。

模板方法设计模式

1. 模板方法设计模式解决了什么问题？

   • 解决方法中存在重复代码的问题

2. 模板设计方法应该怎么写？

   1. 定义一个抽象类。

   2. 在里面定义2个方法：

      • 一个是模板方法：把相同代码放里面去。

      • 一个是抽象方法：具体实现交给子类。

3. 建议使用final关键字修饰模板方法

   • 模板方法是给对象直接使用的，不能被子类重写。
   • 一旦子类重写了模板方法，模板方法就失效了

接口

认识接口

1. Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构：接口。

   public interface 接口名{
       //成员变量（常量）
       //成员方法（抽象方法）
   }

   注意：接口不能创建对象

2. 接口是用来被类实现的（implements）的，实现接口的类称为实现类。

   修饰符 class 类名 implements 接口1, 接口2，……{
       
   }

   一个类可以实现多个接口，实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

使用接口的好处

1. 弥补了类单继承的不足，一个类可以同时实现多个接口
2. 别人通过类实现的接口，就可以显性的知道类实现的功能
3. 让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现

其他细节

1. JDK8开始，在接口中新增了哪些方法？

   • 默认方法：使用default修饰，使用实现类的对象调用

   • 静态方法：static修饰，必须使用当前接口名调用

   • 私有方法：private修饰，jdk9开始才有的，只能在接口内部被调用

   • 他们都会默认被public修饰

2. JDK8开始，接口为什么要新增这些方法？

   • 增强了接口的能力，更便于项目的扩展和维护

3. 接口的多继承：一个接口可以同时继承多个接口

   interface A{}
   interface B{}
   interface C{}
   
   // 接口是多继承的
   interface D extends C, B, A{
       
   }

   接口多继承的作用：便于实现类去实现

4. 接口其他注意事项：

   • 一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承
   • 一个类实现多个接口，如果多个继承中存在方法签名冲突，则此时不支持多实现
   • 一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的
   • 一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写方法即可