java学习（自用）

文章目录

• • 变量
  • 数据类型
  • 类型转换
  • 运算符
  • 标识符
  • 键盘输入
  • 进制转换
  • 顺序控制
  • 一维数组
  • 二维数组
  • 类与对象
  • • • 成员方法（方法）
      • 重载
      • 构造方法/构造器
      • this关键字
  • 包
  • 访问修饰符
  • 封装
  • 继承
  • • • super关键字
      • • super和this的比较：
  • 方法重写/覆盖
  • • • • 重写和重载的比较：
  • 多态
  • • • • 对象的多态：
        • 动态绑定机制
  • Object类
  • • • • ==和equals的对比
        • hashCode
        • toString
        • finalize
  • 类变量和类方法
  • main方法
  • 代码块
  • • • • 类什么时候加载：
        • 创建对象时，调用顺序：
  • 单例设计模式
  • final关键字
  • 抽象类abstract
  • 接口interface
  • • • • 实现接口和继承类
  • 内部类
  • 枚举 注解
  • 异常
  • 常用类
  • 集合
  • • • • ArrayList和LinkedList比较
  • 泛型
  • 绘图
  • 线程

变量

• 内存中一个数据空间的表示
• 先声明后使用
• 三要素：变量名、值、数据类型

数据类型

• 基本数据类型

  • 数值型

    • 整数类型：byte[1],short[2],int[4],long[8]
    • 浮点类型：float[4],double[8]
      • 符号位、指数位、尾数位

  • 字符型：char[2]，单个字符

  • 布尔型：boolean[1]，true，false

• 引用数据类型

  • 类：class
  • 接口：interface
  • 数组：array[]

类型转换

• 自动
  • 精度小的自动转换成精度大的类型
  • 多种类型数据混合运算时，首先自动将所有数据转换成精度大的类型
  • byte，short和char之间不会相互自动转换；三者进行运算时会首先转换为int类型
  • boolean不参与转换
• 强制
  • 精度打的转换成精度小的类型，使用时要加上强制转换符()，但可能造成精度降低或者溢出
• String
  • 基本类型转换成String：值+“ “
  • String转换成基本类型：通过基本类型的包装类调用parseXX方法

运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
  • 短路与&&：如果第一个条件为false，则第二个条件不会判断
  • 逻辑与&：不管第一个条件是否为false，第二个条件都要判断
  • 短路或||：如果第一个条件为true，则第二个条件不会判断
  • 逻辑或|：不管第一个条件是否为true，第二个条件都要判断\
  • 逻辑非!：（取反）
  • 逻辑异或^：
• 赋值运算符
  • 左边只能是变量，右边可以是变量、表达式
  • 复合赋值运算符会进行类型转换
• 三元运算符
  • 条件表达式？表达式1：表达式2
  • 一真二假
• 位运算符
  • 算术右移>>：低位溢出符号位不变，并用符号位补溢出的高位
  • 算术左移<<：符号位不变，低位补0
  • 逻辑右移(无符号右移)>>>：低位溢出，高位补0

标识符

• 英文字母、数字、_、$组成
• 数字不可以开头
• 不可以使用关键字和保留字
• 严格区分大小写
• 不能包含空格

键盘输入

• Scanner scanner=new Scanner(System.in);
  

• 调用nextXX方法

进制转换

• 二进制
• 十进制
• 八进制：0开头
• 十六进制：0x或0X开头
• 原码、反码、补码
  • 正数三码合一
  • 负数反码=原码符号位不变，其他位取反；补码=反码+1；反码=补码-1

顺序控制

• 从上到下逐行地执行，中间没有任何的判断和跳转

• 分支控制

  • if-else

    • 单分支
    • 双分支
    • 多分支

  • switch

    • switch (表达式){
          case 常量1: 语句块1; break;
          ...
          default: default语句块; break;
      }
      

    • 没有写break，程序会顺序执行到结尾

  • 比较：判断的具体数值不多用switch，区间判断用if

• 循环控制

  • for
    • 四要素：循环变量初始、循环条件、循环操作、循环变量迭代
    • 化繁为简、先死后活
  • while
    • 循环条件是返回一个布尔值的表达式
    • 先判断再执行语句
  • do-while
    • 先执行、再判断，最后会有一个分号
  • 嵌套循环：一般建议使用两层

