Java学习笔记-对象开整！(韩顺平)

一.面向对象编程(基础)

1.类与对象

1.引出类与对象

• 

  使用现有技术解决，即单独定义变量解决或使用数组解决，不利于数据的管理且效率较低

  java设计者引入类与对象(OOP)，根本原因就是现有的技术不能完美的解决新的需求。

2.类与对象的概述

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

• 类与对象关系示意图

  

  

  1. 类是抽象的，概念的，代表一类事物，比如人类，猫类......，即它是数据类型

  2. 对象是具体的，实际的，代表一个具体事物，即是实例

  3. 类是对象的模板，对象是类的一个个体，对应一个实例

• 对象在内存中的存在形式

  

  

  类与对象的内存分配机制

  java内存的结构分析

  1. 栈：一般存放基本数据类型(局部变量)

  2. 堆：存放对象(Cat cat , 数组等)

  3. 方法区：常量池(常量，比如字符串)，类加载信息

  4. 示意图 如上

  java创建对象流程简单分析

  

3.属性/成员变量

• 基本介绍

  1. 从概念或叫法上看：成员变量 = 属性 = field (字段)(即 成员变量是用来表示属性的)

     案例演示：Cat(name,price,color)

  2. 属性是类的一个组成部分，一般是基本数据类型，也可以是引用数据类型(对象，数组)。比如我们前面定义猫类的int age 就是属性

• 注意事项和细节说明

  1. 属性的定义语法同变量，示意：访问修饰符 属性类型 属性名;

     简单介绍访问修饰符：控制属性的访问范围

     有四种访问修饰符 public,protected,默认,private

  2. 属性的定义类型可以为任何类型，包含基本类型或引用类型

  3. 属性如果不赋值，有默认值，规则和数组一致

4,创建对象

• 如何创建对象

  1. 先声明再创建

     Cat cat;

     cat = new Cat();

  2. 直接创建

     Cat cat = new Cat();

• 如何访问属性

  基本语法

  对象名.属性名;

  案例演示：

  cat.name;

  cat.age;

5.成员方法

• 基本介绍

  在某些情况下，我们需要定义成员方法(简称方法)，比如人类：除了有一些属性外(年龄，姓名...)，我们人类还有一些行为比如：可以说话、跑步、学习。这时候就要用成员方法才能完成。

• 方法的调用机制

  

• 成员方法的好处

  1. 提高代码的复用性

  2. 可以将实现的细节封装起来，然后供其他用户来调用即可。

• 成员方法的定义

  访问修饰符 返回数据类型 方法名 (参数列表...) {

  方法体语句；

  return 返回值;

  }

  1. 参数列表：表示成员方法输入 cal(int n)

  2. 数据类型(返回类型)：表示成员方法输出，void 表示没有返回值

  3. 方法主体：表示为了实现某一功能代码块

  4. return 语句不是必须的。

• 成员方法的注意事项和使用细节

  修饰符(作用是控制方法使用的范围)

  有四种：public 、protected 、 默认 、 private

  返回数据类型

  1. 一个方法最多有一个返回值(如何返回多个结果，可以返回数组)

  2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)

  3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return 值;而且要求返回值类型必须和return 的值的类型一致或兼容

  4. 如果方法是void，则方法体中可以没有return语句,或者只写return ;

  形参列表

  1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开。

  2. 参数类型可以为任意类型，包含基本类型和引用类型

  3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数！

  4. 方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，形参和实参的类型要一致或兼容、个数、顺序必须一致！

  方法体

  里面写完成功能的具体语句，可以为输入，输出，变量，运算，分支，循环，方法调用，但是里面不能再定义方法！即：方法不能嵌套定义。

  方法细节调用说明

  1. 同一类中的方法调用：直接调用即可。

  2. 跨类中的方法A类调用B类方法：需要通过对象名调用。

  3. 跨类的方法调用和方法的访问修饰符相关。

• 成员方法的传参机制

  1. 基本数据类型的传参机制

     

  2. 引用数据类型的传参机制

     

     

     引用类型传递的是地址(传递的也是值，但是值是地址)，可以通过形参影响实参 ！

  3. 测试题

     

     

6.方法递归调用(recursion)

• 基本介绍

  简单的说：递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂问题，同时可以让代码变简洁。

• 递归能解决什么问题？

  1. 各种数学问题：如8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题

  2. 各种算法中也会遇到递归，比如快排，归并排序，二分查找，分治算法等

  3. 将用栈解决的问题-->递归代码比较简洁

• 递归调用的机制

  

• 阶乘(factorial)

  

• 递归重要规则

  1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)

  2. 方法的局部变量是独立的，不会相互影响，比如n变量

  3. 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据。

  4. 递归必须要退出递归的条件逼近，否则就是无限递归，出现StackOverflowError，死龟了

  5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回谁，同时，当方法执行完毕或返回时，该方法也就执行完毕。

• 小鼠找路

  

  public boolean findWay(int[][] map,int i,int j) {
          if (map[6][5] == 2) {
              return true;
          } else {
              if (map[i][j] == 0) {
                  map[i][j] = 2;
                  if (findWay(map, i + 1, j)) {
                      return true;
                  } else if (findWay(map, i, j + 1)) {
                      return true;
                  } else if (findWay(map, i - 1, j)) {
                      return true;
                  } else if (findWay(map, i, j - 1)) {
                      return true;
                  } else {
                      map[i][j] = 3;
                      return false;
                  }
              }else {
                  return false;
              }
          }
      }

  拓展思考：如何求出最短路径？思路一：穷举，思路二：图-->求出最短路径

• 汉诺塔问题

  public void move(int num,char a,char b,char c) {
          if (num == 1) {
              System.out.println(a + "-->" + c);
          }else {
              move(num - 1, a , c , b);
              System.out.println(a + "-->" + c);
              move(num - 1,b , a , c);
          }
      }

