Java_02
- 第三章面向对象

Java_02

在此之前想要阅览上一部分《Java_01》的内容：

请访问：https://www.yuque.com/docs/share/957e0fc0-04f6-41e6-baa8-2bfc17a80cfa?# 《Java_01》密码：vlif

第三章面向对象

3.1 面向对象初级

3.1.1 类与对象

一个程序就是一个世界，有很多事物(对象[属性，行为])。

类与对象的关系示意图举例：

Java_02 - 图1

猫类Cat => 自定义的数据类型。

说明：

可以通过猫类创建一个猫的对象。
类就是数据类型，对象就是这个对象的具体实例体现。
类是对象的模板，对象是类的一个个个体，对应一个实例。

当然上面的猫也可以是鱼、狗、鸡、鸭…

案例：

// 使用面向对象的方式来解决养猫问题
// 定义一个猫类 Cat => 自定义的数据类型
class Cat{
 // 属性
 String name;
 int age;
 String color;
 // 行为
}
// 使用OOP面向对象解决
// 实例化一只猫
// cat1 就是一只对象
public class void main(String[] args){
 Cat cat1 = new Cat();
 cat1.name = "小白";
 cat1.age = 3;
 cat1.color = "白色";
 Cat cat2 = new Cat();
 cat2.name = "小蓝";
 cat2.age = 5;
 cat2.color = "蓝色";
}

属性/成员变量概念：

属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型(对象，数组)。
例如我们前面定义猫类的名字年龄就是属性。

说明：

属性定义语法与变量相同，示例：修饰符类型属性名；。
属性的定义可以为任意类型，包含基本类型或引用类型。
属性如果不赋值，则有默认值，规则和数组一致。

类和对象的内存分配机制：

栈：一般存放基本数据类型(局部变量)。
堆：一般存放对象。
方法区：常量池，类加载信息

流程简单分析：

先加载类信息(属性和方法信息，只会加载一次)。
在堆中分配空间，进行默认初始化(看规则)。
把地址赋给p,p就指向对象。
进行指定初始化，比如p.name = “jack” p.age = 10

3.1.2 成员方法

在某些情况下，我们需要定义成员方法。当我们需要让一个对象完成一系列的行为时，这个时候要用成员方法来完成。

方法的调用机制

当程序执行到方法时，就会开辟一个独立的栈空间。
当方法执行完毕，或者执行到return语句时，就会返回。
返回到调用方法的地方。
完成后，继续执行方法后面的代码。
当main方法执行完毕，整个程序退出。

方法的定义

参数列表：表示成员方法输入，如show(int n)。
数据类型(返回类型)：表示成员方法输出。
void 表示没有返回值。
方法主体：表示为了实现某一功能的代码块。
return语句不是必须的。

形参列表

一个方法可以有0个参数，也可以有多个，中间用逗号隔开。
参数类型可以为任意类型。
调用带参数方法时，一定对应着参数列表传入相同类型或兼容类型的参数。
方法定义时的参数称为形式参数，简称形参。
方法调用时的参数成为实际参数，简称实参。
实参和形参的类型要一致或兼容、个数、顺序必须一致。

/*
访问修饰符 返回数据类型 方法名(参数列表){
    语句;
    return 返回值;
}
*/

3.1.3 传参机制

Java里方法的参数传递方式只有一种:值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型:将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型:将实参引用数据类型变量的“地址值”传递给形参

要注意一些方法中是局部变量，做一些算法时候可能会导致对应的变量的值没有改变，这时候需要考虑传递引用类型的值，思考下java虚拟机的栈和堆的内存模型。

3.1.4 重载

Java中允许同一个类中，多个方法同名存在，但要求形参列表不一致！

重载的使用

方法名：必须相同。
形参列表：必须不同。
返回类型：无要求。

3.1.5 可变参数

Java允许将同一个类中多个同名同功能但参数不同的方法，封装成一个方法，通过可变参数实现。

语法：

访问修饰符返回类型方法名(数据类型…形参名){

语句；

}

细节说明：