• 跳转控制

  • break
    • 退出最近的循环体
  • continue
    • 结束本次循环
  • return
    • 跳出所在的方法

一维数组

• 存放多个统一类型的数据

• 数组的定义：

  • 动态初始化

    • 数据类型 数组名[] = new 数据类型[大小];
      

    • 先声明再创建

      • 数据类型 数组名[];  数组名 = new 数据类型[大小];
        

      • 声明方式：int[] x; 或者 int x[];
        

  • 静态初始化

    • 数据类型 数组名[] = {元素值,元素值,...};
      

  • 数组创建后，如果没有赋值，会有默认值

  • 使用数组的步骤

    • 声明数组并开辟空间
    • 给数组各个元素赋值
    • 使用数组

  • 数组的下标是从零开始的，必须在指定的范围内使用

  • 数组是引用类型，数组型数据是对象（Object）

• 赋值机制

  • 基本数据类型赋值，这个值就是具体的数值，而且互不影响（值传递）
  • 数组在默认的情况下是引用传递，赋的值是地址（引用传递）

• 排序

• 查找

二维数组

• 数据类型 数组名[][] = new 数据类型[大小][大小];
  

• 声明方式

  • int[][] y; 或者 int[] y[]; 或者 int y[][];
    

• 二维数组实际上是由多个一维数组组成的，各个一维数组的长度可以相等，也可以不等

类与对象

• 利于数据的管理，效率高

• 类和对象的区别和联系

  • 类是抽象的，概念的，代表一类事物，是数据类型
  • 对象是具体的，实际的，代表一个具体事物
  • 类是对象的模板，对象是类的一个个体，对应一个实例

• 属性/成员变量

  • 成员变量是用来表示属性的

  • 属性是类的一个组成部分，一般是基本数据类型，也可是引用类型（对象，数组）

  • 属性的定义语法同变量

    • 访问修饰符 属性类型 属性名;
      

• 对象

  • 先声明再创建或者直接创建

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

• 成员方法（方法）

  • 当程序执行到方法时，就会开辟一个独立的空间（栈空间）

  • 好处：

    • 提高代码的复用性
    • 可以将实现的细节封装起来，供其他用户来调用

  • 方法的定义

    • 访问修饰符 返回数据类型 方法名 (形参列表) { //方法体
          语句;
          return 返回值;  //不是必须的
      }
      

    • 一个方法最多一个返回值，可以为任意类型

    • 一个方法可以有0或多个参数，调用时需要传入对应类型的参数；方法定义时的参数称为形式参数，方法调用时的参数称为实际参数

    • 方法体内不能再定义方法

  • 方法调用：

    • 同一个类中的方法：直接调用
    • 跨类中的方法：对象名调用
    • 基础类型传递的是数值；引用类型传递的时地址；若传入的是对象，并且置空，不会对原本的有影响

  • 递归

    • 执行一个方法时，会创建一个新的受保护的独立空间
    • 方法的局部变量时独立的
    • 如果方法中使用的时引用类型变量，就会共享该引用类型的数据

• 重载

  • 同一个类中，多个同名方法存在，但要求形参列表不一致
  • 减轻了起名的麻烦，减轻了记名的麻烦
  • 方法名必须相同，形参列表必须不同，返回类型无要求

• 可变参数

  • 将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法

  • public int sum(int... nums){//nums可以当成数组
        return 0;
    }
    

  • 可变参数的实参可以是0或任意多，可以为数组

  • 可变参数的本质就是数组

  • 一个形参列表中只能出现一个可变参数；与普通类型参数放一起，必须保证可变参数在后

• 作用域

  • 全局变量：属性，作用域为整个类体
  • 局部变量：除属性之外的其他变量，一般指成员方法中定义的变量，作用域为定义它的代码块中
    • 全局变量可以不赋值，直接使用；局部变量必须赋值后，才能使用
    • 全局变量和局部变量可以重名，遵循就近原则；在同一个作用域中不能重名
    • 生命周期不同：全局变量生命周期长；局部变量生命周期短
    • 作用域范围不同：全局变量可以被本类使用，或其他类使用（通过对象调用）；局部变量只能在本类中对应的方法使用
    • 修饰符不同：全局变量可以加修饰符；局部变量不可以