• 八皇后问题(给我整晕了)

  public class eightQueens{
      public static void main(String[] ards){
          T t = new T();
          int arr[] = new int[8];//使用一维数组保存 棋盘规模 8*8
          t.putQueen(arr,0);
          System.out.println("八皇后问题一共有" + t.count +"情况");
  ​
      }
  }
  ​
  ​
  class T{
      //验证功能:判断棋子放在第几行 是否符合八皇后的规则： 与其他棋子 不能同列 不能同行 不能同一斜线
      //如果符合八皇后游戏规则 返回 true 否则 返回false 使用boolean返回类型
      // arr 表示棋盘 n 表示放入棋子在第n+1行 arr[n] 表示放入棋子在第 arr[n] + 1列
      public boolean verify(int arr[],int n){
          for (int i = 0;i < n ;i++ ) {
              if (arr[n] == arr[i] || Math.abs(n - i) == Math.abs(arr[n] - arr[i])) {
                  return false;
              }
          }
  ​
          return true;
      }
  ​
      //八皇后棋子放置策略：
      //用一维数组arr 表示棋盘 i 表示初始棋子放置棋盘第i+1行
      //arr[i] 表示棋盘第arr[i]+1列
      //设置递归的出口 当棋子放到第8行 验证成功时 即 verify(arr,7) 返回true
      //打印八皇后放置棋子的8个位置
  ​
      int count = 0;//全局变量
      public void putQueen(int[] arr,int i){
          if (verify(arr,7)) {
  ​
              count++;
              System.out.println("\n第" + count + "种：");
              System.out.println("arr 数组：");
              //打印 符合条件的 arr[] 数组
              array(arr);
  ​
          }else{
  ​
              for (int j = 0;j < 8 ;j++ ) {
                  //j 表示列  循环遍历 第0-7列
                  arr[i] = j;
                  //验证是否符合八皇后规则
                  if (verify(arr,i)) {
                      //如果 验证返回true 则 递归调用 putQueen()方法
                      //继续 放置下一行的棋子位置(行和列：i 和 j) 并验证 位置是否符合八皇后规则
                      putQueen(arr,i + 1);
                  }
              }
              //如果 行为第i+1行 棋子 循环遍历 放置0——7列
              //都不符合八皇后规则 即 verify(arr,i) 返回false
              //则 不会执行 if里面的语句 putQueen(arr,i+1);
              //即 不会继续下一行 放置棋子 而是回溯到 for语句
              //继续遍历 数组列表 即 这一行的第2列
          }
      }
  ​
      //一维数组变二维数组 并打印相对应的图形

   public void array(int[] arr){
  ​
          char[][] arr1 = new char[arr.length][arr.length];
          for (int i = 0;i < arr1.length ;i++ ) {
              for (int j = 0;j <arr1[i].length;j++ ) {
                  arr1[i][j] = '*';
                  arr1[i][arr[i]] = 'Q';
  ​
                  System.out.print(arr1[i][j] + " ");
              }
              System.out.println();
          }
  ​
      }
  }

7.方法重载

• 方法重载(OverLoad)

  • 基本介绍

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

    比如：System.out.println(); out是printStream类型

  • 重载的好处

    1. 减轻了起名的麻烦

    2. 减轻了记名的麻烦

  • 方法重载的注意事项和使用细节

    1. 方法名：必须相同

    2. 参数列表：必须不同(参数类型或个数或顺序，至少有一样不同，参数名无要求)

    3. 返回类型：无要求

8.可变参数

• 可变参数

  • 基本概念

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

  • 基本语法

    

    

  • 注意事项和细节

    1. 可变参数的实参可以为0个或多个

    2. 可变参数的实参可以为数组

       

    3. 可变参数的本质就是数组

    4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

    5. 一个形参列表中只能出现一个可变参数(多了就乱套了，个人理解)

  • 练习

    public String showScore(String name,double... scores) {
        double sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];
        }
        return name + scores.length + "门课成绩总分为" + sum;
    }

9.作用域(scope)

• 基本使用

  1. 在java中，主要的变量就是属性(成员变量)和局部变量。

  2. 我们说的局部变量一般指在成员方法中定义的变量。

  3. java中作用域的分类

     全局变量：也就是属性，作用域为整个整体

     局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块

  4. 全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后才能使用，因为没有默认值。

• 注意事项和细节说明

  1. 属性和局部变量可以重名，访问时遵循就近原则。

     

  2. 在同一作用域中，比如在同一成员方法中，两个局部变量，不能重名。

  3. 属性生命周期较长，伴随着对象的创建而创建，伴随着对象的死亡而死亡。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而死亡。即在一次方法调用过程中。

  4. 作用域不同

     全局变量：可以被本类使用，或其他类使用(通过对象调用)

     

     局部变量：只能在本类中对应的方法中使用

  5. 修饰符

     全局变量/属性可以加修饰符

     局部变量不可以加修饰符

10.构造方法/构造器

• 基本语法

  [修饰符] 方法名(形参列表){

  方法体

  }

• 说明

  1. 构造器的修饰符可以默认，也可以是public,protected,private

  2. 构造器没有返回值

  3. 方法名和类名字必须一样

  4. 参数列表和成员方法一样的规则

  5. 构造器的调用系统完成

• 基本介绍

  构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

  1. 方法名和类名相同

  2. 没有返回值

  3. 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

  

• 注意事项和使用细节

  1. 一个类可以定义多个不同的构造器，即构造器重载

     比如：我们可以给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要指定年龄

     

  2. 构造器名和类名要相同

  3. 构造器没有返回值

  4. 构造器是完成对象的初始化，并不是创建对象

  5. 在创建对象时，系统自动的调用该类的方法

  6. 如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造方法)

     可用javap指令看到

     1. javap是jdk提供的一个命令行工具，Javap能对给定的class文件提供的字节码进行反编译。

     2. 通过它，可以对照源代码和字节码，从而了解很多编译器内部的工作，对深入地理解如何提高程序执行的效率等问题有极大的帮助。

     3. 使用方式

        javap <options><classes>

        

  7. 一旦定义了自己的构造器，默认的构造器就被覆盖了，就不能再使用默认的无参构造器了，除非显式的定义一下，即：Person(){}

• 简单一用

  class Person{
      String name;
      int age;
      public Person () {
          age = 18;
      }
      public Person(String pname,int page) {
          name = pname;
          age = page;
      }
  }

• 引入构造器后的对象创建流程分析

  

  1. 加载Person类信息(Person.class)，只会加载一次

  2. 在堆中分配空间(地址)

  3. 完成对象初始化[3.1 默认初始化 3.2 显示初始化 age = 90，name = null， 3.3 构造器初始化 age = 20,name = 小倩]

  4. 在对象堆中的地址返回给p (p是对象名，也可以理解为对象的引用)

11.this关键字

• this的引入

  

• 什么是this

  

• this的本质

  

  小结：简单的说，哪个对象调用，this就代表哪个对象

• this的注意事项和使用细节

  1. this关键字可以用来访问本类的属性、方法、构造器

  2. this用来区分当前类的属性和局部变量

  3. 访问成员变量的语法：this.方法名(参数列表);

  4. 访问构造器语法：this(参数列表);注意只能在构造器中使用，即只能在构造器中访问另外一个构造器，必须放在第一条语句

     

  5. this不能在类定义的外部使用，只能在类定义的方法中使用。