可变参数的实参可以为0个或任意多个。
可变参数的实参可以为数组。
可变参数的本质就是数组。
可变参数可以和普通参数的参数一起放在形参列表。
一个形参列表中只能出现一个可变参数。

public class VarParameter01{
// 编写一个类方法
public static void main(String[] args){
    HspMethod h = new HspMethod();
 h.sum(1,2,3);
}
}
class HspMethod{
// 可以计算n个数的和
// 可以使用方法的重载
// 1.int... 表示接受的是可变参数，类型是int
// 2.使用可变参数时，可以当做数组来使用
public int sum(int... nums) {
  System.out.println("接收的参数个数=" + nums.length);
  return 0;
}
}

3.1.5 作用域

Java用一对大括号作为语句块的范围，称为作用域，作为在作用域里定义的一个变量，它只有在哪个作用域结束之前才可使用。

说明：

在Java中，主要的变量就是属性(成员变量)和局部变量。
我们说的局部变量一般是指在成员方法中定义的变量。

Java中作用域的分类：
全局变量：也就是属性，作用域为整个类体。

局部变量：也就是出来属性之外的其它变量。
全局变量可以不赋值直接使用，因为有默认值，局部变量必须赋值。

使用：

属性和局部变量可以重名，访问时遵循就近原则。
在同一个作用域中，两个局部变量不能重名。
作用域范围不同

全局变量：可以被本类使用，或他类使用。
局部变量：只能在本类中对应方法中使用。

修饰符不同

全局变量可以加修饰符
局部变量不可以加修饰符

3.1.6 构造器

构造方法，Java中的构造方法是一种特殊的方法，用于初始化对象。java构造函数在对象创建时被调用，它构造值，即提供对象的数据。

语法：

修饰符方法体(形参列表){

方法体；

}

说明：

构造器的修饰符可以默认。
构造器没有返回值。
方法名和类名必须一样。
参数列表和成员方法规则相同。

3.1.7 this

Java虚拟机会给每个对象分配this，代表当前对象。

简单的说，哪个对象调用，this就代表哪个对象。

class Dog{
 public String name;
 public int age;
 public Dog(String name,int in_age){
     this.name = name;
     this.age = in_age;
    }
}

3.2 面向对象中级

3.2.1 IDEA

IDEA介绍:

IDEA 全称 IntelliJ IDEA 。
在业界被公认为最好的Java开发工具。
IDEA是JetBrains公司的产品，总部位于捷克。
除了支持Java，还支持HTML，CSS，PHP，MySQL，Python等语言开发。

IDEA快捷键：

快捷键	作用
ctrl + alt + S	打开setting窗口
ctrl + alt + S	打开setting窗口
ctrl + shift + alt + S	打开项目架构窗口
ctrl + F9	快速进行代码编译S
ctrl + D	删除当前行
ctrl + Y	复制当前行
ctrl + Z	回退刚才的效果YZ
ctrl + shift + Z	撤销刚才的回退
ctrl + shift + U	切换选中的字母大小写
ctrl + N	快速查找class文件
ctrl + shift + N	快速查找所有格式的文件
ctrl + shift + alt + N	直接搜索方法
ctrl + shift + V	查看最近在IDEA中复制过的几条记录
alt + Insert	在编写实体类时可以快速生成构造方法等
alt + enter	IDEA帮你操作当前应该做的操作，比如import包等
shift + Esc	关闭当前Tab页
ctrl + alt + O	快速移除当V前类中的失效import引用
ctrl + alt + V	自动补全属性名称及类型

3.2.2 包

实际上就是创建不同的文件夹来保存文件。

包的三大作用

区分相同名字的类。
当类很多时，可以更好的管理类。
控制访问范围。

包的基本语法

package com.JierZhou;

说明：

package关键字，表示打包。
com.JierZhou 表示包名。

包的命名

只能包含数字、字母、下划线、小圆点，但不能以数字开头，不能是关键字或保留字。
命名规范：com.公司名.项目名.业务模块

常用的包

一个包下包含着很多类，Java常用的包有:

java.lang.*; // lang包是基本包，默认引入，不需要再导入
java.util.*; // util包，系统提供的工具包，工具类
java.net.*; // 网络包，网络开发
java.awt.*; // 做Java的界面开发，GUI

包的引入

语法：import 包

说明：

我们引入一个包的主要目的就是引用该包下的类。
import java.util.*；// 表示将java.util包所有都类都引入

3.2.3 访问修饰符

Java一共提供了四种访问修饰符号控制方法和属性的访问权限。

访问修饰符号

public：公开级别，对外公开。
protected:受保护级别，对子类和统一包中的类公开。
default：默认级别，没有修饰符号，像同一个包的类公开。
private：私有级别，用private修饰，只有类本身可以访问，不对外公开。

使用修饰符

修饰符可以用来修饰类中的属性，成员方法以及类。
只有默认的和public才能修饰类，并且遵循访问权限的特点。

3.2.4 OOP三大特征

面向对象编程有三大特征：封装、继承和多态。

3.2.4.1 封装

封装就是把抽象出的数据和对数据的操作方法封装再一起，数据被保护在内部，

程序的其它部分只能通过被授权的操作才能对数据进行操作。

封装的理解和好处

隐藏实现的细节方法 <— 调用(传入参数)。
可以对数据进行验证，保证安全合理。

封装的实现步骤

将属性进行私有化private，不能直接修改属性。
提供一个公共的set方法，用于对属性判断并赋值
public void setXxx(参数){
//加入数据验证业务逻辑
属性 = 参数名；
}
提供一个公共的get方法，用于获取属性的值
public XX getXx(){
return xx;
}

3.2.4.2 继承

继承可以解决代码复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

继承的基本语法

class 子类 extends 父类{
方法体；
}

子类会自动拥有父类定义的属性和方法。
父类又叫超类，基类。
子类又叫派生类。

继承优点

代码的复用性提高。
代码的拓展性和维护性提高。

细节

子类继承了所有的属性和方法，非私有的属性和方法可以在子类中直接访问，但是私有属性和方法不能在子类直接访问，要通过公共的方法去访问。
子类必须调用父类的后遭器，完成父类的初始化。
当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参的构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则无法通过编译。
如果希望指定去调用父类的某个构造器，则显式的调用一下：super(参数列表)。
super在使用时必须放在构造器第一行。
super()和this()都只能放在构造器的一行，因此两个方法不能共存在一个构造器。
Java所有类都是Object类的子类，Object是所有类的基类。
父类构造器的调用不限于直接父类，将一直往上追溯直到Object类。
子类最多只能继承一个父类，即Java是单继承机制。
不能滥用继承，子类和父类之间必须满足is-a的逻辑关系。

3.2.4.3 多态

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础上的。

多态的体现

方法的多态
对象的多态

一个对象的编译类型和运行类型可以不一致。
编译类型在定义对象时，就确定了，不能改变。
运行类型时可以变化的。
编译类型看定义时 = 号的左边，运行类型看 = 号的右边。

public class PolyObeject{
    public static void main(String[] args){
        // 体验对象多态的特点
        // animal 编译类型就是 Animal,运行类型 Dog
        Animal animal = new dog();
        // 因为运行执行到该行时，animal运行类型就是Dog,所以就是Dog的cry
        animal.cry(); 
        // animal 编译类型 Animal，运行类型就是Cat
        animal = new Cat();
        animal.cry(); 
    }
}
class Animal{
   public void cry(){
       System.out.println("动物在叫....");
   }
}
class Dog extends Animal{
    @Override
    public void cry(){
        System.out.println("小狗在叫....");
   }
}
class Cat extends Animal{
    @Override
    public void cry(){
        System.out.println("小毛在叫....");
   }
}

public class PloyMethod {
    public static void main(String[] args) {
        // 方法重载体现多态
        A a = new A();
        // 这里我们传入不同的参数，就会 调用不同的sum方法，体现多态。
        System.out.println(a.sum(10,20));
        System.out.println(a.sum(10,20,30));
           // 方法重写体现多态
        B b = new B();
        a.say();  
        b.say();
    }
}
class B { // 父类
    public void say(){
        System.out,println("B say() 方法被调用...");
    }
}
class A extends B{ // 子类
    public int sum(int n1,int n2){ // 和下面的sum构成重载
        return n1 + n2;
    }
    public int sum(int n1,int n2,int n3){ // 和上面的sum构成重载
        return n1 + n2 + n3;
    }
}

