3 面向对象编程

3.1 编程语言的发展

  • 第一代语言：机器语言
    1.     第一代计算机语言称为机器语言。机器语言就是 0/1 代码。计算机只能识别 0 和 1。在计算机内部，无论是一部电影还是一首歌曲或是一张图片，最终保存的都是 0/1 代码，因为 CPU 只能执行 0/1 代码。那么这是不是就意味着我们编程一定要用 0/1 代码
  • 第二代语言：汇编语言
    1.     如果直接用机器语言编写的话，这几乎是无法实现的。因为用机器语言太难记忆了，也没人能看得懂。所以后来就设计出了第二种语言，即将 0/1 代码翻译为英文单词，这些英文单词直接对应着一串 0/1 指令。这个就是汇编语言。
  1.     通过专门的软件就可以将这些英文单词转化成 0/1 代码并由计算机执行，这种专门起翻译的作用的软件叫作编译器。
  3.     这些英文单词和与它们对应的 0/1 代码之间的对应关系，以及语言的语法，在编写这个软件的时候就已经写在里面了。我们只要通过编译器就可以将这些都转化成 0/1 代码。这样大大方便了我们对程序的编写。
  • 第三代语言：高级语言
    1.     汇编语言之后又出现了第三代语言。第三代语言又叫“高级语言”。高级语言的发展分为两个阶段，以 1980 年为分界线，前一阶段属于结构化语言或者称为面向过程的语言，后一阶段属于面向对象的语言。
  • 面向过程的语言
    1.     面向过程的语言也称为结构化程序设计语言，是高级语言的一种。在面向过程程序设计中，问题被看作一系列需要完成的任务，函数则用于完成这些任务，解决问题的焦点集中于函数。
  • 面向对象的语言
    1.     面向对象语言（Object-Oriented Language）是一类以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。语言中提供了类、继承等成分，有识认性、多态性、类别性和继承性四个主要特点。
  1.     20 世纪 80 年代以后，有了面向对象分析（OOA）、 面向对象设计（OOD）、面向对象程序设计（OOP）等新的系统开发方式模型的研究。
  3.     对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。

语言的发展总是朝着认类更容易理解的方向前进。

3.2 面向过程和面向对象的区别

  • 面向过程
    1.     是一种以过程为中心的编程思想。就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用。
  • 面向对象
    1.     是一类以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。系统中的基本构件可识认为一组可识别的离散对象，对象具有唯一的静态类型和多个可能的动态类型，在基本层次关系的不同类中共享数据和操作。
  1.     面向对象的特点是：**封装**，**多态**，**继承**。其中多态有分为重载和重写。面向对象的编程思想更加接近现实的事物。
  3.     因为面向对象更接近于现实，所以你可以从现实的东西出发，进行适当的抽象，使编程更加容易。
  5.     在软件工程上，面向对象可以使工程更加模块化，实现更低的耦合和更高的内聚。
  7.     在设计模式上，面向对象可以更好的实现开-闭原则，使代码更易阅读和维护。
  9.     面向过程的程序设计是面向对象程序设计的基础。
  11.     面向对象的设计出发点是为了更直接的描述客观存在的事务。

3.3 类(Class)和对象(Object)的概念

在面向对象中，类和对象是最基本、最重要的组成单元。类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。

类就是对象的模板，对象就是类的一个个具体实例。

类中定义了这一类对象所具有的静态属性和动态属性。

对象是计算机语言对某种事物的描述，通过属性（attribute）和方法（method）来区别事物中对应的静态和动态属性。

3.4 类(对象)之间的关系

  • 关联关系
    通常是一个类中的某些方法或参数中包含对另一个类的引用
  • 继承关系（一般和特殊）
    一个类继承另一个类后，这个类会拥有被继承类的一些属性和方法。
  • 聚合关系（整体和部分）
    两个或几个类共同构成了某个类（聚集和组合，组合的关系更加紧密）
  • 实现关系
    一个类实现接口（interface）类后，重写接口中的所有方法

面向对象程序开发思维：

  1. 写程序时先考虑需要有那些类和对象
  2. 这些类和对象中应该具有什么样的属性和方法
  3. 类和类之间应该具备什么关系

3.5 类的定义

3.5.1 概念

定义类其实在定义类中的成员（成员变量和成员函数）

3.5.2 类名命名规则

  • 类名应该以下划线（_）或字母开头，最好以字母开头
  • 第一个字母最好大写，如果类名由多个单词组成，则每个单词的首字母最好都大写
  • 类名不能为 Java 中的关键字，例如 boolean、this、int 等
  • 类名不能包含任何嵌入的空格或点号以及除了下划线（_）和美元符号（$）字符之外的特殊字符
  1. // 定义类的格式
  2. public class 类名 { 
  3.     [访问修饰符] 数据类型 属性名；         //定义属性部分
  4.     [访问修饰符] 返回值类型 方法名(参数){ }  //定义方法部分
  5. }

3.5.3 代码示例

  1. /**
  2.  * 类的定义
  3.  */
  4. public class ClassDefinition {
  5.     // idea查看类中的属性和方法快捷键： alt + 7
  7.     static int a; // 成员变量  有默认值
  9.     public static void main(String[] args) {
  10.         test();
  11.     }
  13.     public static void test(){ // 成员函数、方法
  14.         int a = 1;  // 局部变量a 没有默认值，使用前需要初始化，可以和成员变量同名，优先级更高
  15.         int b = 0;  // 局部变量b
  16. //        int a = 2;  // 不可以重名
  17.         a = 2;
  18.         System.out.println("a= " + a);
  19.         System.out.println("b= " + b);
  20.     }
  22.     public static void test2(){
  23.         System.out.println(a);
  24. //        System.out.println(b); // 不能访问其他方法中的局部变量
  25.     }
  27.     public static void test3(int a){ // 形参属于局部变量
  28.         System.out.println(a);
  29.     }
  30. }
区别 成员变量 局部变量
定义的位置 直接在类中，方法的外部定义 定义在方法内，代码块内,方法的形参部分
声明赋值 可以在声明时赋初始值，也可以不用赋值，系统会自动根据不同数据类型赋默认值（默认值参考数据类型章节） 使用前一定要有显式的赋值，没有默认初始化值
作用域 整个类内部都可以访问，所哟成员方法也可以访问，如果访问权限允许，还可以在类外部被访问 在变量所在方法内部可以访问，方法外部不可以
访问修饰符 public private protected default 没有修饰符，与它所在的方法修饰符一样
在内存中的位置 堆空间中 栈空间中

注意：

  • 在同一作用域中，变量名不可以重复定义，不可以重名

  • 作用域不同，变量可以重名，如果重名，在方法中的变量比外部成员变量有更高优先级

  • 方法中的参数如果是基本数据类型，那么传递的是值本身，如果是引用数据类型，则传递的是对象的引用

一般约定的命名规则

分类 命名规则 案例
包名 所有字母小写 helloworld
类名 每个单词首字母大写 HelloWorld{}
变量名 驼峰（第一个单词首字母小写，后面每个单词首字母大写） helloWorld
方法名 驼峰 helloWorld()

3.6 对象和引用

3.6.1 格式

  1. // 创建并引用对象的格式
  2. 类名 对象名 = new 类名(); // 这里其实是new的构造方法
  3.     对象名.属性名;        // 引用某个对象的属性（成员变量）
  4.     对象名.方法名(...);   // 引用某个对象的方法