12.例题

1. 

   匿名对象，没有对象名引用，直接new

2. 

   1. 构造器中复用构造器需要用到this

   2. 只能放到第一行

二.面向对象编程(中级)

1.包

• 包的三大作用

  1. 区分相同名字的类

  2. 当类很多时，可以很好的管理类

  3. 控制访问范围

• 包的基本语法

  package com.hspedu;

  说明

  1. package 关键字，表示打包

  2. com.hspedu:表示包名

• 包的本质分析(原理)

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

  

• 包的命名

  命名规则

  1. 只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字

     demo.class.exec1 错误 class关键字

     demo.12a 错误 12数字开头

     demo.ab12.oa 正确

  命名规范

  1. 一般是小写字母 + 小圆点一般是

     com.公司名.项目名.业务模块名

     比如 : com.hspedu.oa.model; com.hspedu.oa.controller;

  2. 举例

     com.sina.crm.user //用户模块

     com.sina.crm.order //订单模块

     com.sina.crm.utils //工具类

• 常用的包

  一个包下，包含很多的类，java中常用的包有：

  • java.lang.* //lang包是基本包，默认引入，不需要再引入

  • java.util.* //util包，系统提供的工具包，工具类，使用Scanner

  • java.net.* //网络包，网络开发

  • java.awt.* //是做Java的界面开发，GUI

• 如何导入包

  语法：import 包;

  我们引入一个包的主要目的是要使用该包下的类

  比如 import java.util.Scanner; 就只是引入一个类Scanner。

  import java.util.* //表示将java.util 包所有都引入

  案例: 使用系统提供的Arrays 完成数组排序

  package com.mdkstu;
  ​
  import java.util.Arrays;
  ​
  public class Import01 {
      public static void main(String[] args) {
          int[] arr = {-1,20,2,33,4,13,55,52};
          Arrays.sort(arr);
          for (int i = 0; i < arr.length; i++) {
              System.out.print(arr[i] + "\t");
          }
      }
  }

• 注意事项和使用细节

  1. package 的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package

  2. import指令 位置放在package的下面，在类定义前面，可以有多句且没有顺序要求。

2.访问修饰符

• 基本介绍

  java提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限(范围)；

  1. 公开级别：用public 修饰，对外公开

  2. 受保护级别：用projected 修饰，对子类和同一个包中的类公开

  3. 默认级别：没有修饰符号，向同一个包中的类公开

  4. 私有级别：用private 修饰，只有类本身可以访问，不对外公开。

• 四纵访问修饰符的访问范围

  

• 使用的注意事项

  1. 修饰符可以用来修饰类中的属性，成员方法以及类

  2. 只有默认和public才能修饰类！，并且遵循上述访问权限的特点

  3. 因为没有学习继承，因此关于在子类中的访问权限，在学完继承后讲解

  4. 成员方法的访问规则和属性完全一样。

  在同一个包下，可以访问public，protected 和默认修饰属性或方法，不能访问private 属性

3.面向对象编程三大特征

1.基本介绍

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

2.封装

• 封装介绍

  封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作。

• 封装的理解和好处

  1. 隐藏实现细节

  2. 可以对数据进行验证，保证安全合理

• 封装的实现步骤

  1. 将属性进行私有化[不能直接修改属性]

  2. 提供一个公共(public)的set方法，用于对属性判断并赋值

  3. 提供一个公共的get方法，用于获取属性的值

• 快捷键-----alt + insert

• 将构造器和setXxx结合

3.继承

• 继承的基本介绍和示意图

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

• 继承的基本语法

  class 子类 extends 父类 {

  }

  1. 父类就会自动拥有父类定义的属性和方法

  2. 父类又叫超类、基类

  3. 子类又叫派生类

• 继承示意图

  

• 继承给代码带来的便利

  1. 代码的复用性提高了

  2. 代码的扩展性和维护性提高了

• 继承的深入讨论/细节问题

  1. 子类继承了所有的属性和方法，但是私有属性和方法不能在子类中直接访问，要通过父类提供的公共的方法去访问

  2. 子类必须调用父类的构造器，完成父类的初始化

  3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过

  4. 如果希望指定去调用父类的某个构造器，则显式的调用一下

  5. super在使用时，需要放在构造器第一行

  6. super()和this() 都只能放在构造器第一行，因此两个方法不能共存在一个构造器

  7. java所有类都是Object类的子类

  8. 父类构造器的调用不限于直接父类！将一直往上追溯知道Object类(顶级父类)

  9. 子类最多只能继承一个父类(指直接继承)，即java中是单继承机制。

  10. 不能滥用继承，子类和父类之间必须满足is- a的逻辑关系

• 继承内存访问

  

  先加载父类，后加载子类

  

• 练习

  

  注意：super() 和 this() 不共存

  

  注意：默认存在的那个super() ！！！

• super关键字

  • 基本介绍

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

  • 基本语法

    1. 访问父类属性，但不能访问父类的private属性

       super.属性名;

    2. 访问父类方法，不能访问父类的private方法

       super.方法名(参数列表);

    3. 访问父类构造器(前面有)

       super(参数列表);只能放在构造器的第一句，与this()不共存

  • super给程序带来的便利/细节

    1. 调用父类构造器的好处(分工明确，父类属性由父类初始化，子类属性由子类初始化)

    2. 当子类中由和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super，this，直接访问时一样的效果!

       

       

       属性则与其一致

    3. super的访问不限于直接父类，如果爷爷和本类中有同名的成员，也可以使用super去访问爷爷类的成员，如果多个基类中都有同名的成员，使用super访问遵循就近原则。当然也需要遵守访问权限的相关规则。

  • super和this的比较

    

• 方法重写/覆盖(override)

  • 基本介绍

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

  • 注意事项

    方法重写也叫方法覆盖，需要满足下面的条件

    1. 子类的方法的参数，方法名称，要和父类方法的参数，方法名称完全一样。

    2. 子类方法的返回类型要和父类方法的返回类型一样，或者时父类返回类型的子类(父类范围大一点也ok)

    3. 子类不能缩小父类方法的访问权限，但是放大是允许的

  • 重载和重写的区别

    

    注意:重写子类不能缩小父类的访问范围

4.多态(polymorphic)

• 多态的基本介绍

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