多态的向上转型

本质：父类的引用指向了子类的对象。
语法：父类类型引用名 = new 子类类型()；
特点：

编译类型看左边，运行类型看右边。
可以调用父类中的所有成员(需遵守访问权限)。
不能调用子类中特有成员；
在编译阶段，能调用哪些成员，是由编译类型决定的。
最终运行效果看子类的具体实现，即调用方法时，按照从子类开始查找方法。

多态的向下转型

语法：子类类型引用名 = (子类类型) 父类引用；
只能强转父类的引用，不能强转父类的对象。
要求父类的引用必须指向的是当前目标类型的对象。
可当向下转型后，就可以调用子类类型中所有的成员。

属性重写问题

属性没有重写之说！属性的值看编译类型。

public class PolyDetail02{
    public static void main(String[] args){
        // 向上转型
        Base base = new Base();
        System.out.println(base.count); // 10
        Sub sub = new Sub();
        System.out.println(sub.count);
    }
}
class Base{
    int count = 10;
}
class Sub{
    int count = 20;
}

Java的动态绑定

当调用对象方法的时候，该方法会和对象的内存地址/运行类型绑定。
当调用对象属性的时候，没有动态绑定机制，哪里声明，哪里使用。

public class Poly {
    public static void main(String[] args){
        // a的编译类型A，运行类型B
           A a = new B(); // 向上转型
        // 动态绑定机制
        System.out.println(a.sum()); // 40 -> 30
        System.out.println(a.sum1()); // 30
    }
}
class A { // 父类
    public int i = 10;
    public int sum(){
        return getI() +10; // getI()方法会和对象的内存地址/运行类型绑定
    }
    public int sum1(){
        return i + 10;
    }
    public int getI(){
        return i;
    }
}
class B extends A { //子类
    public int i = 20;
    // public int sum(){
    //     return get() +20;
    // }
    public int sum1(){
        return i + 10;
    }
    public int getI(){
        return i;
    }
}

3.2.5 Super关键字

super表示父类的引用，用于访问父类的属性、方法、构造器。

语法：

访问父类的属性，但不能访问父类的private属性。
super.属性名(参数列表);
访问父类的方法，不能直接访问父类的private方法。
super.方法名(参数列表);
访问父类的构造器：
super(参数列表)；只能放在第一句且只能出现一句！

细节：

调用父类构造器的好处：分工明确，父类由父类初始化，子类的属性由子类初始化。
当子类中由和父类成员同名的时候，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果！
super的访问不限于直接父类，如果爷爷类和本类中由同名的成员，也可以使用super去访问爷爷类的成员；如果搓个基类(上级类)中都有同名的成员，使用super遵循就近原则。

3.2.6 方法重写

简单的说：方法重写就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类这个方法覆盖了父类的那个方法。

细节：

子类的方法的参数，方法名称，要和父类方法的参数，方法名称完全一样。
子类方法的返回类型和父类方法返回类型一样，或是父类返回类型的子类。
子类方法不能缩小父类方法的访问权限。

3.2.7 Object类

所有类的超类。

== 和 equals 的对比

== 是一个比较运算符

既可以判断基本类型，又可以判断引用类型。
如果判断基本类型，判断的是值否相等。
如果判断引用类型，判断地址是否相等，即判断是不是同一个对象。

equals 是一个Object类的方法

只能判断引用类型。
默认判断的是地址是否相等，子类往往重写该方法，用于判断内容是否相等。

== 是指对内存地址进行比较，equals()是对字符串的内容进行比较。
== 指引用是否相同，equals()指的是值是否相同。

**hashCode()**