• 构造方法/构造器

  • 是类的一种特殊方法，主要作用完成对新对象的初始化

  • [修饰符] 方法名(形参列表){
        方法体;
    }
    

  • 没有返回值

  • 方法名和类名必须一致

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

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

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

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

  • 如果没有定义构造器，系统会自动给类生成一个默认的无参构造器（默认的构造方法）；一旦定义了，默认的就会被覆盖，不能再使用，除非显示定义一下

  • 对象流程分析：

    • 加载类信息，只会加载一次
    • 在堆中分配空间（地址）
    • 完成对象初始化
      • 默认初始化
      • 显式初始化
      • 构造器初始化
    • 对象在堆中的地址返回给对象名（对象的引用）

• this关键字

  • 加上this，就是当前对象的属性；哪个对象调用，就代表哪个对象

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

  • this用于区分当前类的属性和局部变量

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

  • 访问成员方法的语法：

    • this.方法名(参数列表);
      

  • 访问构造器语法：（只能在构造器中使用，放第一条语句）

    • this(参数列表);
      

包

• 不同包下可同名类
• 命名：只能包含数字、字母、下划线、小圆点，不能数字开头，不能关键字或保留字
• package的作用：声明当前类所在的包，在最上
• import的作用：导入包，放在package的下面

访问修饰符

• 用于控制方法和属性的访问权限。四种：
  • 公开级别：public修饰，对外公开
  • 受保护级别：protected修饰，对子类和同一个包中的类公开，不同包不可访问
  • 默认级别：没有修饰符，对同一个类、包公开，子类和不同包不可访问
  • 私有级别：private修饰，只有类本身可以访问，不对外公开
• 只有默认的和public才能修饰类

封装

• 面向对象特征之一
• 把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，只有通过被授权的操作（方法），才能对数据进行操作
• 好处：隐藏实现细节；可以对数据进行验证，保证安全合理
• 步骤
  • 将属性进行私有化 private
  • 提供一个公共的（public）set方法，用于对属性判断赋值
  • 提供一个公共的（public）get方法，用于获取属性的值

继承

• 面向对象特征之一

• 当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类只需要extends来声明继承父类即可

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

• 好处：代码复用性提高了；代码的扩展性和维护性提高了

• 细节：

  • 子类继承所有属性和方法，但是私有属性不能直接访问
  • 子类必须调用父类构造器，完成父类的初始化
  • 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器；如果父类没有提供无参构造器，则必须在子类的构造器中用super去值定使用父类的哪个构造器完成对父类的初始化工作
  • super和this不能同时使用
  • Java所有类都是Object类的子类；父类构造器的调用不限于父类，可以追溯到Object类
  • 子类最多继承一个父类（直接继承），单继承机制；不能滥用继承
  • 返回信息：
    • 首先看子类是否有该属性
    • 如果子类有这个属性，并且可以访问，则返回信息
    • 如果子类没有这个属性，查看父类有没有这个属性，直到Object

• super关键字

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

• super和this的比较：

  • 访问属性：this访问本类中属性，若没有，则从父类继续查找；super访问父类中属性
  • 调用方法：this访问本类中的方法，若没有，则从父类继续查找；super直接访问父类中的方法
  • 调用构造器：this调用本类的构造器，必须放在构造器的首行；super调用父类构造器，必须放在子类构造器的首行
  • 特殊：this表示当前对象；super子类中访问父类对象

方法重写/覆盖

• 子类有一个方法和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法

• 子类方法的形参列表、方法名称和父类方法完全一样

• 返回类型一样；或是父类返回类型的子类，如父类返回类型Object，子类是String

• 子类方法不能缩小父类方法的访问权限

• 重写和重载的比较：

  • 重载在本类，方法名必须一样，形参列表不同
  • 重写在父子类，方法名一样，形参列表相同，返回类型一致或者是其子类，子类方法不能缩小父类方法的访问范围（修饰符）

多态

• 面向对象的特征之一

• 方法或对象具有多种形态，建立在封装和继承之上的

• 方法的多态：

  • 重写和重载体现多态

• 对象的多态：

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