3.6.2 代码示例

  1. /**
  2.  * 对象和引用
  3.  */
  4. public class ObjectReferences {
  5.     public static void main(String[] args) {
  6.         Car myCar = new Car();     // 创建Car的对象，对象名为myCar
  7.         System.out.println(myCar); // myCar -> @1b6d3586 对象的引用，而不是对象本身
  9.         String carName = myCar.name;
  10.         int carSeat = myCar.seat;
  12.         System.out.println(carName);
  13.         System.out.println(carSeat);
  14.         myCar.run();
  15.         myCar.stop();
  16.     }
  17. }
  19. class Car{
  20.     String name;
  21.     int seat;   // 座位
  23.     public void run(){
  24.         System.out.println("开车...");
  25.     }
  27.     public void stop(){
  28.         System.out.println("刹车...");
  29.     }
  30. }

3.6.3 内存结构图

03-面向对象编程 - 图1

3.7 构造方法（构造函数）

3.7.1 构造函数作用

用来给给对象进行初始化，例如：new 构造方法(...);

3.7.2 构造函数特点

  • 构造方法名与类名相同
  • 构造方法没有返回值，不需要定义返回值类型，更不能写void，只要声明了返回值类型，就是普通方法
  • 如果类中构造方法一个都没写时，JVM会自动添加一个无参的构造方法，如果我们写了了构造方法，JVM不会再次添加无参构造方法，我们创建对象只能通过new我们自己写的构造方法
  • 构造方法可以写多个，构成方法重载

3.7.3 代码示例

  1. /**
  2.  * 构造函数
  3.  */
  4. public class Constructor {
  5.     public static void main(String[] args) {
  6.         Person person = new Person();
  7.         System.out.println(person.name + ": " + person.age);
  9.         Person person1 = new Person("tom", 20);
  10.         System.out.println(person1.name + ": " + person1.age);
  11.     }
  12. }
  14. class Person{
  15.     String name;
  16.     int age;
  18.     Person(){  // 无参构造函数
  19.         name = "jason";
  20.         age = 18;
  21.     }
  23.     Person(String _name, int _age){ // 有参构造函数，多个同名方法构成方法重载
  24.         name = _name;
  25.         age = _age;
  26.     }
  27. }

3.7.4 内存结构图

03-面向对象编程 - 图2

3.8 对象的创建和使用内存分析

对象的创建参考3.6

3.8.1 注意

  • 同一个类的每个对象，在内存中有不同的存储空间

  • 同一个类的每个对象，共享该类的方法

    • 非静态方法是针对每个对象进行调用
    • 静态（static）方法是针对该类进行调用

3.8.2 代码示例

  1. /**
  2.  * 对象的创建和引用，及内存分析案例
  3.  */
  4. public class ObjectCreation {
  5.     public static void main(String[] args) {
  6.         Circle c = new Circle(3.0);
  7.         double area = c.getAreaOfCricle();
  8.         System.out.println(area);
  10.         c.setR(2.0);
  11.         System.out.println(c.getAreaOfCricle());
  13.         System.out.println(c.getAreaOfCricle(new Circle(2.0))); // 匿名对象
  14.     }
  15. }
  17. class Circle{
  18.     double r; // 半径
  20.     Circle(double _r){
  21.         r = _r;
  22.     }
  24.     // 求圆的面积
  25.     public double getAreaOfCricle(){
  26.         return 3.14*r*r;
  27.     }
  29.     public double getAreaOfCricle(Circle c){ // 方法重载
  30.         return 3.14*c.r*c.r;
  31.     }
  33.     public void setR(double _x){
  34.         r = _x;
  35.     }
  36. }

内存结构图：

略

3.9 方法的重载（Overload）

3.9.1 概念

方法重载是指在类中可以定义有相同名字但参数类型或数目不同的多个方法，调用时会根据不同参数信息选择调用对应的方法

3.9.2 特点

  • 参数类型或数量不能相同
  • 与返回值无关
  • 构造方法也可以重载，参考上面的案例

3.9.3 代码示例

  1. /**
  2.  * 方法的重载
  3.  */
  4. public class MethodOverload {
  5.     public static void main(String[] args) {
  6.         getMax(3, 2);
  8.         short s1 = 1;
  9.         short s2 = 2;
  10.         getMax(s1, s2);
  12.         getMax(2, 3, 4);
  13.     }
  15.     public static void getMax(int a, int b){
  16.         int max = a > b ? a : b;
  17.         System.out.println("int最大值是：" + max);
  18.     }
  20. //    public static int getMax(int a, int b){ // 方法重名，不行
  21. //        int max = a > b ? a : b;
  22. //        return max;
  23. //    }
  25.     public static void getMax(short a, short b){
  26.         int max = a > b ? a : b;
  27.         System.out.println("short最大值是：" + max);
  28.     }
  30.     public static void getMax(int a, int b, int c){
  31.         int max = a > b ? a : b;
  32.         max = max > c ? max : c;
  33.         System.out.println("int最大值是：" + max);
  34.     }
  35. }

3.10 关键字-this

3.10.1 概念

this：是本类对象的…的意思，代表所在函数所属对象的引用，就是对本类对象的引用

3.10.2 特点

  • 当函数内有局部变量和成员变量同名的时候，用this区分
  • 当函数内需要用到调用该函数的对象，用this
  • 可以在构造器中通过“this([形参...])”，方式来显式的调用本类中其他重载的制定的构造器

3.10.3 代码示例

  1. /**
  2.  * this关键字
  3.  */
  4. public class Keyword_this {
  5.     public static void main(String[] args) {
  6.         Student s = new Student();
  7.         s.show();
  8.         s.test();
  9.     }
  10. }
  12. class Student {
  13.     String name;
  14.     int age;
  16.     Student(){
  17.         this("jason", 18);
  18.     };
  20.     Student(String name, int age){
  21.         this.name = name;
  22.         this.age = age;
  23.     }
  25.     public void show(){
  26.         String name = "lily";
  27.         int age = 20;
  28.         System.out.println("name : " + name + "  age : " + age);
  29.         // 通过this调用本类对象的成员变量
  30.         System.out.println("this.name : " + this.name + "  this.age : " + this.age);
  31.     }
  33.     public void test(){
  34.         this.show();  // 通过this调用本类成员方法
  35.     }
  36. }

3.11 关键字-static

3.11.1 概念

static：静态的意思，用来修饰成员（成员变量，成员函数），static修饰的成员变量叫类变量，static修饰的成员函数叫类函数

3.11.2 特点

  • 可以直接被类名（不需要创建对象实例化）调用
  • 随着类的加载而加载，优先于对象存在
  • 静态函数只能调用静态成员变量和静态成员函数
  • 静态方法中不可以写this、super关键字
  • 被所有该类的对象所共享，内存中只存在一份，而普通成员变量在内存中每个本类的对象都有单独一份
  • 静态方法不能被重写，参考方法的重写 代码示例

3.11.3 代码示例

  1. /**
  2.  * static关键字
  3.  */
  4. public class Keyword_static {
  5.     public static void main(String[] args) {
  7. //        TestStatic.getName(); // 不能通过类名调用非静态方法
  9.         System.out.println(TestStatic.name); // 直接调用静态属性
  10.         TestStatic.test();                   // 直接调用静态方法
  11.         TestStatic ts = new TestStatic();
  12.         String name = ts.getName();          // 非静态方法只能通过对象引用调用
  13.         System.out.println(name);
  15.         TestStatic ts1 = new TestStatic();
  16.         ts1.setName("tom");
  18.         System.out.println(ts.getName());    // 静态成员被所有对象共享
  19.         System.out.println(ts1.getName());
  20.     }
  21. }
  23. class TestStatic {
  24.     int age;
  25.     static String name = "jason";
  27.     public static void test(){
  28. //        age = 18;  // 静态方法中不能调用非静态成员变量
  29.         name = "lily";
  30. //        System.out.println(this.age);  // 报错，不能写this关键字
  31.     }
  33.     public String getName(){
  34. //        test();  // 可以直接调用本类静态方法
  35.         return name;
  36.     }
  38.     public void setName(String name){
  39.         this.name = name;
  40.     }
  41. }