提高具有哈希结构容器的效率！
两个引用，如果指向的是同一个对象，则哈希值肯定是一样的，若指向的不同对象，则哈希值是不一样的。
哈希值主要根据地址号来的，但不能完全将哈希值等价于地址。
后面在集合中，hashCode()如果需要的话也会重写。

public class HaseCode_ {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa1 = aa;
        System.out.println("aa.hashCode()="+aa.hashCode());
        System.out.println("aa2.hashCode()="+aa2.hashCode());
        System.out.println("aa1.hashCode()="+aa1.hashCode());
    }
}
class AA{}
// aa.hashCode()=381259350
// aa2.hashCode()=284720968
// aa1.hashCode()=381259350

**toString()**

默认返回:全类名 + @ + 哈希值的十六进制。
子类往往重写toString方法，用于返回对象的属性信息。
重写toString方法，打印对或拼接对象时，都会自动调用该对象的toString形式。
当直接输出一个对象时，toString方法会被默认调用。

**finalize()**

当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法做一些释放资源的操作。
什么时候被回收：当某个对象没有任何引用时，则JVM就会认为这个对象时一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁之前，会先调用finalize方法。
垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制。

3.2.8 断点调试（Debug）

在开发过程中，新手程序员在查找错误时，可以使用断点调试一步一步看源码执行过程，从而发现错误所在。

断点调试概念

断点调试是指在程序某一行设置一个断点，在调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码即显示错误，进行分析从而找到这个Bug。
在断点调试过程中，是运行状态，是以对象的运行类型来执行的。
断点调试是程序员必须掌握的技能。
断点调试也能帮助我们查看Java底层源代码的执行过程，提高程序员的Java水平。
断点可以在Debug过程中动态的下断点。

断点调试的快捷键

：跳入方法。
：逐行执行代码。
+：跳出方法。
：跳出到下一个断点。

3.3 面向对象高级

3.3.1 类变量和类方法

静态变量和静态方法

类变量

类变量也叫静态变量/静态属性，是该类的所有对象的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。
语法:
访问修饰符 static 数据类型变量名；
访问方式：类名.类变量名

类变量说明

当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）。
类变量是该类所有对象共享的，而实例变量是每个对象独享的
加上static称为类变量或静态变量。

类方法

类方法也叫静态方法。
语法：
访问修饰符 static 数据返回类型方法名(){}
类方法的调用：
类名.方法名或对象名.类方法名
当方法中不涉及到任何与对象相关的成员，则可以将方法设计成静态方法，提高开发效率。

类方法说明

类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：
类方法中无this的参数。
普通方法中隐含着this的参数。
类方法可以通过类名调用，也可以通过对象名。
普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。

3.3.2 main方法语法

主函数入口

深入理解main方法

解释main方法的形式：public static void main(String[] args){}

Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public。
Java虚拟机在执行main()方法时不必创建对象，所以该方法必须时static。
该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的参数，接收参数。

在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性。
不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

3.3.3 代码块

代码块又称为初始化块，属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但是和方法不同，没有方法名，没有返回，没有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

理解

相当于另外一种形式的构造器，可以做初始化操作。
场景：如果多个构造器中有重复的语句，可以抽取到初始化块中，提高代码的重用性。

语法

[修饰符]{
代码；
}

注意

修饰符可选，要写的话，也只能写static。
代码块分为两类，使用static修饰的叫静态代码块。
逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)。
；号可以写上，也可以省略。

实例

细节

static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行依次，如果是普通代码块，每创建一个对象就执行。
类什么时候被加载？

创建对象实例时(new)。
创建子类对象实例，父类也会被加载，父类先加载，再到子类。
使用类的静态成员时。

普通的代码块，在创建对象实例的时候，就会被隐式调用，被创建一次就会调用一次，如果只是使用类的静态成员时，不同代码块并不会执行。
创建一个对象时，在一个类调用顺序是：

调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)。
调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多普通态代码块和多个普通变量初始化，则按他们定义的顺序调用)。
调用构造方法。

构造器的最前面其实隐藏了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此时优先于构造器和普通代码块执行的。
创建一个子类对象时(继承关系)，他们的调用顺序时怎样的：

