Java学习——面向对象（二）封装/继承/多态

面向对象的三大特性

封装

1、概念

指隐藏对象的属性和实现细节，仅对外提供公共访问形式。也就是我们平时使用的将方法写在类中，然后通过创建对象或者直接调用，但是在学校里做作业一般使用的都是public类型，体现不出封装的作用，当我们慢慢的学习就会发现它的好处实在很多：

• 1.隐藏实现细节（可以直接用.调用不需要展示我们写好的代码）
• 2.提高代码复用（不用因为重复的功能而一次又一次的写相同的代码）
• 3.提高安全性（保护我们写好的代码不被别人使用或剽窃）

2、关键字

封装常用的关键字为this、private以及static下面我们分开介绍

This关键字

1.概念

• （1）可以代表类的对象引用
• （2）this存在某个方法中时，每当这个方法被调用，this就可以代表那个调用方法的对象。

2.作用
this可以在局部变量和成员变量同名时，指代成员变量，加以区分。

Private关键字

前面有过详细介绍，在这里就不多提了。

Static关键字

1.作用

针对多个对象共有的成员变量时，加上static修饰就可以让所有对象共用一个成员变量。
而且static不仅可以修饰变量，也可以修饰方法，我们最常使用的主方法main就是静态的。

注意

• 静态方法中不存在this关键字
• 静态方法只能访问静态的成员变量和成员方法
• 如果想在静态方法中调用非静态方法，必须创建对象，通过对象调用。

3、实现封装

想要真正的封装我们已经提过了不可以使用public修饰，而与之相对的我们需要用到private修饰符，来保证我们代码的安全，按时用私有化了代码之后，我们的调用就会出现问题，这里我们就需要使用系统提供的get/set方法来实现。

其中get是用来获取私有的值，通过set进行设置或者修改。
而他们的写法也十分简单，只要如下图即可

实在记不住的可以用快捷键，这里我用的是IDEA，我们只要右键选择Generate或者快捷键Alt+Insert就可以打开一个界面，在这里我们不仅可以快速创建get/set方法，甚至重写方法，toString方法都可以在这里找到进行快速编写。

4、构造方法

1.作用
对象的创建就是由构造方法来完成，它的主要功能就是完成对象的初始化，当类实例化一个对象时会自动调用构造方法。

2.格式

修饰符 类名(){

     方法体;

}
例如：
class A{
public A(){
System.out.print("hello A")
}

但是要注意

• 方法名与类名相同
• 构造方法没有返回值类型，脸void也不可以有
• 构造方法没有具体返回值
• 如果你没有给出构造方法，系统会自动提供一个无参构造方法，但是你只要写了构造方法，系统提供的就会消失
• 构造方法可以重载

5.JavaBean

JavaBean说白了就是一中编程格式，是一种规范化。

规范：

• 成员变量私有化
• 提供get/set方法
• 提供无参构造方法
• 提供有参构造方法

将这些全部写完就是一个比较完整的JavaBean了。

6、代码块

1.静态代码块

位置：类中，方法外

格式：static{要执行的语句}

随着类的加载而只执行一次

2.构造代码块

位置：类中，方法外

格式：{要执行的语句;}

每创建一个对象，就会执行一次。

用于初始化所有构造方法都必须初始化的数据

3.局部代码块

位置：方法中的一对大括号

格式：{要执行的语句;}

执行完后会被立马认为是垃圾

4.执行顺序

静态代码块>构造代码块>构造方法

继承

1、概述

为什么需要继承呢？这是学习之前的第一个问题，我们可以从平时的学习中看到，要是我有两个类，都是用来描述人的，只是人的性别、名字等属性不同，那么我们这两个人在没有继承的情况下，最快的只是复制粘贴，但是有了继承之后，这些相同的属性和行为，我们可以变成一个个成员抽取到一个类中，将这个类作为父类，让其他的类去继承他，那么我们这些子类就不用再去定义这些属性和行为了。

注意：

Java中如果没有继承任何父类，会默认继承一个叫Object的系统给出的类。

2、优点

1. 提高代码复用性，多个类的成员可以放在一个类中。
2. 提高了代码的维护性，如果我们需要修改，只需要修改一处就可以。
3. 让类与类之间产生联系，但是这个也是集成的一个缺点，看你怎么理解，当类继承产生联系后，类之间的耦合性会很强。

3、格式

class 子类名 extends 父类名
例如：
class A{
.........
}
class B extends A{
.........
}

注意：

Java中只可以单继承，不可以多继承，但是可以多层继承 ，意思就是一个类只可以有一个爸爸，但是可以有爷爷、祖父。

4、继承中的关系

1.成员变量的关系

• 首先在子类的局部范围查找
• 然后查找子类的成员范围
• 最后在父类的成员范围查找
• 如果还是找不到这个成员变量就报错

2.构造方法的关系

• 子类中所有构造方法默认访问父类的无参构造方法
• 如果父类没有无参构造方法，那么子类通过super去显示调用父类其他的带参的构造方法（super后面会写）
• 子类通过this去调用本类的其他构造方法，但是本类的其他构造方法也必须首先访问父类构造方法
• 注意：super（…）和 this（…）必须出现在第一行

5、Super

1. 只能用于子类
2. 当子类的成员和父类的名字相同时，可以用super指代父类成员
3. 子类可以通过super曲线是调用父类的有参构造方法
4. 静态方法中没有this和super
5. super代表弗雷德存储空间标识，也可以理解为他是父类的一个引用。

例如：
class Father{
public Father(int i){
}
}

class Son extends Father{
public Son(int i){
super(i);
}
}

6、方法重写

1、概述
当子类和父类中出现了一样（返回值，名字，参数列表）的方法时，这种情况就是方法重写，也叫方法覆盖。

2、应用
当子类需要父类的功能，但是子类中又有自己的定义，这种情况下就可以重写父类中的方法，这样既沿袭了父类的功能，也定义了子类的功能 。
3、注意

1. 父类中的私有方法不可以被重写
2. 子类重写父类方法时，权限不能比父类还低。比如父类中是public，子类重写的方法就不可以是private的。
3. 父类的静态方法，子类也必须通过静态的格式去重写，但是静态的方法重写完毕后，不具备重写特性，只是单独的一个子类功能，所以在我们实例化调用时一定要注意。

7、final关键字

1.特点

• 被final修饰的变量就变成了自定义常量(必须赋值)，但是只能被赋值一次

• final修饰的方法不能被重写

• final修饰的类不能被继承

• 注意：
  例如：