• 细节：

  • 多态的前提：两个对象（类）存在继承关系

  • 多态的向上转型

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

    • 语法：

      • 父类类型 引用名 =new 子类类型();
        

    • 特点：

      • 编译阶段：可以调用父类所有成员（遵循访问类型）；不能调用子类中特有成员
      • 运行阶段：最终运行效果看子类的具体实现，即调用方法时，按照从子类开始查找方法然后调用

  • 多态的向下转型

    • 语法：

      • 子类类型 引用名 = （子类类型）父类引用;
        

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

    • 要求父类的引用必须指向的是当前目标类型的对象

    • 可以调用子类类型中所有成员

• 细节：

  • 属性没有重写之说！属性的值看编译类型
  • instanceOf比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

• 动态绑定机制

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

• 多态的应用：

  • 多态数组
    • 数组的定义类型为父类类型，里面保存的实际元素为子类类型
  • 多态参数
    • 方法定义的参数类型为父类类型，实参类型允许为子类类型

Object类

• ==和equals的对比

  • ==（比较运算符）既可判断基本类型（判断的是值是否相等），又可判断引用类型（判断的是地址是否相等，即判断是不是同一对象）
  • equals（Object类的方法）只判断引用类型，默认判断的是地址是否相等，子类往往重写该方法，用于判断内容是否相等如String，Integer

• hashCode

  • 提高具有哈希结构的容器的效率
  • 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
  • 两个引用，如果指向的是不同对象，则哈希值不一样
  • 哈希值主要根据地址号来的，但不等价于地址
  • 集合中有需要的话也会重写

• toString

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

• finalize

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

类变量和类方法

• 类变量

  • static变量是同一个类所有对象共享；static类变量在类加载的时候就生成了

  • 类变量也叫静态变量，该类对象都可以去读取和修改

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

  • 访问：类名.类变量名（推荐） 或 对象名.类变量名

  • 细节：

    • 类变量和实例变量（普通属性）区别：
      • 类变量是该类的所有对象共享的；实例变量是每个对象共享的
    • 实例变量不能通过类名.变量名访问
    • 类变量在类加载时就初始化了，也就是说，即使没有创建对象，只要类加载了，也可以使用类变量
    • 声明周期随类的加载开始，随着类的消亡而销毁

• 类方法

  • 也叫静态方法

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

  • 调用：类名.方法名 或 对象名.方法名

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

  • 细节：

    • 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区；类方法中无this的参数，普通方法中隐含着this的参数
    • 普通方法和对象有关，需要通过对象名调用，不能通过类名调用
    • 类方法中不允许使用和对象有关的关键字，比如this和super。普通方法可以
    • 类方法中只能访问静态变量和静态方法；普通成员方法既可以访问普通变量（方法），也可访问静态变量（方法）
    • 静态方法只能访问静态的成员，非静态方法可以访问静态成员和非静态成员

main方法

• main方法java虚拟机调用，所以访问权限必须是public

• java虚拟机在执行main方法时不必创建对象，所以该方法的访问权限必须时static

• 该方法接收String类型的数组参数，该数据保存执行java命令时传递给所以运行的类的参数

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

• main中可直接调用所在类的静态方法或静态属性；但不能直接访问该类非静态成员，必须创建对象，才能通过这个对象区访问

代码块

• 又称初始化块，属于类中的成员，类似于方法，但没有方法名、没有返回、没有参数，只有方法体；不能通过对象或类显示调用，而是加载类时，或创建对象时隐式调用

• 好处：

  • 相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化操作；代码块调用顺序优先于构造器
  • 如果多个构造器中都要重复的语句，可以抽取到初始化块中，提高代码的重用性

• static代码块也叫静态代码块，随着类的加载而执行，只会执行一次；普通代码块，没创建一个对象执行一次

• 类什么时候加载：

  • 创建对象实例时
  • 创建子类对象实例，父类也会被加载
  • 使用类的静态成员时

• 普通代码块在调用类的静态成员时不加载

• 创建对象时，调用顺序：

  • 静态代码块和静态属性初始化（按照定义顺序执行）
  • 普通代码块和普通属性初始化（按照定义顺序执行）
  • 调用构造器

• 创建子类对象时，构造方法调用顺序：

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

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

单例设计模式