• 多态的具体体现

  1. 方法的多态

     重写和重载就体现多态

     

     

  2. 对象的多态(多态的核心)

     1. 一个对象的编译类型和运行类型可以不一致。

        

     2. 编译类型看定义时 = 的左边，运行类型看 = 的右边

     3. 编译类型实在定义对象时就确定了，不能改变

     4. 运行类型是可以变化的

• 多态注意事项和细节讨论

  1. 多态的前提是：两个对象(类)存在继承关系

  2. 多态的向上转型

     1. 本质：父类的引用指向了子类的对象

     2. 语法：父类类型 引用名 = new 子类类型();

     3. 特点：编译类型看左边，运行类型看右边。

        可以调用父类中的所有成员(须遵守访问权限)

        不能调用子类特有成员

        因为在编译阶段，能调用哪些成员，是由编译类型来决定的

        最终运行效果看子类的具体实现！即调用方法时，按照从子类开始查找方法//，然后调用，规则和前面我们讲的方法调用规则一致。

  3. 多态的向下转型

     1. 语法：子类类型 引用名 = (子类类型)父类引用;

     2. 只能强转父类的引用，不能强转父类的对象

     3. 要求父类的引用必须指向的是当前目录类型的对象

     4. 当向下转型后，可以调用子类类型中所有的成员

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

  5. instanceOf 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

• 练习

  

  

  个人认为也体现了java的动态绑定机制

• java的动态绑定机制(important)(dynamicBinding)

  1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

  2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用

     

• 多态的应用

  1. 多态数组

  2. 多态参数

     方法定义的形参为父类类型，实参类型允许为子类类型

5.Object类详解

• equals方法

  == 和 equals对比

  ==是一个比较运算符

  1. ==：既可以判断基本类型，又可以判断引用类型。

  2. ==：如果判断基本类型，判断的是值是否相等

  3. ==：如果判断引用类型，判断的是地址是否相等，即判断是不是一个对象

     

  4. equals：是object类中的方法，只能判断引用类型

  5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。

  重写object类中的equals对象

  

  课堂练习

  

• hashCode方法

  1. 提高具有哈希结构的容器的效率！

  2. 两个引用，如果指向的是不同对象，则哈希值是不一样的。

  3. 哈希值主要根据地址号来的！不能完全将哈希值等价于地址。

  4. 后面在集合中也会重写

  5. 

• toString 方法

  • 基本介绍

    默认返回：全类名(包名加类名) + @ + 哈希值的十六进制【查看object 的toString方法】子类往往重写toString方法，用于返回对象的属性信息

  • object中对其重写

    

  • finalize方法

    1. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作

    2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象就是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。

    3. 垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制。

    4. 如果程序员不重写finalize，那么就会调用Object类的finalize，即默认处理

    5. 如果程序员重写了finalize，就可以实现自己的逻辑

       

    6. 实际开发不会运用，更多就是为了面试

6.断点调试(deBug)

重要提示：在断点调试过程中，是运行状态，是以对象的运行类型来执行的。

• 介绍

  1. 断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码即显示错误，停下。进而分析找到这个Bug

  2. 断点调试是程序员必须掌握的技能

  3. 断点调试也能帮助我们查看java底层源代码的执行过程，提高程序员的java水平

• deBug快捷键

  

  

  debug跳入跳出方法

  

7.房屋出租系统

• 项目设计

  

• 界面代码

  不是韩老师写的，我自己瞎写的

  package com.mdkstu.housesys;
  ​
  import com.sun.source.tree.WhileLoopTree;
  ​
  import java.sql.SQLOutput;
  import java.util.Scanner;
  ​
  /*
  1.显示界面
  2.接受用户的输入
  3.调用HouseService完成对房屋信息的各种操作
   */
  public class HouseView {
      Scanner sc = new Scanner(System.in);
      String key = "";
      private boolean loop = true;
      HouseService service = new HouseService();
      public void mainView() {
          Scanner sc = new Scanner(System.in);
  ​
          do {
              System.out.println("--------------------房屋出租系统--------------------");
              System.out.println("\t\t\t1 新 增 房 源");
              System.out.println("\t\t\t2 查 找 房 屋");
              System.out.println("\t\t\t3 删 除 房 屋");
              System.out.println("\t\t\t4 修 改 房 屋 信 息");
              System.out.println("\t\t\t5 房 屋 列 表");
              System.out.println("\t\t\t6 退 出");
              System.out.print("请输入您需要进行的操作：");
              key = sc.next();
              switch (key){
                  case "1":
                      addHouseView();
                      break;
                  case "2":
                      findHouse();
                      break;
                  case "3":
                      delHouse();
                      break;
                  case "4":
                      changeImg();
                      break;
                  case "5":
                      houseList();
                      break;
                  case "6":
                      System.out.println("--------------------系统已退出--------------------");
                      loop = false;
                      break;
                  default:
                      System.out.println("输入类型错误，请重新输入!");
              }
  ​
          } while (loop);
      }
  ​
  //    1.添加房屋
      public void addHouseView() {
          System.out.println("--------------------添加房屋--------------------");
          service.addHouse();
          System.out.println("--------------------添加完成--------------------");
      }
  ​
  //    2.查找房屋
      public void findHouse() {
          System.out.println("--------------------查找房屋--------------------");
          System.out.print("请输入需要查找房屋的id: ");
          int changeId = sc.nextInt();
          service.findHouse(changeId);
  ​
      }
  ​
  //    3.删除房屋
      public void delHouse() {
          System.out.println("--------------------删除房屋--------------------");
          System.out.print("请选择待删除房屋编号(-1退出): ");
          int change = sc.nextInt();
          if (change == -1){
              System.out.println("--------------------已退出删除界面--------------------");
          }else {
              service.delHouse(change);
          }
  ​
      }
  ​
  //    4.修改房屋信息
      public void changeImg() {
          System.out.println("--------------------修改客户--------------------");
          service.changeImg();
          System.out.println("--------------------修改完成--------------------");
  ​
      }
  ​
  //    5.房屋列表
      public void houseList() {
          System.out.println("--------------------房屋列表--------------------");
          System.out.println("编号\t房主\t电话\t地址\t月租\t状态(已出租/未出租)");
          service.showHouses();
          System.out.println("-------------------房屋列表完成-------------------");
      }
  ​
  ​
  }