3.12 关键字-package、import

3.12.1 package包

目的：解决类名命名冲突问题，引入包（package）机制，提供类的多重类命名空间，控制访问范围

用法：放在类的代码第一行，使用“.”来指明包（目录）层次

命名规则：一般是利用公司或组织域名的反写，加上项目模块名等，例如：package cn.com.liyanlong;

3.12.2 import 引入

目的：如果一个类中用到了别的包下的某个类中的引用，则使用哦个import关键字引入相应的包下的类

用法：在package关键字下面，类名上面，例如：improt cn.com.liyanlong.Person，表示引入，如果访问的是同一个包下的类，不需要引入

注意：

  • java.lang包下的类在使用的时候，不需要引入，直接使用就可以，其他包下的的需要引入（idea可以设置自动导入）

  • 了解rt.jar

    • java.lang包：包含一些Java语言的核心类，如：String，Math，Integer，System，Thread等，提供常用的功能
    • java.net包：提供与网络相关的操作的类
    • java.io包：提供多种输入输出的类
    • java.util包：提供一些常用工具类，如日期日历相关操作类
    • java.awt包：构成抽象窗口工具集，用来构建和管理应用程序图形用户界面（GUI）（了解）
    • java.applet包：包含applet（Java小程序）运行的一些类（了解）
  • 学会打包，打包命令：jar -cvf xxx.jar *.*

cmd代码示例：

  1. C:\Users\LYL>jar
  2. 用法: jar {ctxui}[vfmn0PMe] [jar-file] [manifest-file] [entry-point] [-C dir] files ...
  3. 选项:
  4.     -c  创建新档案
  5.     -t  列出档案目录
  6.     -x  从档案中提取指定的 (或所有) 文件
  7.     -u  更新现有档案
  8.     -v  在标准输出中生成详细输出
  9.     -f  指定档案文件名
  10.     -m  包含指定清单文件中的清单信息
  11.     -n  创建新档案后执行 Pack200 规范化
  12.     -e  为捆绑到可执行 jar 文件的独立应用程序
  13.         指定应用程序入口点
  14.     -0  仅存储; 不使用任何 ZIP 压缩
  15.     -P  保留文件名中的前导 '/' (绝对路径) 和 ".." (父目录) 组件
  16.     -M  不创建条目的清单文件
  17.     -i  为指定的 jar 文件生成索引信息
  18.     -C  更改为指定的目录并包含以下文件
  19. 如果任何文件为目录, 则对其进行递归处理。
  20. 清单文件名, 档案文件名和入口点名称的指定顺序
  21. 与 'm', 'f' 和 'e' 标记的指定顺序相同。
  23. 示例 1: 将两个类文件归档到一个名为 classes.jar 的档案中:
  24.        jar cvf classes.jar Foo.class Bar.class
  25. 示例 2: 使用现有的清单文件 'mymanifest' 并
  26.            将 foo/ 目录中的所有文件归档到 'classes.jar' 中:
  27.        jar cvfm classes.jar mymanifest -C foo/ .

3.12.3 代码示例

  1. package cn.com.liyanlong;
  3. //import java.util.Date;  // 单独引入Date类
  4. import java.util.*;       // * 表示当前包下的所有类
  6. public class Package_and_Import {
  7.     public static void main(String[] args) {
  8.         Date date = new Date();
  9.         System.out.println(date.toString());
  10.     }
  11. }

3.13 类的继承（extends）

3.13.1 概念

继承：如果多个类中存在相同的属性和行为，可以将这些内容单独抽取到一个类中，其他类就无须再重复定义，直接继承单独的那个类即可。通过继承，子类可以拥有父类的所有成员（成员变量和成员方法），解决代码复用问题

备注：

  • “子类”也可称为：派生类，孩子类
  • “父类”也可称为：基类，超类
  • Java只支持单继承，不支持多继承，一个类只可以有一个基类，一个基类可以派生出多个子类
  • 子类不能继承父类构造方法

3.13.2 特点

通过extends关键字实现

3.13.3 代码示例

  1. /**
  2.  * extends关键字 /继承
  3.  */
  4. public class Keyword_extends {
  5.     public static void main(String[] args) {
  6.         Sun sun = new Sun();
  7.         sun.height = 180;    // 父类属性
  8.         sun.setWeight(80);   // 父类方法
  9.         sun.getHeight();
  10.         sun.getWeight();
  11.         sun.school = "北大";  // 子类属性
  12.         sun.playGames();     // 子类方法
  13.     }
  14. }
  16. class Father {
  17.     // 快捷键： alt + Insert 快速生成set、get方法
  18.     public int height;
  19.     public int weight;
  21.     public int getHeight() {
  22.         return height;
  23.     }
  25.     public void setHeight(int height) {
  26.         this.height = height;
  27.     }
  29.     public int getWeight() {
  30.         return weight;
  31.     }
  33.     public void setWeight(int weight) {
  34.         this.weight = weight;
  35.     }
  36. }
  38. class Sun extends Father {
  40.     public String school;
  42.     public void playGames() {
  43.         System.out.println("玩游戏...");
  44.     }
  45. }

3.13.4 内存结构图

03-面向对象编程 - 图3

3.13.5 继承中的构造方法

参考3.14.4和3.14.5

3.14 关键字-super

3.14.1 概念

super：代表对父类的引用，指代父类对象的…的意思

3.14.2 特点

  • 子类和父类出现同名成员，可以用super区分
  • 子类调用父类构造函数时，可以使用“super([形参...])”语句表示。
  • 子类不能通过super调用父类private（私有的）修饰的成员

3.14.3 代码示例

  1. /**
  2.  * super关键字
  3.  */
  4. public class Keyword_super extends SuperClass {
  6.     Keyword_super(){
  7.         // 子类通过super()调用父类构造器
  8.         super();
  9. //        super("lily");
  10.     }
  11.     public static void main(String[] args) {
  12.         Keyword_super ks = new Keyword_super();
  13. //        ks.show(); // 子类调用父类方法
  14.         ks.showSuperInfo();
  15.     }
  17.     public void showSuperInfo(){
  18.         System.out.println("showSuperInfo...");
  19.         System.out.println(super.name);  // 调用父类属性
  20. //        System.out.println(super.age);   // 子类不能调用父类private修饰的成员
  21.         super.show();                    // 调用父类方法
  22.     }
  23. }
  25. class SuperClass {
  26.     public String name;
  27.     private int age;
  29.     SuperClass(){
  30.         name = "jason";
  31.         age = 18;
  32.     }
  34.     SuperClass(String _name){
  35.         name = _name;
  36.         age = 20;
  37.     }
  39.     public void show(){
  40.         System.out.println("I am SuperClass...");
  41.         System.out.println("name: " + name + "\nage : " + age);
  42.     }
  43. }

3.14.4 继承中的构造方法

  • 子类在构造时一定会调用父类构造方法来实例化父类

  • 子类可以在自己的构造方法中使用super(...)调用基类的构造方法

    • 使用this(...)可以调用本类其他构造方法
  • 如果子类构造方法中没有显示的调用父类构造方法，则系统默认首先调用父类无参构造方法
  • 如果子类构造方法中没有显示的调用父类构造方法，且父类没有无参构造方法，则会编译出错
  • 如果显式的调用了super()，则必须写在子类构造方法的第一行（先有父类，才可以有子类）