• 设计模式是静态方法和属性的经典使用，是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式
• 单例模式：就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
• 两种：饿汉式、懒汉式
  • 饿汉式：（创建了对象，可能没有使用）
    • 构造器私有化
    • 类的内部创建对象（static）
    • 向外提供一个static的公共方法，返回对象
  • 懒汉式：（只有使用时才创建对象）
    • 构造器私有化
    • 定义一个static静态属性对象，不创建
    • 提供一个公共的static方法，（使用时创建对象）返回对象
  • 区别
    • 创建对象的时机不同：饿汉式是在类加载就创建对象实例；懒汉式是在使用时创建
    • 懒汉式存在线程安全问题；饿汉式不存在
    • 饿汉式存在浪费资源问题
  • javaSE标准类中，java.lang.Runtime就是经典的单例模式

final关键字

• final可以修饰类、属性、方法和局部变量
• 使用final修饰的情况：
  • 当不希望类被继承时
  • 当不希望父类的某个方法被子类覆盖/重写时
  • 当不希望类的某个属性的值被修改
  • 当不希望某个局部变量被修改
• 细节：
  • final修饰的属性一般叫常量
  • 修饰的属性在定义时必须赋初值，赋值位置：
    • 定义时
    • 构造器中
    • 代码块中
  • 若修饰的属性是静态的，则初始化的位置只能是定义时或静态代码块中
  • final类不能被继承，但是可以实例化
  • 如果类不是final类，final方法虽不能重写，但可以被继承
  • 一般来说，若一个类是final类，则方法没有必要再修饰成final方法
  • final不能修饰构造方法
  • final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理
  • 包装类（Integer，Double，Float，Boolean等），String也是final类

抽象类abstract

• 当父类的某些方法需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类
• 抽象方法就是没有实现的方法，没有方法体
• 抽象类会被继承，子类必须实现所有的抽象方法，除非它自己也声明为抽象类
• 抽象类不能被实例化
• 抽象类不一定包含abstract方法；一旦包含abstract方法，则这个类必须声明为abstract
• abstract只修饰类和方法，不修饰属性和其它的
• 抽象类可以有任意成员
• 抽象方法不能使用private、final和static来修饰，因为这些关键字和重写相违背
• 抽象模板模式

接口interface

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