• 业务层代码

  package com.mdkstu.housesys;
  ​
  import java.util.Scanner;
  ​
  /*
  1.享用HouseView的调用
  2.完成对房屋信息的操作(增删改查)crud
   */
  public class HouseService {
      Scanner sc = new Scanner(System.in);
      public House[] houses = new House[2];
      private int houseCount = 0;
      private int houseId = 0;
  ​
      public void addHouse() {
          House h1 = new House();
          Scanner sc = new Scanner(System.in);
          h1.setId(houseId);
          System.out.print("姓名：");
          h1.setName(sc.next());
          System.out.print("电话：");
          h1.setPhoneNum(sc.next());
          System.out.print("地址：");
          h1.setAddress(sc.next());
          System.out.print("月租：");
          h1.setRent(sc.nextDouble());
          System.out.print("状态：");
          h1.setState(sc.next());
          if (houses[houses.length - 1] == null) {
              houses[houseCount++] = h1;
              houseId++;
          } else {
              House[] newHouses = new House[houses.length + 1];
              for (int j = 0; j < houses.length; j++) {
                  newHouses[j] = houses[j];
              }
              newHouses[houseCount++] = h1;
              houses = newHouses;
              houseId++;
          }
      }
  ​
      public void showHouses() {
          for (int j = 0; j < houses.length; j++) {
              if (houses[j] != null){
                  System.out.println(houses[j].toString());
              }
          }
      }
  ​
      public void findHouse(int id) {
          for (int i = 0; i < houseCount; i++) {
              if (houses[i] != null && id == houses[i].getId()) {
                  System.out.println(houses[i].toString());
              }
          }
      }
  ​
      public boolean delHouse(int change) {
          int index = -1;
          boolean loop = true;
          for (int i = 0; i < houseCount; i++) {
              if (change == houses[i].getId()) {
                  index = i;
              }
          }
          if (index == -1){
              System.out.println("-----------------无以其为编号的房屋，删除失败-----------------");
              return false;
          }
          else {
              do {
                  System.out.print("确认是否删除(Y/N)，请小心选择：");
                  String myChange = sc.next();
                  if (myChange.equals("Y") ){
                      delite(index);
                      return true;
                  }else if (myChange.equals("N")) {
                      return false;
                  }else {
                      continue;
                  }
              }while (loop);
          }
          return false;
      }
      public void delite(int index) {
          for (int i = index; i < houseCount - 1; i++) {
              houses[i] = houses[i + 1];
          }
          houses[--houseCount] = null;
  ​
      }
  ​
  ​
      public void changeImg() {
          System.out.print("请选择修改房屋编号(-1退出)：");
          int inputId = sc.nextInt();
          if (inputId != -1) {
              for (int j = 0; j < houseCount; j++) {
                  if (houses[j].getId() == inputId) {
                      System.out.print("姓名(" + houses[j].getName() + ")");
                      houses[j].setName(sc.next());
                      System.out.print("电话(" + houses[j].getPhoneNum() + ")");
                      houses[j].setPhoneNum(sc.next());
                      System.out.print("地址(" + houses[j].getAddress() + ")");
                      houses[j].setAddress(sc.next());
                      System.out.print("租金(" + houses[j].getRent() + ")");
                      houses[j].setRent(sc.nextDouble());
                      System.out.print("状态(" + houses[j].getState() + ")");
                      houses[j].setState(sc.next());
                  }
              }
              System.out.println("未查找到该id的房屋！");
          }
      }
  }

• 数据层代码

  package com.mdkstu.housesys;
  ​
  import com.sun.source.tree.WhileLoopTree;
  ​
  //一个House对象表示一个房屋信息
  public class House {
      private int id;
      private String name;
      private String phoneNum;
      private String address;
      private double rent;
      private String state;
  ​
      public House(int id, String name, String phoneNum, String address, double rent, String state) {
          this.id = id;
          this.name = name;
          this.phoneNum = phoneNum;
          this.address = address;
          this.rent = rent;
          this.state = state;
      }
  ​
      public House() {
      }
  ​
      public int getId() {
          return id;
      }
  ​
      public void setId(int id) {
          this.id = id;
      }
  ​
      public String getName() {
          return name;
      }
  ​
      public void setName(String name) {
          this.name = name;
      }
  ​
      public String getPhoneNum() {
          return phoneNum;
      }
  ​
      public void setPhoneNum(String phoneNum) {
          this.phoneNum = phoneNum;
      }
  ​
      public String getAddress() {
          return address;
      }
  ​
      public void setAddress(String address) {
          this.address = address;
      }
  ​
      public double getRent() {
          return rent;
      }
  ​
      public void setRent(double rent) {
          this.rent = rent;
      }
  ​
      public String getState() {
          return state;
      }
  ​
      public void setState(String state) {
          this.state = state;
      }
  ​
      @Override
      public String toString() {
          return  " "+id +
                  "\t\t" + name +
                  "   " + phoneNum +
                  "   " + address +
                  "   " +  rent +
                  "\t" + state ;
      }
  }

三.面向对象编程(高级)

1. 类变量

1. 类变量的内存布局

• 

  jdk8以前认为在方法区中的静态域中

  jdk8以后认为在堆里面该类对应的class对象的最后

• 共识：

  1. static 变量是同一个类所有对象共享的

  2. static 类变量，在类加载的时候就生成了

2.什么是类变量

• 类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样，任何一个该类的变量去修改它时，修改的是同一个变量。

3.如何定义类变量

• 定义语法

  访问修饰符 static 数据类型 变量名;[推荐]

  static 访问修饰符 数据类型 变量名;

4.如何访问类变量

• 类名.类变量名 [静态变量的访问修饰符的访问权限和访问范围 和 普通属性是一样的]

  类变量是随着类的加载而创建的，所以没有创建对象实例也可以访问

• 或者 对象名.类变量名

5.类变量使用注意事项和细节讨论

1. 什么时候需要用类变量

   当我们需要让某个类的所有对象都共享一个变量时，既可以考虑使用类变量(静态变量)：比如定义学生类，统计所有学生共交多少钱。

2. 类变量与实例变量(普通属性)的区别

   类变量是该类的所有对象共享的，而实例变量是每个对象独享的、

3. 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

4. 类变量可以通过类名.类变量名 或者 对象名.类变量名 来访问，但java设计者推荐我们使用 类名.类变量名去访问，[前提是满足访问修饰符的访问权限和范围]

5. 实例变量不能通过类名.类变量名 方式询问。

6. 类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。

7. 类变量的生命周期是随类的加载开始，随着类的消亡而摧毁。

2.类方法

1.类方法的基本介绍

• 类方法也叫静态方法

  形式如下：

  访问修饰符 static 数据返回类型 方法名() { }[推荐]

  static 访问修饰符 数据返回类型 方法名() {}

• 类方法的调用

  使用方式：类名.类方法名 或者 对象名.类方法名 [前提是 满足访问修饰符的访问权限和范围]

• 小案例

  