3.14.5 代码示例

  1. /**
  2.  * 关于继承中的构造方法问题
  3.  */
  4. public class InheritConstructor {
  5.     public static void main(String[] args) {
  6.         new ChildClass();
  7. //        new ChildClass("jason");
  8.     }
  9. }
  11. class FatherClass {
  12.     FatherClass(){
  13.         System.out.println("调用了 -- FatherClass()");
  14.     }
  16.     FatherClass(String name){
  17.         System.out.println("调用了 -- FatherClass()" + " name : " + name);
  18.     }
  19. }
  21. class ChildClass extends FatherClass {
  22.     ChildClass(){  // 如果不写super()，系统会默认调用父类无参构造函数，相当于加了一个super()方法
  23.         System.out.println("调用了 -- ChildClass()");
  24.     }
  26.     ChildClass(String name){
  27.         super(name);
  28.         System.out.println("调用了 -- ChildClass(String name)");
  29. //        super(name); // 不写在第一行，会报错
  30.     }
  31. }

3.15 访问控制/权限控制符

3.15.1 作用

用来进行访问控制，可以修饰类，属性，方法，修饰类时只能使用public或默认

3.15.2 分类

访问修饰符 public(公共的) protected(受保护的) 默认的/default private(私有的)
同一个类中 √ √ √ √
同一个包，子类 √ √ √ ❌
同一个包，非子类 √ √ √ ❌
不同包，子类 √ √ ❌ ❌
不同包，非子类 √ ❌ ❌ ❌

3.15.3 代码示例

  1. /**
  2.  * 权限控制/访问修饰符
  3.  */
  4. public class AccessModifier {
  6.     public String name;  // public 公共的
  7.     protected int age;   // protected 受保护的
  8.     String sex;          // 默认/default
  9.     private int height;  // private 私有的
  11.     public void test(){  // 本类中的普通方法，都可以访问
  12.         System.out.println(name);
  13.         System.out.println(age);
  14.         System.out.println(sex);
  15.         System.out.println(height);
  16.     }
  17. }
  1. /**
  2.  * 权限控制/访问修饰符 测试 - 同一包下子类
  3.  */
  4. public class AccessModifierSun extends AccessModifier {
  5.     public static void main(String[] args) {
  6.         AccessModifierSun ams = new AccessModifierSun();
  7.         System.out.println(ams.name);
  8.         System.out.println(ams.age);
  9.         System.out.println(ams.sex);
  10. //        System.out.println(ams.height);  // 不能访问私有属性
  11.     }
  12. }
  1. /**
  2.  * 权限控制/访问修饰符 测试 - 同一包下非子类
  3.  */
  4. public class AccessModifierTest {
  5.     public static void main(String[] args) {
  6.         AccessModifier am = new AccessModifier();
  7.         System.out.println(am.name);
  8.         System.out.println(am.age);
  9.         System.out.println(am.sex);
  10. //        System.out.println(am.height);  // 不能访问私有属性
  11.     }
  12. }
  1. /**
  2.  * 权限控制/访问修饰符 测试 - 不同包下子类
  3.  */
  4. public class AccessModifierSun extends AccessModifier {
  5.     public static void main(String[] args) {
  6.         AccessModifierSun ams = new AccessModifierSun();
  7.         System.out.println(ams.name);
  8.         System.out.println(ams.age);
  9. //        System.out.println(ams.sex);     // 不能访问默认属性
  10. //        System.out.println(ams.height);  // 不能访问私有属性
  11.     }
  12. }
  1. /**
  2.  * 权限控制/访问修饰符 测试 - 不同包下非子类
  3.  */
  4. public class AccessModifierTest {
  5.     public static void main(String[] args) {
  6.         AccessModifier am = new AccessModifier();
  7.         System.out.println(am.name);
  8. //        System.out.println(am.age);     // 不能访问受保护的属性
  9. //        System.out.println(am.sex);     // 不能访问默认属性
  10. //        System.out.println(am.height);  // 不能访问私有属性
  11.     }
  12. }

3.16 类的封装

3.16.1 概念

把抽象的数据和对数据进行的操作封装在一起，数据被保存在内部，程序的其他部分只有通过被授权的操作（成员方法）才能对数据进行操作，保护数据不被外部直接修改

3.16.2 特点

  • 数据封装：保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问
  • 方法封装：方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者
  • 当对象含有完整的属性和与之对应的方法时称为封装
  • 从对象外面不能直接访问对象的属性，只能通过和该属性对应的方法访问，提供公共访问方法（setter,getter）
  • 对象的方法可以接收对象外面的消息
  • 通过访问修饰符（private）实现，私有化属性

3.16.3 代码示例

  1. /**
  2.  * 封装
  3.  */
  4. public class Encapsulation {
  5.     public static void main(String[] args) {
  6.         Person person = new Person();
  7.         person.name = "jason";
  8.         System.out.println(person.name);
  10.         person.setAge(100);
  11.         System.out.println(person.getAge());
  12.     }
  13. }
  15. class Person {
  16.     public String name;
  17.     // 数据封装，使用private隔绝外部直接访问
  18.     private int age;
  20.     // 对外提供访问方法
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     // 对外提供访问方法，可以接受参数
  26.     public void setAge(int age) {
  27.         if(this.checkAge(age))
  28.             this.age = age;
  29.     }
  31.     // 方法封装，只允许当前类内部访问
  32.     private boolean checkAge(int age){
  33.         return age < 0 ? false : age > 150 ? false : true;
  34.     }
  35. }

3.17 方法的重写（Override）

3.17.1 概念

当子类中出现和父类一模一样的方法时，会出现覆盖操作，也叫做重写，复写

3.17.2 特点

  • 子类方法必须和父类方法完全一样才能覆盖（名称、参数类型和参数个数都一样）
  • 如果想继续调用父类方法，可以使用super关键字
  • 父类中的私有的方法，子类不能访问
  • 重写的方法不能拥有比被重写方法更严格的访问权限
  • 使用场景：当父类中的实现不能满足子类时，子类可以根据需要重写相应的方法的实现
  • 返回值类型可以是被重写方法返回值类型的子类