• 语法：

  • interface 接口名{
        //属性
        //方法	}
    

  • class 类名 implements 接口{
        自己属性;
        自己方法;
        必须实现接口的抽象方法	}
    

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

• 细节：

  • 接口不能实例化
  • 接口中所有方法是public方法，抽象方法可以不用abstract修饰
  • 一个普通类实现接口，必须将接口的所有方法都实现
  • 抽象类实现接口，可以不用实现接口的方法
  • 一个类可以实现多个接口
  • 接口中的属性，等价于final，而且是public static final修饰符
  • 接口属性的访问形式：接口名.属性名
  • 一个接口不能继承其他的类，但是可以继承多个别的接口
  • 接口的修饰符只能是public和默认，这点和类的修饰符是一样的

• 实现接口和继承类

  • 解决的问题不同
    • 继承：解决代码的复用性和可维护性
    • 接口：设计，设计好各种规范（方法），让其它类去实现这些方法
  • 接口比继承更灵活
    • 继承是满足is-a的关系；接口时like-a的关系
  • 接口在一定程度上实现代码解耦[即：接口规范性+动态绑定]

• 接口多态

  • 多态参数
    • 接口类型的变量可以指向实现了接口类的对象实例
  • 多态数组
  • 接口存在多态传递现象

内部类

• 类的内部又完整的嵌套另一个类的结构
• 类五大成员：属性、方法、构造器、代码块、内部类
• 特点：可以访问私有属性，可以体现类与类之间的关系
• 局部内部类：
  • 定义在外部类的局部位置，比如方法中
  • 可以直接访问外部类所有成员，包含私有
  • 不能添加访问修饰符，但可以使用final修饰
  • 作用域：仅仅在定义它的方法或代码块中
  • 外部类访问局部类成员需要创建对象再访问（必须在作用域内）
  • 外部其他类不能访问
  • 若外部类和局部内部类成员重名时，遵循就近原则，想访问外部类成员使用 外部类.this.成员
• 匿名内部类
  • 没有类名；使用一次就不能再使用
  • 既有定义类的特征，也有创建对象的特征
• 成员内部类
  • 定义再外部类的成员位置，没有static修饰
  • 可以添加任意访问修饰符
  • 再外部类的成员方法中创建成员内部类对象，再调用方法
• 静态内部类
  • 外部类成员位置，static修饰
  • 可以访问所有外部类静态成员，包含私有的，不能访问非静态
  • 可以添加任意访问修饰符
  • 作用域：整个类体
  • 外部其他类可以通过类名直接访问

枚举 注解

• 枚举类
  • 一组常量的集合；属于一种特殊的类，里面只包含一组有限的特定的对象
  • 自定义枚举
    • 不提供setXx方法；对枚举对象/属性使用final+static修饰，实现底层优化
  • enum枚举类
    • 使用enum关键字后，不能继承其他类，隐式继承Enum；可实现接口
• 注解
  • @Override：限定某个方法，是重写父类的方法，该注解只用于方法
  • @Deprecated：表示某个程序元素已过时；不推荐使用，但仍可使用
  • @Suppress Warnings：抑制编译器警告

异常

• 异常：程序执行中发生的不正常情况（语法错误和逻辑错误不是异常）
• 两类：
  • Error（错误）：Java虚拟机无法解决的严重问题
  • Exception：其它因编程错误或偶然的外在因素导致的一般问题
    • 运行时异常：
    • 编译时异常：
• 异常处理：
  • try-catch-finally： catch代码块发生异常执行；finally代码块始终执行
  • throws：声明方法异常但不处理，由该方法的调用者处理；throws后面的异常类型可以是方法中产生的异常类型，也可以时它的父类
  • 自定义异常：

常用类

• 包装类
  • 装箱：基本类型->包装类型；反之，拆箱
  • 自动装箱底层（隐式）调用的时 valueOf方法
• String、String Buffer、String Builder
• Math
• Arrays：管理操作数组
  • toString方法：返回数组的字符串形式
  • sort方法：排序
  • binarySearch：通过二分搜索法进行查找，有序情况下
  • copyOf：数组元素的复制
  • fill：数组元素的填充
  • equals：比较两个数组元素内容
  • asList：将一组值，转换成list
• System类
• Big Integer和Big Decimal类
  • Big Integer适合保存较大的整型
  • Big Decimal适合保存精度更高的浮点型
• Date

集合

• 可以动态保存任意多个对象，使用方便

• 两大类：Collection和Map

  • Collection：

    • 子接口 List、Set，它们的实现子类都是单例集合

    • collection接口实现类的特点：

      • 可以存放多个元素，每个元素可以是Object
      • 有些可以存放重复的元素
      • 有些是有序的（List），有些是无序的（Set）
      • Collection接口没有直接的实现子类，是通过它子接口Set和List来实现的

    • collection接口常用方法，以实现子类：

      • add：添加单个元素；addAll：添加多个元素
      • remove：删除指定元素；removeAll：删除多个元素
      • contains：查找元素是否存在；containsAll：查找多个元素是否都存在
      • size：获取元素个数
      • isEmpty：判断是否为空
      • clear：清空

    • 迭代器遍历：Iterator

      • Iterator对象称为迭代器，主要用于遍历Collection集合中的元素；本身不存放对象

      • 所有实现了collection接口的集合类都要一个Iterator方法，用于返回一个实现了Iterator接口的对象，即返回一个迭代器

      • Iterator iterator=collation.iterator();
        while(iterator.hasNext()){//判断下一个是否空
            System.out.println(iterator.next());//下移，将下移后的元素返回
        }
        

    • List接口

      • List集合类中的元素有序（添加顺序和取出顺序一样），且可重复

      • 支持索引，每个元素都有其对应的索引，调用get方法

      • 接口实现类：常用的有ArrayList、LinkedList、Vector

      • 三种遍历方式：使用iterator、增强for、普通for

      • ArrayList：

        • 是由数组实现数据存储的
        • 基本等同于Vector，但ArrayList是线程不安全的，多线程情况下不推荐
        • 底层操作机制分析：

      • Vector：

        • 底层是一个对象数组
        • 线程同步的，即线程安全；Vector类的操作方法带有synchronized

      • LinkedList：

        • 底层实现了双向链表和双端队列特点
        • 可以添加任意元素
        • 线程不安全，没有实现同步

      • ArrayList和LinkedList比较

        • ArrayList改查的效率高；LinkedList增删的效率高

    • Set接口

      • 常用方法和Collection接口一样；遍历方式也一样，不能使用索引方式获取
      • HashSet：
        • 实际上是HashMap
        • 可以存放null值，但只能有一个；无序的；不可以有重复的元素/对象
        • 底层机制说明：
          • 添加一个元素时，先得到hash值，会转换成一个索引值
          • 如果索引值所在位置没有其他元素，则直接存放；如果有元素，则需要调用equals比较，如果相等，则不添加，如果不相等，则添加到最后
      • LinkedHashSet：
        • 是HashSet的子类；底层是一个LinkedHashMap；底层维护了一个数组+双向链表
        • 根据元素的hashcode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以拆入顺序保存的
        • 不允许添加重复元素

  • Map:

    • 实现子类时双例集合，存放Key-Value；key和value可以是任何引用类型的数据，会封装到HashMap￥Node对象中

    • key不允许重复，可以为null并且只能一个；value可以重复，可以多个为null

    • 常用的String类作为Map的key

    • key和value之间存在单向的一对一关系，即通过指定的key总能找到对应value

    • 一对key-value存放再一个Node中，因为Node实现了Entry接口，也有书上说一对k-v是一个Entry

      • Set set = map.entrySet();
        System.out.println(set.getClass());
        for (Object obj : set) {
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "-" + entry.getValue());
        }
        

    • Map接口方法：

      • put：添加
      • remove：根据键删除映射关系
      • get：根据键获取值
      • size：获取元素个数
      • isEmpty：判断个数是否为0
      • clear：清除
      • containsKey：查找键是否存在
      • keySet：取出所有的key
      • values：取出所有的value
      • entrySet：获取所有关系k-v

    • 六种遍历方式：

      • 键遍历：通过key，取出对应的value
        • 增强for；迭代器
      • 值遍历：把所有的value取出
        • collection遍历方法
      • 通过entrySet来获取k-v
        • 增强for；迭代器

    • Map实现类：HashMap、HashTable、Properties

      • HashMap没有实现同步，因此是线程不安全的，方法中没有做同步互斥操作；HashMap底层（jdk8的）数组+链表+红黑树
      • HashTable：
        • k-v都不能为null，使用方法与hashmap一样；是线程安全的；没有hashmap效率高
      • Properties：
        • 继承自hashtable类并实现了Map接口，也是使用一种键值对的形式来保存数据
        • 特点与Hashtable类似
        • xxx.properties文件通常作为配置文件

  • 如何选择集合：

    • 