  public class FinalDemo {
  
    final Student p = new Student();
    
    public void test(){
   
      final int b = 10;
   
  //p = new Person(); 地址值不能变,会报错
   
      p.name = "张三";
   
    }
   
   }
  

8、单例设计模式

1、概述
单例模式就是字面意思，一个类只产生一个实例对象，后面再实例化虽然不会报错，但是地址值不会改变，也就是确定了实例化对象的地址值，来保证单例实现。

2、实现方法
单例模式的实现方法很多，网上一搜就会有一大片，这里我们就介绍其中两种比较好理解而且简单的方法。

饿汉式：

public class Singleton {

 private static Singleton s = new Singleton();

 private Singleton() { }

 public static Singleton getInstance() {

   return s;

 }
 
}
public class SingletonTest {

 public static void main(String[] args) {

   //不管new多少次都是同一个对象

   Singleton s = Singleton.getInstance();

   Singleton s1 = Singleton.getInstance();
   
   System.out.println(s == s1);//== 在连接引用类型的时候，比较的是地址值

 }

}

懒汉式：

public class Singleton2 {

 private static Singleton2 s = null;

 private Singleton2() {

 }

 public static Singleton2 getInstance() {

   if (s == null) {

    s = new Singleton2();

   }

   return s;

 }
 
}

这里的两个方法其实思想是大致相同的，我们既然要保证实例化的时候地址值不变，那么我们可以想到，实例化对象一定会调用构造方法，那么我们解决这个问题就可以在构造方法中做一些处理来保证单例模式，从代码中可以看到，两种方法都是在类中定义了构造方法，通过提前一次实例化，来保证这个构造方法在被调用时只能实例化一次。这个步骤我们大体可以理解为：

1. 私有化构造方法
2. 创建静态对象
3. 提供公有的访问对象来访问私有方法

多态

1、概述
也可以从字面意思理解，多态就是一个事物，在不同环境下表现出的不同状态。
多态的好处：

• 提高了程序的维护性（继承保证）
• 提高了程序的可扩展性（多态保证）

除此之外多态也有自己的弊端，他不可以访问子类的特有功能，意思就是多态只可以访问父类子类中共有的功能。

2、多态的实现

• 必须存在继承关系
• 要有方法的重写
• 要有父类引用指向子类对象

这里的三个特点都是多态实现的前提，其中“ 要有父类引用指向子类对象”这句话比较难理解，他的意思就是，实例化时，用父类接受子类的对象，这里涉及到了一个新的知识，转型：

• 向上转型：
  从子类到父类，用父类接受子类的对象，即引用指向子类对象。

• 向下转型
  有父类到子类，用子类接受一个类似于强转的父类对象，即父类引用转为子类对象。

例如：

Father f =new Son()；//向上转型
Son s=(Son) f;//向下转型

后续：

https://blog.csdn.net/qq_40343117/article/details/97613214