父类的静态代码块和静态属性。
子类的静态代码块和静态属性。
父类的普通代码和普通属性初始化。
父类的构造方法。
子类的普通代码和普通属性初始化。
子类的构造方法。

静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。

public class CodeClock{
    public static void main(String[] args){
        Movie movie = new Movie("你好，Java!");
    }
}
class Movie{
    String name;
    double price;
    // 1.下面的三个构造器都有相同的语句前提下
    // 2.这样的代码看起来比较冗余
    // 3.这时我们可以把相同的语句，放入到一个代码块中
    // 4.这样当我们不管调用哪个构造器，都会先调用代码块的内容
    // 5.代码块调用的顺序优先于构造器
    {
        System.out.println("电影屏幕打开...");
        System.out.println("电影广告开始...");
        System.out.println("电影广告结束...");
    }
    public Movie(String name){
        this.name = name;
    }
    public Movie(String name,double price){
        this.name = name;this.price = price;
    }
}

3.3.4 单例设计模式

所谓类的单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

单例模式-饿汉式-案例

类的初始化的时候实例已经被加载。

// 有一个类
// 只能有一个女朋友
class GirlFriend{
    private String name;
    // 为了能够在静态方法中，返回gf对象，需要将其修饰成静态
    private static GirlFriend gf = new GrilFriend("小红红");
    // 如何保障我们只能创建一个 GirlFriend 对象
    // 步骤[单例模式-饿汉式]
    // 1.将构造器私有化
    // 2.在类的内部直接创建(该对象是静态的)
    // 3.提供一个公共的静态方法，返回gf对象
    private GridFriend(String name){
        this.name = name;
    }
    public static GridFriend getInstance(){
        return gf;
    }  
}
public class SingleTon01{
    public static void main(String[] args){
        GrilFriend instance = GrilFriend.getInstance();
        System.out.println(instance);
    }
}

单例模式-懒汉式-案例

class Cat{
    private String name;
    private static Cat cat;
    // 步骤
    // 1.仍然使构造器私有化
    // 2.定义一个static属性对象
    // 3.提供一个public的static方法，可以返回一只Cat对象
    // 4.懒汉式只有当用户使用getInstance时，才会返回Cat对象
    //   后面再次调用的时候，会返回上次创建的Cat对象
    //   从而保证了单例
    private Cat(String name){
        this.name = name;
    }
    public static Cat getInstance(){
        if(cat == null){//如果没有创建Cat对象
            cat = new Cat("小可爱");
        }
        return cat;
    }
}
public class SingleTon02{
    public static void main(String[] args){
        Cat instance = Cat.getInstance();
        System.out.println(instance)
    }
}

总结

饿汉式 VS 懒汉式

二者主要的区别在于创建对象的时机不同:饿汉式是在加载类时就创建了对象实例，而懒汉式则是在使用时才创建。
饿汉式不存在线程安全问题，懒汉式存在线程安全问题。
饿汉式存在浪费资源的可能，因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了。
在我们JavaSE标准类中，Java.lang.Runtime就是经典的单例模式。

设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像经典的棋谱，不同的棋局，我们用不同的棋谱，免得我们自己再思考。

3.3.5 final关键字

final中文意思：最后的，最终的。

final可以修饰类、属性、方法和局部变量。

用法

当不希望类被继承时，可以用final修饰。
当不希望父类的某个方法被子类覆盖/重写时，可以用final修饰。
当不希望类的某个属性被修改，可以用final修饰。
当不希望某个局部变量被修改，可以使用final修饰。

注意事项

final修饰的属性又叫常量，一般用 XX_XX_XX来命名。
final修饰的属性在定义时，不许赋初值，并且不能再修改，赋值可以再如下位置位置之一：

定义时:如 public final double TAX_RATE = 0.08;
在构造器中
在代码块中