• 类方法经典的使用场景

  当方法中不涉及任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率

  比如：工具类中的方法 utils

  Math类，Arrays类，Collections集合类

• 小结

  在程序员实际开发中，往往会将一些通用的方法，设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一维数组，冒泡排序，完成某个计算任务 等。。。

2.类方法的注意事项和细节讨论

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：类方法中无this的参数，普通方法中隐含着this的参数

2. 类方法可以通过类名调用，也可以通过对象名调用

3. 普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用

4. 类方法中不预序使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以。

5. 类方法(静态方法)中，只能访问静态变量或静态方法。

6. 普通成员方法，既可以访问 普通变量(方法)，也可以访问静态变量(方法)。

7. 类方法不能继承，类方法（也称为静态方法）是属于类的方法，而不是实例的方法。因为类方法是与整个类相关联的，而不是与类的实例相关联的，所以它们不能被继承到子类中。子类只能继承父类的实例方法和属性，而类方法是独立于实例的，所以不会被子类继承。

小结：静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员(必须遵守访问权限)

3.理解main方法的语法

• 深入理解main方法

  main方法是虚拟机在调用

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

  1. java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public

  2. java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static

  3. 该方法接受String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

  4. java执行的程序 参数1 参数2 参数3

     

• 特别提醒

  1. 在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性。

  2. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

• 练习

  

3.代码块

1.基本介绍

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

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

2.基本语法

• [修饰符]{

  代码

  };

• 注意：

  1. 修饰符可选，要写的话，也只能写static

  2. 代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块。

  3. 逻辑语句可以分为任何逻辑语句(输入、输出、方法调用、循环、判断等)

  4. ;可写上，也可以省略。

  5. 代码块的调用优先于构造器

3.理解

1. 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

2. 场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的复用性

4.使用注意事项和细节讨论

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

2. 类什么时候被加载

   1. 创建对象实例时(new)

   2. 创建子类对象实例，父类也会被加载，而且父类先被加载，子类后被加载

   3. 使用类的静态成员时(静态属性，静态方法)

3. 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。

   如果只是使用类的静态成员时，普通代码块并不会执行。和类是否加载无关。

4. 创建一个对象时，在一个类 调用顺序时：

   1. 调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按定义顺序调用)

      

   2. 调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

   3. 调用构造方法

5. 构造方法(构造器)的最前面其实隐含了super() 和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的。