3.17.3 代码示例

  1. /**
  2.  * 方法的重写/覆盖
  3.  */
  4. public class MethodOverride extends SuperMethodOverride {
  5.     // 重写父类方法快捷键  ctrl + o
  6.     public static void main(String[] args) {
  7.         MethodOverride mo = new MethodOverride();
  8.         mo.testOverride(); // 此时子类方法覆盖父类方法，本方法则会调用子类方法
  9.         mo.testSuper();    // 如果想调用父类方法，可以使用super关键字来调用
  10.         mo.testOther();    // 如果子类中没有覆盖父类方法，则会继续调用父类方法
  11.     }
  13.     public void testSuper(){
  14.         testOverride();
  15.         super.testOverride(); // 可以通过super调用父类方法
  16.     }
  18.     @Override
  19.     public void testOverride(){
  20.         System.out.println("I am MethodOverride...");
  21.     }
  23.     @Override
  24.     public void testAccessOverride() { // 访问权限不能比父类方法权限更严格，可以更宽松
  25.         super.testAccessOverride();
  26.     }
  28.     @Override
  29.     public MethodOverride testReturnTypeOverride() { // 返回值类型可以是被重写方法返回值类型的子类
  30.         return new MethodOverride();
  31.     }
  33.     // 静态方法不能被重写
  34. //    @Override
  35. //    public static void testStatic(){}
  37.     /*
  38.      * @Override 表示覆盖（重写）父类方法，这里是静态方法所以不能被覆盖（重写）
  39.      * 不写 @Override 注解，且方法与父类一模一样时，此时父类相应方法相对于子类会隐藏，
  40.      * 而不是被子类重写，调用时是调用的子类方法
  41.      */
  42.     public static void testStatic(){
  43.         System.out.println("testStatic...MethodOverride");
  44.     }
  45. }
  47. class SuperMethodOverride {
  48.     public void testOverride(){
  49.         System.out.println("I am SuperMethodOverride...");
  50.     }
  52.     void testAccessOverride(){
  53.         System.out.println("testAccessOverride...");
  54.     }
  56.     public SuperMethodOverride testReturnTypeOverride(){
  57.         System.out.println("testReturnTypeOverride...");
  58.         SuperMethodOverride s = new SuperMethodOverride();
  59.         return s;
  60.     }
  62.     public void testOther(){
  63.         System.out.println("没有被覆盖的方法...");
  64.     }
  66.     // 静态方法
  67.     public static void testStatic(){
  68.         System.out.println("testStatic...");
  69.     }
  70. }

3.18 关键字-final

3.18.1 概念

final：最终的，不可改变的

3.18.2 特点

  • 可以修饰类，方法，变量
  • 修饰的类不可以被继承
  • 修饰的方法不可以被覆盖
  • 修饰的变量，是一个常量，只能被赋值一次
  • 命名规范

3.18.3 代码示例

  1. /**
  2.  * fianl 关键字
  3.  */
  4. public class Keyword_final extends SuperFinal {
  5.     public static void main(String[] args) {
  6.         new Keyword_final().test();
  8.         SuperFinal superFinal = new SuperFinal();
  9. //        superFinal.USER_NAME = "abc"; // 不能修改final修饰的变量
  10.         superFinal.age = 28;
  12.         superFinal.testFianl();
  13.     }
  15.     @Override
  16.     public void test() {
  17.         super.test();
  18.     }
  20.     // 不可以覆盖final方法
  21. //    @Override
  22. //    public void testFianl() {
  23. //    }
  25.     // final 修饰的参数不能被改变
  26.     public void test2(final int num){
  27. //        num++;
  28. //        num = 0;
  29.     }
  30. }
  32. // final修饰的类
  33. final class Final {
  35. }
  37. // 被final修饰的类不可以被继承
  38. //class SubFinal extends Final {
  39. //
  40. //}
  42. class SuperFinal {
  43.     public final String USER_NAME = "jason";
  44.     public int age = 18;
  46.     public final void testFianl(){
  47.         System.out.println("USER_NAME: " + USER_NAME + "  age: " + age);
  48.     }
  50.     public void test(){
  51.         System.out.println("USER_NAME: " + USER_NAME + "  age: " + age);
  52.     }
  53. }

3.19 对象转型

3.19.1 概念

一种事物的多种存在形态

3.19.2 特点

  • 父类或接口的引用“指向”子类对象
  • 父类引用不能访问子类新增的成员（属性和方法）
  • 可以使用 引用变量 instanceof 类名 来判断该引用类型变量所“指向”的对象是否是属于该类或该类子类
  • 子类对象可以作为基类对象来使用，叫向上转型，反之叫向下转型

3.19.3 代码示例

  1. /**
  2.  * 对象转型
  3.  */
  4. public class ObjectCasting {
  5.     public static void main(String[] args) {
  6.         // 父类引用指向子类对象
  7.         Aniaml aniaml = new Dog("小黑");  // 向上转型
  8.         Aniaml aniaml2 = new Bird("鹦鹉");
  10.         Dog dog = (Dog) aniaml;  // 向下转型，需要强制转换
  12. //        Dog dog2 = (Dog) aniaml2; // 错误转型  异常 : java.lang.ClassCastException
  14.         /*
  15.          * 使用 instanceof 关键字，进行判断
  16.          * 作用：判断是否属于某个类型，返回boolean类型值
  17.          * 前提： 使用instanceof时，对象类型必须和instanceof后面的参数所指定的类在继承上有上下级关系
  18.          * 语法：   boolean bn  = 子类类型 instanceof 父类类型
  19.          */
  20.         System.out.println(aniaml instanceof Dog);  // instanceof 判断是否属于某个类型
  21.         System.out.println(aniaml2 instanceof Dog);
  23.         if(aniaml instanceof Dog){
  24.             Dog d1 = (Dog) aniaml;
  25.         }
  26.         if(aniaml2 instanceof Dog){
  27.             Dog d21 = (Dog) aniaml;
  28.         }
  29.     }
  30. }
  32. // 所有动物类的父类
  33. class Aniaml {
  34.     public String name;
  35.     public void run(){  // 此处根据实际情况，可以写方法默认实现，也可以不写，如果不写，则需定义为抽象方法
  36.         System.out.println("默认方法...");
  37.     }
  39.     // 静态成员变量
  40.     static String flag = "我是父类...";
  41.     // 静态成员方法
  42.     public static void eat(){
  43.         System.out.println("吃某种食物...");
  44.     }
  45. }
  47. class Dog extends Aniaml {
  48.     Dog (String name){
  49.         this.name = name;
  50.     }
  52.     // 子类特有的属性
  53.     public int leg = 4;
  55.     // 重写父类方法
  56.     @Override
  57.     public void run(){
  58.         System.out.println("四条腿跑...");
  59.     }
  61.     // 子类特有的方法
  62.     public void swimming(){
  63.         System.out.println("dog 会游泳...");
  64.     }
  66.     // 静态成员变量
  67.     static String flag = "我是子类...";
  68.     // 静态成员方法
  69.     public static void eat(){
  70.         System.out.println("吃狗粮...");
  71.     }
  72. }
  74. class Bird extends Aniaml {
  75.     Bird (String name){
  76.         this.name = name;
  77.     }
  78.     // 重写父类方法
  79.     @Override
  80.     public void run(){
  81.         System.out.println("张开翅膀飞...");
  82.     }
  83. }

3.20 动态绑定/多态

3.20.1 概念

动态绑定/多态：指在程序执行期间判断所引用对象的实际类型，根据实际类型调用相应方法

3.20.2 特点

  • 多态前提：

    • 需要存在继承或者实现关系
    • 要有覆盖操作（Override）
    • 父类应用指向子类对象
  • 多态的存在提高了程序的扩展性和后期可维护性