如果final修饰的属性是静态的，则初始化的位置只能是定义时和在静态代码块中，不能在构造器中赋值。
final类不能被继承，但是可以实例化对象。
如果不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承，即仍然遵循继承机制。
一般来说，如果一个类是final类，就没有必要再将方法修饰成final方法。
final不能修饰构造器。
final和static通常搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理。
包装类(Integer,Double,Float,Boolean等都是final，String也是final类。

3.3.6 抽象类

当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。

解析

用abstract关键字来修饰一个类时，这个类就叫抽象类。
语法：
访问修饰符 abstract 类名{
主体；
}
用abstract关键字来修饰一个方法时，这个方法就是抽象方法。
语法：
访问修饰符 abstract 返回类型方法名(参数列表);// 没有方法体
抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()。
抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多。
抽象类可以又任意的成员(抽象类还是类)。
抽象方法不能有主体。
如果一个类继承了抽象类，则它必须实现抽象类的所有方法，除非它自己也声明为抽象类。

抽象类实践-模板设计模式

需求：

有多个类，完成不同的任务Job。
要求统计得到各自完成任务的时间。

案例：

设计一个抽象类(Template),能完成以下功能：

编写方法calculateTime(),可以计算代码消耗的时间。
编写抽象方法job()。
编写一个子类Sub，继承Template，并实现Job()方法。

abstract class Template{ //抽象类-模板设计模式
    public abstract void job();// 抽象方法
    public void calculateTime(){
        // 得到开始的时间
        long start = System.currentTimeMillis();
        job(); //动态绑定机制
        // 得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间" + (end - start));
    }
}
class A extends Template{
    public void job(){ // 重写了job方法
        long num = 0;
        for(long i = 1; i <= 8000000; i++)
        {
            num *= i;
        }
    }
}
class B extends Template{ // 重写了job方法
    public void job(){
        long num = 0;
        for(long i = 1; i <= 8000000; i++)
        {
            num *= i;
        }
    }
}
public class abstract_{
    A a = new A();
    a.calculateTime();
    B b = new B();
    b.calculateTime();
}

3.3.7 接口

引入接口

USB插槽就是现实中的接口，通常我们可以把手机、相机、优盘等插在USB槽上，而不用担心哪个是专门插哪个槽的，原因就是做USB插槽的厂家和各种设备的厂家都遵守了统一的规定包括尺寸，排线等。

引例：

interface UsbInterface{ // 这就是一个接口
    // 规定接口的相关方法,类似于规定接口的规格
    public void start();
    public void stop();
}
// Phone 类实现 UsbInterface
// 即 Phone 这个类需要实现 UsbInterface 接口规定/声明的方法
public class Phone implements UsbInterface{ // 实现接口，把接口方法完成
    @Override
    public void start(){
        System.out.println("手机开始工作...");
    }
    @Override
    public void stop(){
        System.out.println("手机停止工作...");
    }
}
//同理，定义相机
public class Camera implements UsbInterface{
    @Override
    public void start(){
        System.out.println("相机开始工作...");
    }
    @Override
    public void stop(){
        System.out.println("相机停止工作...");
    }
}
// 定义电脑并装上一个接口插槽
public class Computer{
    // 编写一个方法
    public void work(UsbInterface usbInterface){
        usbInterface.start();
        usbInterface.stop();
    }
}
public class TestLink{
    // 创建手机，相机对象
    Phone phone = new Phone();
    Camera camera = new Camera();
    // 创建一台计算机
    Computer computer = new Computer();
    computer.work(phone); // 把手机接入到计算机
    computer.work(camera);// 把相机接入到计算机
}

解析接口

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。
语法：
interface 接口名{
// 属性
// 方法
}
// 实现接口
class 类名 implements 接口{
自己属性；
自己方法；
必须实现接口的方法；
}
小结：

Jdk7.0前接口里的所有方法都没有方法体。
Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现。

相关细节

接口不能被实例化。
接口中所有的方法都是public方法，接口中的抽象方法，可以不用abstract修饰。
一个普通的类实现接口，就必须将该接口所有的方法都实现。
抽象类实现接口，可以不用实现接口的方法。
一个类同时可以实现多个接口。
接口中的属性，只能是final的而且是public static final修饰符。
比如：int a = 1; => public static final int a = 1;
接口中属性的访问形式：接口名.属性名。
接口不能继承其它的类，但是可以继承多个别的接口。
比如：interface A extends B,C{}

// 多态传递现象
public class InterfacePolyPass{
    public static void main(String[] args){
        // 接口类型的变量可以指向实现了接口的对象实例
        IG ig = new Teacher();
        // 如果 IG 继承了 IH 接口，而Teacher实现了IG接口
        // 那么，实际上就相当于 Teacher 类也实现了 IH 接口
        IH ih = new Teacher();
    }
}
interface IH{}
interface IG extends IH{}
class Teacher implements IG{}

3.3.8 内部类

一个类的内部又完整嵌套了另一个类结构。被嵌套的类称为内部类，嵌套其他类的类称之为外部类。是我们类的第五大成员，内部类的最大特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。（类五大成员：属性、方法、构造器、代码块、内部类）

class Outer{ // 外部类
    class Inner{ // 内部类
    }
}
class Other{} // 外部其它类

局部内部类

说明

可以直接访问外部类的所有成员。
不能添加访问修饰符，因为它的地位是一个局部变量，局部变量是不能使用修饰符的，但是可以使用final修饰。
作用域：仅仅定义它的方法或代码中。
局部内部类—-访问—->外部类的成员：直接访问。
外部类—-访问—->局部内部类的成员：创建对象，再访问(必须在作用域内)。
外部其他类—-不能访问—->局部内部类。
如果外部类和局部内部类成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问。

匿名内部类

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名。

本质还是类
内部类
没有名字
同时还是一个对象

语法：
new 类或接口(参数列表){
类体
};

细节

匿名内部类本身的语法比较titer，请大家注意，因为匿名内部类急事一个类的定义，同时它本身也是一个对象，因此从语法看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。
可以直接访问外部类的所有成员，包含私有的。

class Outer04{      
    private int n1 = 10;
    public void method(){ //外部类
        // 1.需求：想要使用IA接口，并且创建对象
          // 2.传统方式：写一个类，实现该接口，并创建对象
          // 3.可Tiger类只使用一次，后面不再使用
          // 4.可以使用匿名内部类简化开发
          // 5.tiger的编译类型：IA
          // 6.tiger的运行类型：就是匿名内部类，系统默认分配
          /*
              我们看底层，会分配类名 xxxxxx
              class xxxxxx implements IA{
                  @Override
                  public void(){
                      System.out.println("老虎叫唤...");
                  }
              }
          */
        IA tiger = new IA(){
            @Override
            public void cry(){
                System.out.println("老虎叫唤");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiget.cry();
    }
}
interface IA{
    public void cry();
}

成员内部类

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。
可以添加任意访问修饰符，因为他的地位就是一个成员。
作用域：和外部类的其他成员一样，在外部类的成员方法中创建成员内部类对象，再调用方法。
成员内部类—-访问—-外部类：直接访问
外部类—-访问—-成员内部类：创建对象再访问

静态内部类

说明：成员内部类是定义在外部类的成员位置，但是有static修饰。

可以添加任意访问修饰符，因为他的地位就是一个成员。
可以直接访问外部类所有静态成员，包含私有的，但不能直接访问非静态成员。
作用域：同其它测成员，为整个类体。

Java_02

Java_02

第三章 面向对象

3.1 面向对象初级

3.1.1 类与对象

3.1.2 成员方法

3.1.3 传参机制

3.1.4 重载

3.1.5 可变参数

3.1.5 作用域

3.1.6 构造器

3.1.7 this

3.2 面向对象中级

3.2.1 IDEA

3.2.2 包

3.2.3 访问修饰符

3.2.4 OOP三大特征

3.2.4.1 封装

3.2.4.2 继承

3.2.4.3 多态

3.2.5 Super关键字

3.2.6 方法重写

3.2.7 Object类

3.2.8 断点调试（Debug）

3.3 面向对象高级

3.3.1 类变量和类方法

3.3.2 main方法语法

3.3.3 代码块

3.3.4 单例设计模式

3.3.5 final关键字

3.3.6 抽象类

3.3.7 接口

3.3.8 内部类

第三章面向对象