6. 我们看一下创建一个子类时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

   1. 父类的静态代码块和静态属性初始化 (优先级一样，按定义顺序执行)

   2. 子类的静态代码块和静态属性初始化(优先级一样，按定义顺序执行)

   3. 父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

   4. 父类的构造方法(构造器)

   5. 子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

   6. 子类的构造方法(构造器）

   7. 静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员

   小结：

7. static静态代码块随着类加载而执行，只加载一次

8. 普通代码块在创建对象时调用，创建一次，调用一次

5.单例设计模式

• 什么是设计模式

  1. 静态方法和属性的经典使用

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

• 什么是单例模式

  单例(单个的例子)

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

  2. 单例模式有两种方式：1.饿汉式 2.懒汉式

• 演示

  1. 饿汉式-你有可能还没用到这个对象但是类中已经创建好了

     可能造成创建了对象但没有使用

     步骤如下

     1. 构造器私有化 (防止直接new)

     2. 类的内部创建对象

     3. 向外暴露一个静态的公共方法。getInstance

     4. 代码实现

        package com.mdkstu.Instance_;
        ​
        public class Single {
            private Single() {}
            private static Single instance = new Single();
            public static Instance_ getInstance() {
                return instance;
            }
        ​
        }

  2. 懒汉式

     步骤

     1. 仍然进行构造器私有化

     2. 定义一个static静态属性对象

     3. 提供一个public的static方法，可以返回一个Cat对象

     4. 只有当用户使用Instance时，才返回cat对象，后面再次调用时，会返回上次创建的cat对象

     package com.mdkstu.Instance_;
     ​
     class Cat {
         private  String name;
     ​
         private static Cat cat ;
         private Cat(String name) {
             this.name = name;
         }
     ​
         public static Cat getInstance() {
             if (cat == null){
                 cat = new Cat("小可爱");
             }
             return cat;
         }
     }

4.final关键字

1.基本介绍

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

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

在某些情况下，程序员可能有以下需求，就会用到final：

1. 当不希望类被继承时，可以用final修饰

2. 当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰。

3. 当不希望类的某个属性的值被修改，可以用final修饰。

4. 当不希望某个局部变量被修改，可以使用final修饰

2.final使用注意事项和细节讨论

1. final修饰的属性又叫常量，一般用XX_XX_XX来命名

2. final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一

   1. 定义时，如public final double TAX_RATE = 0.08;

   2. 在构造器中

   3. 在代码块中

3. 如果final修饰的属性是静态的，则初始化的位置只能是

   1. 定义时

   2. 在静态代码块，不能在构造器中赋值

4. final类不能继承，但是可以实例化对象

5. 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承

6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法了。

7. final不能修饰构造方法(即构造器)

8. final和static往往搭配使用，不会导致类加载，效率更高，底层编译器做了优化处理

   不太理解先记住

9. 包装类(Interger,Double,Float,Boolean等都是final(),String也是final类)

5.抽象类

1.使用场景

• 当父类的某些方法，需要声明，但又不确定如何实现的时候，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract类来修饰类就是抽象类

  

2.抽象类的介绍

1. 用abstract 关键字来修饰一个类时，这个类就叫抽象类

   访问修饰符 abstract 类名{}

2. 用abstract关键字来修饰方法时，这个方法就是抽象方法

   访问修饰符 abstract 返回类型 方法名(参数列表);//没有方法体！！！

3. 抽象类的价值更多作用在于设计，是设计者设计好后，让子类继承并实现抽象类

4. 抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多

3.抽象类的注意事项和细节讨论

1. 抽象类不能被实例化

2. 抽象类不一定要包含abstract方法，也就是说，抽象类可以没有abstract方法

3. 一旦类包含了abstract方法，则这个类必须声明为abstract

4. abstract 只能修饰类和方法，不能修饰属性和其他

5. 抽象类可以有任意成员[因为抽象类还是类]，比如：非抽象方法，构造器，静态属性等等

6. 抽象方法不能有方法体

7. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类

8. 抽象方法不能使用private，final，static来修饰，因为这些关键字都是与重写相违背的。

4.抽象类的最佳实践-模板设计模式

• 需求

  1. 有多个类，完成不同的任务job

  2. 要求能够得到各自完成任务的时间

• 代码演示

  • CalculateTime类

    package com.mdkstu.calculatetime;
    ​
    public abstract class CalculateTime {
        public abstract void job();
    ​
        public void calculateTime_() {
            long start = System.currentTimeMillis();
            job();//java的动态绑定机制
            long end = System.currentTimeMillis();
            System.out.println("任务执行时间 " + (end - start));
        }
    }

  • job01类

    package com.mdkstu.calculatetime;
    ​
    public class Job01 extends CalculateTime{
        @Override
        public void job() {
            long num = 0;
            for (int i = 1; i <= 1000000; i++) {
                num += i;
            }
        }
    }

  • Test类

    package com.mdkstu.calculatetime;
    ​
    public class Test {
        public static void main(String[] args) {
            Job01 AA = new Job01();
            AA.calculateTime_();
    ​
        }
    }

6.接口

1.为什么有接口

• usb插槽就是现实中的接口

  你可以把手机，相机，u盘都插在usb插槽上，而不用担心那个插槽是专门插哪个的，原因是做usb插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸、排线等等。

2.基本介绍

• 接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。语法：

  interface 接口名 {

  //属性

  //方法(1. 抽象方法 2. 默认实现方法 3. 静态方法)

  }

  class 类名 implements 接口 {

  自己属性;

  自己方法;

  必须实现的接口的抽象方法

  }

  如果一个类implements 接口 需要将该接口的所有抽象方法都实现

• 小结

  1. 在jdk7.0以前 接口里的所有方法都没有方法体。即 都是抽象方法

     在接口中，抽象方法可以省略abstract关键字

  2. jdk8.0以后 接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

3.接口实现场景

• 
• 

4.接口的注意事项和细节

1. 接口不能被实例化

2. 接口中所有方法是public方法，接口中抽象方法，可以不用abstract 修饰

3. 一个普通类实现接口，就必须将该接口的所有方法都实现。

   可以使用alt + enter来快速解决

4. 抽象类实现接口，可以不用实现接口的方法。

5. 一个类可以实现多个接口

6. 接口中的属性只能是final的，而且是public static final 修饰符。比如：int a = 1；实际上是public static final int a = 1；(必须初始化)

7. 接口中属性的访问形式：接口名.属性名

8. 一个接口不能继承其他的类，但是可以继承多个别的接口

9. 接口的修饰符只能是public 和默认 ，这点和类的修饰符是一样的

5.接口和继承类的比较

• 可以理解为接口的实现机制是对单继承机制的一个补充

• 当子类继承了父类，就自动拥有了父类的功能

• 如果子类需要扩展功能，可以通过实现皆空的方式来扩展

1. 接口和继承解决的问题不同

   继承的价值主要在于：解决代码的复用性和可维护性。

   接口的价值主要在于：设计，设计好各种规范(方法)，让其他类去实现这些方法。

2. 接口比继承更加灵活

   接口比继承更加灵活，继承是满足is - a的关系，而接口只需满足 like - a 的关系。

3. 接口在一定程度上实现代码解耦[即 接口规范性 + 动态绑定机制]

6.接口多态

package com.mdkstu.interface_;
​
public interface USB {
    void start();
    void end();
}
package com.mdkstu.interface_;
​
public class Camera implements USB{
​
    @Override
    public void start() {
        System.out.println("相机开始干活");
    }
​
    @Override
    public void end() {
        System.out.println("相机不干活了");
    }
}
package com.mdkstu.interface_;
//1. USB usbInterface 形参是接口类型 USB
//2. 看到 接受 实现了 USB接口的类的对象实例
public class Computer {
    public void work(USB usbInterface){
        //通过接口来调用方法
        usbInterface.start();
        usbInterface.end();
    }
}

多态数组

package com.mdkstu.interfacearray;
​
public class Interface_02 {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera();
        for (int i = 0; i < 2; i++) {
            usbs[i].work();
            if (usbs[i] instanceof Phone_) {
                ((Phone_) usbs[i]).call();
            }
        }
    }
}
interface Usb {
    void work();
}
class Phone_ implements Usb{
​
    @Override
    public void work() {
        System.out.println("手机开始工作了");
    }
    public void call() {
        System.out.println("手机可以打电话");
    }
}
class Camera implements Usb{
​
    @Override
    public void work() {
        System.out.println("相机开始工作了");
    }
}

• 接口的多态特性

  1. 在前面的Usb接口案例中，UsbInterface usb，既可以接受手机对象，又可以接受相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)

  2. 多态数组

  3. 接口存在多态传递现象

     package com.mdkstu.interfacearray;
     ​
     import jdk.incubator.vector.VectorOperators;
     ​
     public class InterfaceDeliver {
         public static void main(String[] args) {
             IB ib = new Teacher();
             //ib = new IA(); 此时会报错
         }
     }
     interface IA { }
     //interface IB { }
     ​
     interface IB extends IA { } // 此时就ok了
     class Teacher implements IB { }

7.内部类

1. 基本介绍

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

2.基本语法

• class Outer { //外部类

  class Inner { //内部类

  }

  }

  class Other { } //外部其他类

3.内部类的分类

1. 定义在外部类局部位置上(比如方法内)：

   1. 局部内部类(有类名)

   2. 匿名内部类(没有类名，重点)

2. 定义在外部类的成员位置上:

   1. 成员内部类(没用static修饰)

   2. 静态内部类(使用static修饰)

4.局部内部类

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

  1. 可以直接访问外部类的所有成员，包含私有的

  2. 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final

  3. 作用域：仅仅在定义它的方法或方法块中

  4. 局部内部类 ---访问 --->外部类的成员 [访问方式：直接访问]

  5. 外部类---访问--->局部内部类的成员

     访问方式：创建对象，再访问(注意：必须在作用域内)

  6. 外部其他类---不能访问----->局部内部类(因为局部内部类地位是一个局部变量)

  7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

     解读

     外部类名.this 本质就是外部类的对象，即哪个对象调用了内部类所在的方法，外部类名.this就是哪个对象

5.匿名内部类

1. 本质是类 2.内部类 3. 该类没有名字 4. 同时还是一个对象

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

• 匿名内部类的基本语法

  new 类或接口(参数列表) {

  类体;

  }