3.20.3 代码示例

  1. /**
  2.  * 多态
  3.  */
  4. public class Polymorphism {
  5.     // 多态前提：  存在继承或实现关系，要有覆盖操作
  6.     /*
  7.      * 多态特点：
  8.      * 1非静态成员变量： 编译看左边（父类引用），运行看左边（父类引用）
  9.      * 2静态成员变量：   编译看左边（父类引用），运行看左边（父类引用）
  10.      * 3非静态成员函数： 编译看左边（父类引用），运行看右边（子类对象）
  11.      * 4静态成员函数：   编译看左边（父类引用），运行看左边（父类引用）
  12.      */
  13.     public static void main(String[] args) {
  14.         // 向上转型
  15.         Aniaml aniaml = new Dog("小黑");
  16.         Aniaml aniaml2 = new Bird("鹦鹉");
  18.         System.out.println("aniaml: " + aniaml.name);      // 特点 1非静态成员变量
  19.         aniaml.run();                                      // 特点 3非静态成员函数
  20.         System.out.println("animal-flag: " + aniaml.flag); // 特点 2静态成员变量
  21.         aniaml.eat();                                      // 特点 4静态成员函数
  23.         System.out.println("aniaml2: " + aniaml2.name);
  24.         aniaml2.run();
  26. //        System.out.println(aniaml.leg); // 父类引用不能调用子类特有属性
  27. //        aniaml.swimming(); // 父类引用不能调用子类特有方法
  29.         // 向下转型，需要强制转换，转换后可以调用子类特有的属性和方法
  30.         Dog dog = (Dog) aniaml;
  31.         System.out.println(dog.name);
  32.         System.out.println(dog.leg);
  33.         dog.run();
  34.         dog.swimming();
  35.         System.out.println("dog-flag: " + dog.flag);
  36.         dog.eat();
  37.     }
  38. }
  1. /**
  2.  * 多态案例
  3.  */
  4. public class PolymorphismTest {
  5.     public static void main(String[] args) {
  6.         User user1 = new User("张三",new HouYi());
  7.         User user2 = new User("李四",new LiBai());
  9.         GameRole user1Role = user1.getRole();
  10.         GameRole user2Role = user2.getRole();
  12.         user1Role.skill();
  13.         user2Role.skill();
  14.     }
  15. }
  17. // 用户
  18. class User {
  19.     User(String userName, GameRole role) {
  20.         this.userName = userName;
  21.         this.role = role;
  22.     }
  23.     private String userName;
  24.     private GameRole role;
  26.     public GameRole getRole() {
  27.         System.out.println(userName + " 的游戏角色是： " + role.roleName);
  28.         return role;
  29.     }
  30. }
  32. // 游戏角色-父类
  33. class GameRole {
  34.     public String roleName;
  35.     public void skill(){
  36.         System.out.println("拥有某项技能...");
  37.     }
  38. }
  40. // 游戏角色-子类
  41. class HouYi extends GameRole{
  42.     HouYi() {
  43.         this.roleName = "后羿";
  44.     }
  46.     @Override
  47.     public void skill() {
  48.         System.out.println("后羿大招：火鸟之翼");
  49.     }
  50. }
  52. // 游戏角色-子类
  53. class LiBai extends GameRole{
  54.     LiBai() {
  55.         this.roleName = "李白";
  56.     }
  58.     @Override
  59.     public void skill() {
  60.         System.out.println("李白大招：青莲剑歌");
  61.     }
  62. }
  64. // 后期如果添加新的角色，可以直接新建对应的类即可，不用在原文件中修改，增强程序扩展性

3.21 抽象类（abstract）

3.21.1 概念

使用abstract关键字修饰的类是抽象类（使用abstract修饰的方法为抽象方法）

3.21.2 特点

  • 抽象类和抽象方法必须用abstract来修饰
  • 含有抽象方法的类必须被声明为抽象类，抽象类中可以有普通方法
  • 抽象类不能被实例化（抽象类中可以有构造函数）
  • 抽象类可以通过子类实例化，子类需要覆盖抽象类中所有的抽象方法才能创建对象，否则该子类还是一个抽象类
  • 抽象方法只有方法声明，没有方法体（不需实现），定义在抽象类中
  • abstract和static不能共存
  • abstract和private不能共存

3.21.3 代码示例

  1. /**
  2.  * 抽象类
  3.  */
  4. public abstract class AbsClass {
  5.     public static void main(String[] args) {
  6. //        AbsClass absClass = new AbsClass(); // 不可以实例化
  7.         AbsClass absClass = new AbsChild(); // 通过子类实例化
  8.         absClass.testAbs();
  10.         AbsClass.testStatic();
  11.         new AbsChild().testStatic();
  12.     }
  14.     AbsClass() {} // 可以存在构造方法
  16.     // 不能使用static修饰成员变量
  17. //    public staitc String name;
  18.     // 普通成员变量
  19.     public int age;
  21.     // 普通方法
  22.     public void test(){
  23.         System.out.println("test...");
  24.     }
  26.     // 抽象方法不需要实现，由子类在继承这个抽象类时进行实现
  27.     public abstract void testAbs();
  29.     // 静态方法属于类方法，不需要类实例化即可调用，一般不建议放在抽象类中使用
  30.     public static void testStatic(){
  31.         System.out.println("testStatic...AbsClass");
  32.     }
  34.     // private 不能和 abstract 同时使用，当方法私有后，就不能被子类重写
  35. //    private abstract void testPrivate();
  37.     // static 不能和 abstract 同时使用，静态方法为类方法，不能被子类重写
  38. //    static abstract void testPrivate();
  39. }
  41. class AbsChild extends AbsClass {
  42.     // 子类继承抽象类后，需要实现抽象类中所有的抽象方法
  43.     @Override
  44.     public void testAbs() {
  45.         System.out.println("testAbs...");
  46.     }
  48.     /*
  49.      * @Override 表示覆盖（重写）父类方法，这里是静态方法所以不能被覆盖（重写）
  50.      * 当不写 @Override 注解，且方法与父类一模一样时，此时父类相应方法相对于子类会隐藏，
  51.      * 而不是被子类重写，调用时是调用的子类方法
  52.      */
  53. //    @Override
  54.     public static void testStatic(){
  55.         System.out.println("testStatic...AbsChild");
  56.     }
  57. }
  59. // 子类是抽象类，可以不覆盖父类抽象类中的抽象方法
  60. abstract class AbsChild_02 extends AbsClass {
  62. }

3.22 接口（interface）

3.22.1 概念

interface：接口，一种特殊的抽象类，只包含常量和方法的定义，没有变量和方法的实现

3.22.2 特点

  • 一个类可以实现多个接口
  • 多个无关的类可以实现同一个接口
  • 一个接口可以继承多个其他接口，子接口不需要实现被继承的接口中的方法
  • 一个抽象类也可以继承其他接口，子抽象类可以不用实现被继承的接口中的方法
  • 使用interface修饰，格式：public interface 类名 {}
  • 使用implements实现某个接口，格式：public calss 类名 implements 接口名 [, 接口名...] {}
  • 接口中的成员都是常量和抽象方法
  • 成员常量默认修饰：public static final ...
  • 成员函数默认修饰：public abstract 返回值类型 xxx()
  • 接口和实现类之间存在多态性