• Collection工具类：

泛型

• 如：  ArrayList<类型> arrayList=new ArrayList<类型>();
  

• 好处：

• • 编译时，检查添加元素的类型，提高了安全性
  • 减少了类型转换的次数，提高效率

• 泛型：（只能是引用类型）参数化类型，解决数据类型的安全性问题；再类声明和实例化时只需要制定好需要的具体类型就可

• 作用：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型

  • class Person<E>{
        E s;
        public Person(E s) {   this.s = s;    }
        public E f(){  return s;     }
    }
    

绘图

• 例：画圆
  public class DrawCircle extends JFrame {//窗口
      private MyPanel myPanel = null;
      public static void main(String[] args) {
          new DrawCircle();    
      }
  
      public DrawCircle() {
          myPanel = new MyPanel();//初始化面板
          this.add(myPanel);//面板放窗口
          this.setSize(400, 300);//窗口大小
          this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//点×退出程序
          this.setVisible(true);//可以显示    }
  }
  
  class MyPanel extends JPanel {//画板
      @Override
      public void paint(Graphics g) {//Graphics 画笔，提供了很多绘画方法
          super.paint(g);
          g.drawOval(10, 10, 100, 100);//画个圆    }
  }
  

• paint(Graphics g)：绘制组件外观 ； 当组件第一次屏幕显示时，自动调用

  • 调用情况：
    • 窗口最小化再最大化；窗口大小发生变化；repaint函数被调用

• repaint()：刷新组件外观

• Graphics类：

  • 

线程