• 基于接口的匿名内部类

  package com.mdkstu.anonymous;
  ​
  /*
  演示匿名内部类的实现
   */
  public class AnonymousInnerClass {
      public static void main(String[] args) {
          Outer04 outer04 = new Outer04();
          outer04.method();
      }
  }
  ​
  class Outer04 {
      private int n1 = 10;
      public void method() {
          //基于接口的匿名内部类
          //解读
          //1.需求：想使用IA接口，并创建对象
          //2.传统方式，写一个类，实现该接口，并创建对象
          //3.需求是 该类只使用一次，后面不再使用
          //4.可以使用匿名内部类来简化开发
          //5.tiger的编译类型 ？ IA
          //6.tiger的运行类型 ？就是匿名内部类 名字：Outer04$1
          /*
          底层 会分配类名：Outer04$1
              class XXXX implements IA {
                  @Override
                  public void cry() {
                      System.out.println("老虎叫");
                  }
              }
           */
          //7.jdk底层在创建了匿名内部类Outer04$1,立马就创建了Outer04$1实例，并且
          // 把地址返回给tiger
          //8.匿名内部类使用一次，就不能再使用
          IA tiger = new IA() {
  ​
              @Override
              public void cry() {
                  System.out.println("老虎叫");
              }
          };
          System.out.println(tiger.getClass());
          tiger.cry();
      }
  }
  ​
  interface IA {
      public void cry();
  }
  class Father {
      public Father() {
          super();
      }
      public void test() {
  ​
      }
  }

• 基于对象的匿名内部类

  package com.mdkstu.anonymous;
  ​
  ​
  /*
  演示匿名内部类的实现
   */
  public class AnonymousInnerClass {
      public static void main(String[] args) {
          Outer04 outer04 = new Outer04();
          outer04.method();
      }
  }
  ​
  class Outer04 {
      private int n1 = 10;
      public void method() {
          IA tiger = new IA() {
  ​
              @Override
              public void cry() {
                  System.out.println("老虎叫");
              }
          };
          //基于类的匿名内部类
          //不带{} father的编译类型是 Father
          //Father father = new Father();
          //带{}father的编译类型是Outer04$2
          /*
          底层
          class Outer04$2 extends Father {
  ​
          }
           */
          Father father = new Father("mdk") {
              @Override
              public void test() {
                  System.out.println("Outer04$2重写了匿名内部类");
              }
          };
  ​
          //基于抽象类的匿名内部类
          Animal animal = new Animal() {
  ​
              @Override
              void eat() {
                  System.out.println("Outer04$3重写了eat方法");
              }
          };
  ​
          father.test();
          animal.eat();
  ​
          System.out.println(tiger.getClass());
          tiger.cry();
      }
  }
  ​
  interface IA {
      public void cry();
  }
  class Father {
      public Father(String name) {
          System.out.println("接受name" + name);
      }
      public Father() {
          super();
      }
      public void test() {
  ​
      }
  }
  abstract class Animal {
      abstract void eat();
  }

• 注意事项

  • 匿名内部类的语法比较奇特，因为匿名内部类即是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征。

  • 可以直接访问外部类的所有成员，包含私有的

  • 不能添加访问修饰符，因为它的地位就是一个局部变量

  • 作用域：仅仅在定义它的方法或代码块中。

  • 匿名内部类 ---访问---->外部类成员[访问方式：直接访问]

  • 外部其他类不能访问匿名内部类(因为 匿名内部类地位是一个局部变量)

  • 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

• 应用

  1. 当作实参直接传递，简洁高效

     package com.mdkstu.anouymous_detail;
     ​
     public class Test {
         public static void main(String[] args) {
             Car.f1(new CarUsb() {
                 @Override
                 public void run() {
                     System.out.println("车跑了");
                 }
             });
         }
     }
     ​
     class Car {
         public static void f1(CarUsb carUsb) {
             carUsb.run();
         }
     }
     ​
     interface CarUsb {
         void run();
     }

     练习

     package com.mdkstu.inner_class_exercise;
     ​
     public class InnerClassExercise {
         public static void main(String[] args) {
             Cellphone.alarmclock(new Bell() {
                 @Override
                 public void ring() {
                     System.out.println("懒猪起床了!");
                 }
             });
         }
     }
     ​
     class Cellphone {
         public static void alarmclock(Bell bell){}
     }
     interface Bell {
         void ring();
     }

6.成员内部类

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

1. 可以直接访问外部类的所有成员，包含私有的

2. 可以添加任意访问修饰符(public,protected,默认.private)，因为它的地位就是一个成员。

   package com.mdkstu.memberinnerclass;
   ​
   public class MemberInnerClass01 {
       public static void main(String[] args) {
           Book book = new Book();
           book.s1();
       }
   }
   class Book {
       private int pageNum = 50;
       private String name;
   ​
       //注意：成员内部类是定义在外部类的成员位置上
       public class Page {
           public void story() {
               System.out.println(pageNum + "页，讲了故事");
           }
       }
       public void s1() {
           new Page().story();
       }
   }

3. 作用域

   和外部类其他成员一样，为整个类体

4. 成员内部类---访问----->内部类(比如：属性)[访问方式：直接访问]

5. 外部类---访问----->内部类[访问方式：创建对象，再访问]

6. 外部其他类---访问------>内部成员类

   package com.mdkstu.memberinnerclass;
   ​
   public class MemberInnerClass01 {
       public static void main(String[] args) {
           Outer01 outer01 = new Outer01();
           //外部其他类使用成员内部类的三种方式
           //第一种方式
           Outer01.Inner01 inner01 = outer01.new Inner01();
           inner01.show();
           //第二种方式 在外部类中编写一个方法返回内部类
           Outer01.Inner01 inner011 = outer01.getInner01();
           inner011.show();
       }
   }
   class Outer01 {
       private int age;
       private String name;
       public class Inner01 {
           public void show() {
               System.out.println(name + age);
           }
   ​
       }
       public Inner01 getInner01() {
           return new Inner01();
       }
   }

7. 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问。

7.静态内部类

• 说明：静态内部类是定义在外部类的成员位置，并且有static修饰

  1. 可以直接访问所有外部类的所有静态成员，包括私有的，但不能直接访问非静态成员

  2. 可以添加任意访问修饰符(public,protected,默认,private)，因为它的地位就是一个成员

  3. 作用域：同其他的成员，为整个类体

  4. 静态内部类---访问----->外部类(比如：静态属性)[访问方式：直接访问所有静态成员]

  5. 外部类---访问----->静态内部类 访问方式 创建对象，再访问

  6. 外部其他类---访问----->静态内部类

     1. Outer.Inner inner = new Outer.Inner();

        因为静态内部类是可以通过类名直接访问的(前提是满足访问权限)

     2. 编写一个方法返回静态内部类的对象实例

        public static Inner getInner() {

        return new Inner();

        }

  7. 如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问