3.22.3 代码示例

  1. /**
  2.  * 接口
  3.  */
  4. public interface InterfaceClass {
  6.     // 接口中不能有构造方法，不能被直接实例化，只能通过子类实例化
  7. //    InterfaceClass(){
  8. //
  9. //    }
  11.     String name = "jason"; // 相当于自动省略了 public static final
  12.     public static final String name2 = "jason";
  14.     void test(); // 相当于自动省略 public abstract
  16.     public abstract void test2();
  18.     // 接口中不可以有普通方法
  19. //    public void test3(){
  20. //
  21. //    }
  22.     // jdk8新增
  23.     default void test3(){
  25.     }
  26. }
  28. // 一个类实现某个接口，这个类就是接口的实现类，必须重写接口中所有的方法
  29. class TestInterface implements InterfaceClass {
  31.     public static void main(String[] args) {
  32.         // 接口是抽象的，不可以被直接实例化
  33. //        InterfaceClass in = new InterfaceClass();
  34.         // 可以通过子类实例化接口
  35.         InterfaceClass in = new TestInterface();
  36.     }
  38.     @Override
  39.     public void test() {}
  41.     @Override
  42.     public void test2() {}
  43. }
  45. interface InterfaceClass2 {
  47. }
  49. // 一个类可以实现多个接口
  50. class TestInterface2 implements  InterfaceClass, InterfaceClass2{
  52.     @Override
  53.     public void test() {}
  55.     @Override
  56.     public void test2() {}
  57. }
  59. // 接口可以多继承其他接口，子接口不需要实现被继承的接口中的方法
  60. interface InterfaceClass3 extends InterfaceClass, InterfaceClass2 {
  62. }
  64. // 抽象类也可以继承其他接口，子抽象类可以不用实现被继承的接口中的方法
  65. abstract class SubClass implements InterfaceClass, InterfaceClass2 {
  67. }
  1. /**
  2.  * 接口练习
  3.  */
  4. public class InterfaceTest {
  5.     public static void main(String[] args) {
  6. //        User user = new User();
  7. //        user.eat();
  8. //        user.work();
  9. //        user.readBook();
  11.         // 接口只能访问实现类中的一部分代码
  12.         IHuman human = new User();
  13.         human.eat();
  14.         human.work();
  16.         IStudent student = new User();
  17.         student.readBook();
  19.         // 可以画内存图进行辅助理解
  20.         IStudent student2 = (IStudent) human;
  21.         student2.readBook();
  22.     }
  23. }
  25. interface IHuman {
  26.     void eat();
  27.     void work();
  28. //    int readBook(); // 避免实现的两个不同接口中有相同方法名但是返回值类型不一样的情况
  29. }
  31. interface IStudent {
  32.     void readBook();
  33. }
  35. class User implements IHuman, IStudent {
  37.     @Override
  38.     public void eat() {
  39.         System.out.println("吃饭...");
  40.     }
  42.     @Override
  43.     public void work() {
  44.         System.out.println("工作是：敲代码...");
  45.     }
  47.     @Override
  48.     public void readBook() {
  49.         System.out.println("我会读书...");
  50.     }
  51. }

3.23 匿名对象

3.23.1 概念

只创建对象,但是不用变量来接收

3.23.2 特点

  • 匿名对象也是一个对象,具有对象的所有功能
  • 每一次使用匿名对象时，都是一个新的对象，每次创建匿名对象都是不同的对象，所以一个匿名对象，只能使用一次

3.23.3 代码示例

  1. /**
  2.  * 匿名对象
  3.  */
  4. public class AnonymousObject {
  5.     public static void main(String[] args) {
  6.         // 创建有名的对象
  7.         Person person = new Person();
  9.         // 创建匿名对象
  10.         new Person();
  12.         // 调用匿名对象的属性和方法
  13.         new Person().name = "jason";
  14.         System.out.println(new Person().name); // null
  15.         new Person().sleep(); // sleeping...
  16.     }
  17. }
  19. class Person {
  20.     String name;
  22.     public void sleep() {
  23.         System.out.println("sleeping...");
  24.     }
  25. }

3.24 内部类

3.24.1 概念

成员内部类：将一个类定义在另一个类里面,里面的类叫做内部类（内置类，嵌套类）

局部内部类：定义在局部（方法或代码块中）位置

3.24.2 特点

  • 成员内部类：

    • 可以被public、private、protected、static等成员修饰符修饰
    • 被 static 修饰的内部类，只能访问外部类中静态成员

  • 局部内部类：

    • 不能被public、private、protected、static等成员修饰符修饰
    • 可以访问外部类中的成员
    • 也可以访问所在局部中的局部变量，必须是final修饰(JDK1.8之前)
    • 从JDK8.0开始，还可以访问所在方法的实际上的最终变量或参数（没有被final修饰但只进行了一次赋值的变量或参数）

    • 为什么是final或只进行了一次赋值的变量

      • 当方法执行完后，就会被销毁，包括局部变量，而局部内部类并不一定会被销毁，有可能还在执行相应方法，如果这时访问了外部方法中定义的局部变量，则访问不到
      • 为了解决这个矛盾，如果局部内部类中访问了所在方法的某个变量，就将该方法中的变量复制一份作为内部类的成员变量，当内部类访问所在方法中的变量时，就让它去访问复制出来的成员变量。这样在内部类所在方法中的变量消失的之后，仍然可以访问它，当然这里并不是真正地访问它，而是访问它的复制品
      • 由于是将局部内部类所在方法的变量复制一份作为局部内部类的成员变量，故在定义局部内部类之前，一定要对局部内部类所在方法的变量进行初始化，没有初始化是无法复制的
      • 为了保证复制得到的那一份成员变量的值和原来的局部变量的值相同。如果在外部类中修改了局部变量的值，那就要修改局部内部类中复制得到的那一份成员变量的值；如果在局部内部类中修改了复制得到的那一份成员变量的值，那就要修改外部类中局部变量的值（前提是这个局部变量还存在），这样做是非常困难的。于是Java干脆就不允许局部内部类要访问的局部变量的值发生改变，即局部内部类中只能访问所在方法的最终变量或实际上的最终变量

3.24.3 代码示例

  1. /**
  2.  * 内部类
  3.  */
  4. public class InnerClass {
  6.     public static void main(String[] args) {
  7.         new InnerClass().new MemberInnerClass().test();
  8.         new StaticMemberInnerClass().test();
  9.         new InnerClass().testMemberInnerClass();
  10.         new InnerClass().testLocalInnerClass(0);
  11.     }
  13.     // 外部类成员属性
  14.     int a = 1;
  15.     private int b = 2;
  16.     static int c = 3;
  18.     // 成员内部类
  19.     class MemberInnerClass {
  20.         int a = 4;
  21.         public void test(){
  22.             System.out.println("test MemberInnerClass");
  23.             System.out.println(a); // 4
  24.             System.out.println(b); // 2
  25.             System.out.println(c); // 3
  26.         }
  27.     }
  29.     // 静态成员内部类
  30.     static class StaticMemberInnerClass{
  31.         public void test(){
  32.             System.out.println("test StaticMemberInnerClass");
  33. //            System.out.println(a); // 无法访问非静态变量
  34. //            System.out.println(b); // 无法访问非静态变量
  35.             System.out.println(c); // 3
  36.         }
  37.     }
  39.     // 成员函数中访问内部类
  40.     public void testMemberInnerClass(){
  41.         MemberInnerClass memberInnerClass = new MemberInnerClass();
  42.         memberInnerClass.test();
  44.         StaticMemberInnerClass staticMemberInnerClass = new StaticMemberInnerClass();
  45.         staticMemberInnerClass.test();
  47.         // 不能访问 局部内部类
  48. //        LocalInnerClass localInnerClass = new LocalInnerClass();
  50.     }
  52.     // 成员函数中的局部内部类
  53.     public void testLocalInnerClass(final int i) {
  54.         int f = 5;
  55. //        f = 7; // 不能修改，只能进行一次赋值
  56.         final int g = 6;
  57.         // 定义局部内部类
  58.         class LocalInnerClass {
  59.             public void test() {
  60.                 System.out.println("test LocalInnerClass");
  61.                 System.out.println(i); // 0
  62.                 System.out.println(f); // 5
  63.                 System.out.println(g); // 6
  64. //                f = 7; // 不能修改，只能进行一次赋值
  65.             }
  66.             // 不能修改，只能进行一次赋值
  67. //            public void change(){
  68. //                f = 7;
  69. //            }
  70.         }
  71.         // 访问局部内部类，在局部访问
  72.         LocalInnerClass localInnerClass = new LocalInnerClass();
  73.         localInnerClass.test();
  74.     }
  75. }
  1. /**
  2.  * 内部类使用案例，技能类接口
  3.  */
  4. public interface Skill {
  5.     // 获取终极大招
  6.     String getBigSkill();
  7. }
  1. /**
  2.  * 内部类使用案例，第1种方式访问内部类
  3.  * 在成员方法中访问局部内部类
  4.  */
  5. public class TestInnerClass_01 {
  7.     public static void main(String[] args) {
  8.         new TestInnerClass_01().test();
  9.     }
  11.     public void test() {
  12.         class InnerSkill {
  13.             public void bigSkill() {
  14.                 System.out.println("终极大招...");
  15.             }
  16.         }
  18.         // 在成员方法中访问成员内部类
  19.         InnerSkill innerSkill = new InnerSkill();
  20.         innerSkill.bigSkill();
  21.     }
  22. }
  1. /**
  2.  * 内部类使用案例，第2种方式访问内部类
  3.  * 定义成员方法，返回封装的成员内部类实例
  4.  */
  5. public class TestInnerClass_02 {
  7.     public static void main(String[] args) {
  8.         TestInnerClass_02 testInnerClass_02 = new TestInnerClass_02();
  9.         Skill houYi = testInnerClass_02.getHouYi();
  10.         Skill liBai = testInnerClass_02.getLiBai();
  11.         System.out.println(houYi.getBigSkill());
  12.         System.out.println(liBai.getBigSkill());
  13.     }
  15.     private class HouYi implements Skill {
  16.         private String bigSkill = "后羿大招：火鸟之翼";
  18.         @Override
  19.         public String getBigSkill() {
  20.             return bigSkill;
  21.         }
  22.     }
  24.     private class LiBai implements Skill {
  25.         private String bigSkill = "李白大招：青莲剑歌";
  27.         @Override
  28.         public String getBigSkill() {
  29.             return bigSkill;
  30.         }
  31.     }
  33.     // 定义成员方法，返回封装的成员内部类实例
  34.     public Skill getHouYi() {
  35.         return new HouYi();
  36.     }
  38.     public Skill getLiBai() {
  39.         return new LiBai();
  40.     }
  41. }
  1. /**
  2.  * 内部类使用案例，第3种方式访问内部类
  3.  * 在方法中返回局部内部类实例
  4.  */
  5. public class TestInnerClass_03 {
  6.     public static void main(String[] args) {
  7.         Skill skill = new TestInnerClass_03().getSkill();
  8.         String bigSkill = skill.getBigSkill();
  9.         System.out.println(bigSkill);
  10.     }
  12.     public Skill getSkill() {
  13.         String skill = "我的技能...";
  15.         class Person implements Skill {
  17.             @Override
  18.             public String getBigSkill() {
  19.                 test();        // 访问局部内部类中的其他方法
  20.                 return skill;  // 访问外部方法中的变量
  21.             }
  23.             private void test() {
  24.                 System.out.println(skill + " + 1");
  25.             }
  26.         }
  28.         return new Person();
  29.     }
  30. }

3.25 Object类

3.25.1 简介

  • Ojbect是所有Java类的跟基类（祖先），如果在类中没有使用extends指明基类，则默认基类为Object类
  • Object类有一个默认构造方法pubilc Object()，在构造子类实例时， 都会先调用这个默认构造方法
  • 可以使用类型为Object的变量指向任意类型的对象（参考对象转型）
  • Object类的变量只能用作各种值的通用持有者，要对他们进行任何专 门的操作，都需要知道它们的原始类型并进行类型转换（参考对象转型）

3.25.2 常用方法

参考API文档

  • toString()方法

    • Object类中toString()方法，描述当前对象相关信息（类名和引用信息），返回值为String类型
    • 在进行String与其它类型数据的连接操作时，自动调用toString()方法
    • 可根据需要，重写toString()方法

  • equals()方法

    • 用来判断两个对象（不同的对象的属性值）是否相等，返回true或false
    • JDK一些常用类重写了该方法，如String，Date等类
    • 可以根据需要，重写equals()方法
    • 重写equals()方法时，需要同时重写hashCode()方法
    • Ojbect中equals()方法默认使用双等号来实现，并不能判断对象是否相等，所以需要时要重写

    • 与“==”关系：

      • “==”：比较的是基本数据类型的值，
      • 如果是引用数据类型，没有重写equals()方法前提下，两者都是比较对象的值（地址引用是否指向同一个对象）

  • hashCode()方法

    • 返回该对象的哈希代码值
    • 在 Java 应用程序执行期间，在对同一对象多次调用hashCode()方法时，必 须一致地返回相同的整数，前提是将对象进行equals比较时所用的信息没有 被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数 无需保持一致
    • 如果根据equals(Object)方法，两个对象是相等的，那么对这两个对象中的 每个对象调用hashCode方法都必须生成相同的整数结果
    • 如果根据equals(java.lang.Object)方法，两个对象不相等，那么对这两个 对象中的任一对象上调用hashCode方法不 要求一定生成不同的整数结果。 但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能

  • getClass()方法

    • 获取当前对象所属的类信息，返回Class对象
  1. // Object类中toString()的默认实现
  2. public String toString() {
  3.     return getClass().getName() + "@" + Integer.toHexString(hashCode());
  4. }
  6. // Object类中equals()的默认实现
  7. public boolean equals(Object obj) {
  8.     return (this == obj);
  9. }
  11. // Object类中hashCode()的默认实现
  12. public native int hashCode();
  14. // Object类中getClass()的默认实现
  15. public final native Class<?> getClass();

3.25.3 代码示例

  1. /**
  2.  * Object类相关操作
  3.  */
  4. public class ObjectClass {
  5.     public static void main(String[] args) {
  6.         Object obj = new TestToString(); // 多态特性
  7.         TestToString tts = new TestToString();
  8.         System.out.println(tts);
  9.         System.out.println(tts.toString());
  11.         TestEquals te = new TestEquals();
  12.         te.setName("jason");
  13.         te.setAge(18);
  14.         TestEquals te2 = new TestEquals();
  15.         te2.setName("jason");
  16.         te2.setAge(18);
  17.         System.out.println(te.equals(te2));
  19.         System.out.println(te.hashCode());
  20.         System.out.println(te2.hashCode());
  22.         String str = new String("jason");
  23.         String str2 = new String("jason");
  24.         System.out.println("str == str2 : " + str == str2); // false
  25.         System.out.println("str.equals(str2) : " + str.equals(str2)); // true
  27.         System.out.println(te.getClass());
  28.     }
  29. }
  31. class TestToString {
  32.     public String name;
  33.     public int age;
  35.     @Override
  36.     public String toString() {
  37.         return "TestToString{" +
  38.                 "name='" + name + '\'' +
  39.                 ", age=" + age +
  40.                 '}';
  41.     }
  42. }
  44. class TestEquals {
  45.     public String name;
  46.     public int age;
  48.     @Override
  49.     public boolean equals(Object o) {
  50.         System.out.println("调用了 -- equals(Object o)");
  51.         if (this == o) return true;
  52.         if (o == null || getClass() != o.getClass()) return false;
  53.         TestEquals that = (TestEquals) o;
  54.         return age == that.age &&
  55.                 name.equals(that.name);
  56.     }
  58.     @Override
  59.     public int hashCode() {
  60.         System.out.println("调用了 -- hashCode()");
  61.         return Objects.hash(name, age);
  62.     }
  64.     public String getName() {
  65.         return name;
  66.     }
  68.     public void setName(String name) {
  69.         this.name = name;
  70.     }
  72.     public int getAge() {
  73.         return age;
  74.     }
  76.     public void setAge(int age) {
  77.         this.age = age;
  78.     }
  79. }