Java 基础部分

Java

一 语言环境与开发工具

1.了解 Java 的语言背景

1. Java（ 1995年诞生，James Cosling ）
2. 三个版本：
   • JavaSE（标准版本）
   • JavaEE（企业版本）
   • JavaME（微型版本）
3. Java 语言特点：跨平台性
   • 编写一个程序，只需要一次的编译，就能够在各大平台运行。（一次编译，到处运行）

2.掌握搭建 Java 开发环境

1. Java 的源程序：xx.java
   • 编译：可以用 javac.exe 来编译（安装了 JDK 以后就会有 javac 这个程序）
   • 执行：可以用 java.exe 来编译（安装了 JDK 以后就会有 java 这个程序）
2. Java 开发环境
   • 记事本+JDK
   • idea / eclipse / myeclipse
3. 安装 JDK
   • 找到 JDK 的安装文件
     
4. 配置环境变量
   
   需要在电脑的任意目录都能够找到 javac.exe 这个程序，只能通过配置环境变量来实现
   • path：记录了我们 windows 能够处理的程序的路径
     
5. JAD 软件：可以将 xxx.class -> xx.java

3.了解 Java 程序结构，并能够开发 Java 程序

4.掌握 JDK，JRE，JVM 等常用概念

1. JDK：java development took kit（ Java 开发工具包 ），安装以后可以用来开发 Java 程序，还可以执行 Java 程序
2. JRE：Java 的运行环境（里面包含有 JVM ）

二 变量，数据类型和运算符

1.变量

1. 3.14（常量）
2. x：变量 x+y=20，x-y=10
   x+y=20,x=1,2,3,4,5,6,7,8,9…，y=19,18,17,16…
3. 计算机中的变量
   • 数据存放到计算机中，就是需要一个存储的空间（磁盘（具备持久性），内存（临时的））
   • 变量：就会计算中的内存的一个区域，作用就是为了存放临时数据
   • 变量名：通过变量名去找内存区域
   • 变量类型

2.数据类型

8种基本的数据类型

数据类型名	长度	范围	默认值
byte	1 byte（8个二进制位）	-158~127	0
short	2 byte	-32768~32767	0
int	4 byte	-2,147,483,648~2,147,483,647	0
long	8 byte		0
float	4 byte	2^128	0.0f
double	8 byte	2^1024	0.0d
char	2 byte		‘\u0000’
boolean	1 byte		false

1. 整数类型：byte > short > int > long
   • l / L 表示 long 类型
2. 浮点类型（小数类型）
   • float
   • double
3. 字符类型

   • char

       计算机是无法表示字符的
       人们就是发明了一种字符和数字的对应关系
       65 -> A
       66 -> B
       97 -> a
       从而形成一种编码，最早的编码就是 ASCII 编码
       因为 ASCII 编码存放不了中文，就出现了 GBK，GB2312，UTF-8 等编码，能够存放中文，以及阿拉伯文等世界上的各种语言
     

4. 布尔类型
   • boolean
     • true/false：真/假

3.运算符

1. 赋值运算符
   • = , += , -= , *= , /= , %=
2. 算术运算符

   • + , - , * , / , % , ++ , –

       i++;
       ++i;
       
       当单独使用的时候，++i，i++：都等同于 i=i+1
       
       当组合使用的时候：
       	int i=12;
       	int c=i++;
       	首先执行赋值操作，将 i 的值赋值给 c ，然后执行 i++
       	c：12
       	
       	int i=12;
       	int c=++i;
       	首先执行 ++ 操作，然后执行赋值操作
       	c：13
     

3. 关系运算符
   • > , < , == , >= , <= , !=
     返回的结果只有 true/false
4. 逻辑运算符
   • && , || , !
5. 位运算符
   • >> , << , & , | , ^ , ~
     • >> , << ：可以对一个数进行乘除法，使用移位，绕过了 jvm 的乘法指令，速度快（先将一个数转化为二进制，然后进行移动）
     • & ：按位与
       同为 1 ，则结果为 1
     • | ：按位或
       只要有一个 1 ，则结果为 1
     • ^ ：按位异或
       同则为 0 ，不同则为 1
     • ~ ：按位取反
6. 三元运算符
   判断条件?表达式1:表达式2;

4.程序逻辑

资料
Java基础语法（讲课笔记）.pdf
第四章 程序入门之复杂选择结构.pptx
第五章 程序入门之循环结构（一）.pptx

1. 顺序结构
2. 分支结构
   • 单独分支
     • if…else
   • 多分支
     • if…else if…else if…else
   • switch…case
     • switch(变量)
       变量：int,short,byte,char,String,枚举类型( enum )
3. 循环结构
   • 循环的含义：重复地完成固定的事情
   • 循环的四要素：
     • 初始化条件
     • 循环条件——>是 boolean 类型
     • 循环体
     • 迭代条件
   • 循环的基本结构

     • for 循环

         for(int i=0;i<10;i++){
         	循环体;
         }
         
         i：循环变量
         i++：迭代条件
         i 的作用：控制循环体执行的次数
       

     • while 循环

     • do…while 循环

     • for…each 循环（处理数组的）

三 Java 方法（函数）

1. 方法介绍

   • 方法==函数==一个功能

     System.out.println("字符串");	// 能够输出一个字符串的值在控制台上
     int n=random.nextInt(10);	// 能够产生一个 10 以内的随机数，还能将这个随机数返回给 n 变量
     

   • 一个方法==一个功能

     // 这也是一个方法==函数
     // 这个方法是系统的默认方法，当程序运行的时候自动的会去调用这个方法
     
     public static void main(String[] args){
     
     }
     

   • 当程序需要实现一个项目的时候，系统的功能就比较多。此时需要将系统按照功能模块进行划分，每个小功能就可以编写为一个方法

2. 方法定义

    修饰符( public static ) 返回类型(void,int...) 方法名(参数){
    	方法体;
    }
   

3. 方法调用

   • 在别的方法中书写方法的名称就可以调用了。例如：方法名();

4. 方法的参数

5. 方法的返回值

6. 递归调用

   • 自己调用自己

四 Java 数组

1.数组的作用

1. 当我们需要定义多个相同类型的变量的时候，常规定义就有问题，很难定义，即使你定义了，也很难操作
2. 我们可以使用数组来解决，数组就是一个连续的内存空间

2.数组的定义

1. 声明数组

   int[] a;
   

2. 分配空间

   a=new int[10];	// 占 40 byte
   

3. 向数组的元素赋值

   a[0]=100;
   a[1]=200;
   

4. 对数组中的元素做一些操作

   a[0]=a[0]%10;
   

5. 数组中的常用定义方法

    变量名[] 数组名=new 变量名[数组的长度];
    
    int[] arr=new int[10];
    int[] arr=new int[]{1,2,3,4,5};
    int[] arr={1,2,3,4,5};
    
    String[] menus={
    	"1.用户管理",
    	"2.产品管理",
    	"3.订单管理"
    };
    
    int[] arr2;
    arr2=new int[5];
   

6. 数组的内存分配图
   

3.数组的常用算法

1. 遍历

   • 使用循环将数组的每个元素都访问一次

   • 增强 for 循环：for…each

       for(数组的类型 临时变量名 : 数组名){
       	操作临时变量名;
       }
     

2. 求最值

3. 插入（在一个已经有序的数组中插入一个元素，仍然保持数组的有序性）

4. 删除

5. 查找

   • 顺序查找
   • 二分查找

6. 排序

   资料
   八大排序算法
   数据结构与算法分析 Java语言描述（原书第3版）
   附录：排序算法
   Java数组3

4.Java 多维数组

1. 二维数组

   • 了解二维数组的使用场景
     • 游戏中的地图
     • 数学计算（矩阵）
   • 掌握二维数组的定义
   • 掌握二维数组的遍历
   • 常见的算法
     • 杨辉三角
     • 鞍点

2. 二维数组的定义

    int[][] arr=new int[5][6]; 
    
    第一个中括号表示的是行
    第二个中括号表示的是列
    
    数组的默认值：0
   

   静态定义二维数组

    int[][] arr=new int[][]{
    				{1},
    				{1,2},
    				{1,2,3},
    				{1,2,3,4},
    				{1,2,3,4,5}
    };
   
    int[][] arr=new int[5][];
    System.out.println(arr.length);	// 5
    
    // 这种定义是非法的
    int[][] arr=new int[][5];
    System.out.println(arr.length);	// 前面编译错误
   

   

五 Java 面向对象

资料
oop.doc
类和对象.ppt

1.Java 面向对象基础

1. 面向对象编程思想
   编程思维

   • 面向过程编程

     1. 解决一个问题：将一个大问题分解为若干的小的问题
     2. 编程解决一个问题：将一个大问题分解为若干的小的问题，把每个小问题写成一个个的函数
        

   • 面向对象编程

     1. 只需要修改应当修改的地方（可维护性）
     2. 可扩展性（代码可以随时的扩展新的功能）
     3. 可移植性
     4. 灵活性好

   • 现代软件的特点就是需求是随时变化的（回答为什么需要面向对象编程时可以往这里靠）

   • oop( object oriented program )中：开闭原则（ OCP ）（对于扩展开放，对于修改关闭）

2. 类
   1. 面向对象编程的基本步骤：
      • 找对象
      • 确定对象的属性
      • 确定对象的行为
      • 确定对象之间如何交互
   2. 具有相同属性和行为的一类对象组成了一个类别，一个类
   3. 类就是一个模具
   4. 类：就是一种自定义的数据类型
   5. 类的组成部分
      • 属性
      • 方法（行为）
3. 对象
   对象的内存分析图
   
   对象：类的具体化

2.面向对象编程

1. 构造函数（方法）（重点）Constructor

   1. 什么是构造方法
      构造方法是没有返回类型的方法，方法名与类名相同
   2. 有什么用
      构造方法不能被主动调用，只能被动的调用
      构造方法是 new 对象() 的时候自动调用的
      适合于做一些对象的初始化工作
   3. 如何编写
      构造方法如果你没有编写，那么编译器会为类自动加上一个默认的构造方法（没有参数的）
      new 类名()
      当你编写了一个构造方法以后，那个默认的就没有了
   4. 在哪里会使用
      当为一个类写多个构造方法的时候，就形成了重载（ overload ）

2. 引用类型

    基本的数据类型：都是在栈中分配的内存
    int a;
    double b;
   
    对象类型：在堆中会分配一个空间，然后用栈中的变量去指向
    所有的对象类型都是引用类型
    Student st=new Student();
   

3. 方法的重载（ overload ）

4. 对象数组

   // 将多个对象放入到数组中，目的是为了方便操作（遍历，搜索，排序，查找）
   Student[] arr=new Student[5];
   

   数组中存放的是对象的地址，不是整个对象
   

5. 注意点

   • “this(形参列表)” 必须声明在类的构造器的首行
   • 在类的一个构造器中，最多只能声明一个 “this(形参列表)”
   • 构造器中不能通过"this(形参列表)"的方式调用自己
   • 如果一个类中声明了n个构造器，则最多有 n-1 个构造器中使用了 “this(形参列表)”
   • 如果子类和父类中出现了同名的属性，那么我们如果在子类中调用父类中同名的属性的话，必须使用 “super.” 的方式；说明：子类的属性不会覆盖父类中同名属性。在堆空间中，两个属性都会存在
   • 在子类的构造器的首行，显示的使用“super(形参列表)”的方式，调用父类指定的构造器
   • 在子类的构造器的首行，要么使用 “this(形参列表)” ,要么使用 “super(形参列表)”，不能同时出现
   • 在子类构造器的首行，既没显式的使用 “this(形参列表)”，也没显式的使用 “super(形参列表)”，那么默认提供的是：“super()”
   • 在子类的多个构造器中，至少一个构造器的首行使用了 “super(形参列表)”

3.面向对象之重载与封装

1. 重载 overload
   在类中定义方法的时候，需要定义多个同名的方法，参数不同
   参数不同：

   1. 参数的类型不同

   2. 参数的顺序不同

   3. 参数的个数不同

       当我们编写代码的时候，发现很多方法功能类似但是参数不一致，这时候就可以使用重载了
       
       重载：实现了一种多态的效果（是一种静态的多态）
       
       注意：返回类型不构成重载的必要条件（下面两个构成重载）
       	public void cook(Chicken chicken){
       		
       	}
       	public int cook(Water water){
       	
       	}
      

2. 封装
   面向对象编程有三个重要的特征：

   • 封装
   • 继承
   • 多态

   封装：将一些属性，行为包在一个类中，形成了一种封装

    class Temp{
    	属性
    	
    	构造方法
    	
    	方法
    }
    
    public void sendEmail(Message message){
    
    }
    Message{
    	发送者，接收者，消息标题，消息的正文，发送时间，发送的 ip 地址
    }
   

   封装的第二个层次：封装可以实现消息的隐藏和保护

   • 修饰符
     • private
       修饰我们的成员以后，只有类自身可以访问，别的类是不能访问私有成员的，从而实现了消息的隐藏
       然后提供一个公有的 setter 方法，用于对这个私有的成员赋值，从而达到保护的效果
     • public
       方法公有

3. 属性默认值
   类产生对象的时候，类中的那些属性是有默认值的
   
   

数据类型	初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0D
boolean	false
char	‘’
String	null

4.面向对象之继承

资料
Java面向对象之继承…pdf

1. 注意点
   • 不管父类中的属性或方法的权限为何，子类都可以获取到，但是由于封装性的影响，可能在子类中不能直接调用父类中权限较小的属性或方法

5.面向对象之多态

1. 重写（ override ）和多态
   • 重载：实现了静态的多态
     一个类中有多个同名方法
   • 重写：
     • 必须有继承
     • 子类将父类继承过来的方法重新编写
     • 用父类变量指向子类的对象
     • 父类变量调用方法的时候就是多态了
2. 多态需要满足的3个条件
   1. 有继承
   2. 有重写
   3. 父类变量指向子类的对象
3. 简单工厂设计模式
   
   • 设计模式：遇到一些问题，前辈提供了一套比较好的解决方案，从而形成了一种固定的模式、套路（类似于棋谱）
   • GOF( gang of four )四人组：写了一本书，软件的可复用的一本书中介绍了这些模式，23种
   • 简单工厂：解决了对象的创建问题，如果你的项目中遇到了同一类对象经常在改变的时候就可以使用
     解决对象的创建问题，当需要频繁的切换几种固定类型的对象的时候，需要用到简单工厂
4. 重写的注意点
   • 重写方法必须和被重写方法具有相同的方法名称、参数列表
   • 重写方法使用的访问权限不能小于被重写方法的访问权限
   • 重写的方法的返回值类型不能大于被重写的方法的返回值类型
   • 父类方法的返回值类型是类型A,子类重写父类方法，返回值类型可以是类型A或类型A的子类.不能是类型A的父类
   • 子类方法抛出的异常不能大于父类被重写方法的异常
   • 子类与父类中同名同参数的方法必须同时声明为 static 的(不是重写)，或者同时声明为非 static 的（即为重写）
5. 多态的注意点
   • 由于子类的对象赋给了父类的引用，所以在编译时，只能调用父类声明的结构：属性和方法
   • 在内存结构中存在子类特有的属性和方法，我们考虑向下转型才能调用子类特有的属性和方法

六 Java面向对象高级

资料
Java 之23种设计模式解析.pdf
大话设计模式(带目录完整版).pdf
深入浅出设计模式(中文版).pdf
盛#男.exe
第6章_面向对象编程(下).pptx
阿里巴巴Java开发手册终极版v1.3.0.pdf

1.访问控制

private、默认、protected、public

修饰符	类的内部	类的外部（同包）	包外子类	类的外部（不同包）
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

1. default 和 protected 的区别：
   • 包外子类：protected 可以访问，default 是不可以的
2. 最佳实践
   • private 用于属性
   • public 用于方法

2.static 关键字详解

1. static 可以用于：

   1. 方法（类方法）

       public static void show(){}
      
       当我们不需要使用对象来调用的时候就用静态方法
      
       一些工具类会使用静态方法，例如 Math 类中的所有方法都是静态的
      
       静态方法通过类名调用，不需要使用对象去调用
      
       static 的方法中没有 this，也没有 super
      
       static 的方法只能访问静态的成员
      
      
       public static void main(String[] args){
      
       }
       为什么 main 需要写成静态的
      
       main 方法是由主线程来调用的，此刻并没有产生任何的 Java 对象，不通过对象调用方法就只能是静态的
       String[] args：表示是命令行参数，有程序启动的时候来传递
      

      
      

   2. 属性（类属性）

       该属性是对这个类的所有对象共享的，只能通过类去访问，目的是为了多个对象共享同一个数据
      
       静态成员不需要对象可以访问（可以使用对象访问，. 的时候不会提示出来，
       但是可以使用 对象.属性 强行调用（静态方法同理），只不过会有警告）
      
       使用案例：
       	1.在线人数
       	2.统计总人数
      

   3. 静态代码段（块）
      用于做一些类的初始化工作

      static{
      	// Java 代码
      }
      

   4. 内部类

2. static 关键字的作用
   设计模式：
   • 简单工厂：simplefactory
   • 单例模式：singleton
     描述：一个类有且只有一个对象，这个事情是类的设计者的责任，而不是使用者的责任（为了系统的性能需求，我们规定一个类只许有一个对象）
3. 单例模式完成步骤
   • 构造方法私有化
   • 提供一个静态方法用于获取这个类的实例

   // 懒汉式（存在线程安全问题）
   public class Monitor {
   	private static Monitor instance;
   
   	private Monitor(){}
   
   	public static Monitor getInstance(){
       	if(instance==null) instance=new Monitor();
       	return instance;
   	}
   }
   

   // 饿汉式
   public class Monitor {
   	private static Monitor instance=new Monitor();
   
   	private Monitor(){}
   
   	public static Monitor getInstance(){
       	return instance;
   	}
   }
   

4. 注意点
   • 静态的方法只能调用静态的属性和方法；非静态的方法可以调用静态的方法和属性也可以调用非静态的方法和属性
   • 实例变量：随着对象的创建而产生，分配在堆空间中
   • 静态变量：随着类的加载而产生的，分配在方法区

3.类的组成部分以及执行的顺序

1. 类的组成部分：
   1. 属性
   2. 方法
   3. 构造方法
   4. 静态属性（类属性）
   5. 静态方法（类方法）
   6. 代码块
   7. 静态代码块
2. 执行顺序
   
   • 第一梯队：静态属性 and 静态代码块
   • 第二梯队：属性 and 代码块
   • 第三梯队：构造方法
3. 继承后的执行先后顺序
   • 静态部分排名第一（父类子类一起加载，也存在先父类后子类）
   • 代码块（父类）
   • 构造器（父类）
   • 代码块（子类）
   • 构造器（子类）
4. 注意点
   • 在子类对象整个实例化过程中，只创建了唯一的一个对象，即为当前的子类对象

4.final 关键字以及 Java 中的包 package

1. final 关键字

   • 修饰属性：最终属性，不能被修改，常量

       常量是不能被修改的量，所以一般会定义为静态的
       命名一般为大写
       static final
     

   • 修饰方法：最终方法，不能被重写的方法

   • 修饰类：最终类，不可以被继承

       final class A{}
     
       class B extends A{}	// 报错
     
       String,Math都是最终类
     

2. Java 中的包 package

   • package：作用就是为了整理代码

   • 一个包就是一个文件夹
     com.xc.dao.User.java

       com
       		xc
       			dao
     

   • 打包

     package com.xc.dao;	// 位于代码的第一行
     

   • 导入包：当你要使用的类和你不在一个包下的时候，就需要导入
     import 包名.类名;
     import 包名.*;

     • idea 快捷键：Alt+Enter

   • 包的命名

       公司域名的反写，小写字母
       
       www.chinaedu.com
       
       com.chinaedu.taobao.dao
     

3. 注意点
   • 使用 final 修饰属性，可以考虑的赋值的位置：①显示初始化 ②代码块中初始化 ③构造器中

5.Java 抽象类

1. 阿里巴巴编码规范
   可以在 idea 中安装一个插件，检查命名是否规范
   
2. 抽象类
   1. 抽象类：很抽象的类，例如现实中很多食物的总结
   2. 抽象类和普通类相比，区别在于抽象类不能 new ，类中可以包含抽象的方法

      public abstract void show();
      

      含有抽象方法的类就是抽象类（抽象类中不一定含有抽象方法，但是有抽象方法的类一定是抽象类）
   3. 抽象类的作用：
      • 定义了一个抽象方法，用于约束子类的行为
      • 定义常规方法，为子类提供继承的方便，为了减少所有的子类都要去编写这个方法
      • 抽象类一般用于和别的模块作为对接的桥梁（低耦合，松耦合）
      • 子类和抽象类是一种 is-a 的关系（有继承关系）
3. 模板方法的设计模式（ TemplateMethod ）
   • 当功能内部一部分是确定的，一部分实现是不确定的，这时可以 把不确定的部分暴露出去，让子类去实现
   • 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了，但是某些部分可以抽象出来，供不同子类实现，这就是一种模板模式

     public abstract class TimeTemplate{
     	// 防止子类修改
     	public final long getTime(){
     		// 获取系统的当前时间
     		long begin=System.currentTimeMillis();
     		code();
     		long end=System.currentTimeMillis();
     		System.out.println("用时："+(end-begin)+"ms");
     		return end-begin;
     	}
     	
     	public abstract void code();
     }
     

4. 注意点
   • 前提：抽象性使用的前提是类的继承性
   • abstract 关键字不能用来修饰：属性、构造器，abstract 关键字不能与 final，private，static 共用
   • 抽象方法没有方法体，所有此方法一定不能被调用
   • 抽象类中也有构造器，但是，抽象类中的构造器不能实例化，是为了让子类继承时调用

6.Java 接口

1. 什么叫接口
   • USB接口，typec接口
2. 接口的定义

   public interface 接口名{
   	void show();
   	void hide();
   }
   

   • 接口就是一种能力的体现
3. 面向接口编程
4. 抽象类和接口的区别
   • 接口是一种特殊的抽象类
   • 接口体现的是一种能力（一个接口表示一种能力，抽象类体现的是事物的本质）
   • 接口是可以多重实现的，一个类可以实现多个接口（表达的意思是具有多种的能力）
5. 访问修饰符的省略
   • 属性：省略 public static final
     • public：使接口的实现类可以使用该常量
     • static：接口不涉及和任何具体实例相关的细节，因此接口没有构造方法，不能被实例化，没有实例变量，只有静态变量（ static 修饰就表示它属于类的，随着类的加载而存在的，当 JVM 把字节码加载进 JVM 的时候，static 修饰的成员已经在内存中存在了，如果是非 static 的话，就表示属于对象的，只有建立对象时才有它，而接口是不能建立对象的，所以接口的常量必须定义为 static ）
     • final：接口中不可以定义变量，即定义的变量前都要加上 final 修饰，使之成为常量，且必须赋初始值（ final 修饰就是保证接口定义的常量不能被实现类去修改，如果没有 final 的话，由子类随意去修改的话，接口建立这个常量就没有意义了）
   • 方法
     • 普通方法：省略 public abstract ，一般写为：void show();
     • 默认方法：省略 public ，一般写为：default void show(){ // 代码体 }
     • 静态方法：省略 public ，一般写为：static void show(){ // 代码体 }
   • 类：省略 abstract（ interface 本身都是抽象的，加不加都一样）
6. 注意点
   • 接口中只能定义常量和抽象方法----->JDK7.0及以前（JDK8.0接口中引入默认方法、静态方法）
   • 接口中不能声明构造器，接口是不可以直接实例化的
   • 如果类实现的接口和继承的父类中，定义了同名同参数的方法，那么子类在没重写此方法的情况下，默认调用的是父类中声明的方法。。—“类优先”原则
   • 如果实现类实现了多个接口，接口中定义了同名同参数的方法。那么此时对于实现类来讲，会出现接口冲突问题----->要求实现类必须重写接口中的方法

7.Java 内部类

1. 内部类的作用
   • 没有内部类的情况下：重新写一个类来实现两个类的传参问题
   • 有内部类的情况下：类中再写一个类，内部类可以访问外部类的属性，不需要特地传参
2. 内部类的分类
   • 普通内部类
     在一个类中编写一个类，里面的类称为内部类，外部的类称为外部类
     编译后的结果：
     
     内部类属性访问：

     public class Outer{
     	int i=10;
     	
     	/**
     	 *内部类
     	 */
     	 class Inner{
     	 	int i=20;
     		
     		public void show(){
     			int i=30;
     			System.out.println(i);	// 30
     			System.out.println(this.i);	// 20
     			// 此 Outer 是外部类的类名
     			System.out.println(Outer.this.i);	// 10
     		}
     	 }
     }
     

     如何生成对象：

     /**
      *在别的类生成
      *其中main 方法中也需要这样，是因为 main 方法是静态的，
      *看不到非静态的内部类，如果内部类是静态的就可以看到
      */
     public void creatInner(){
     	Outer outer=new Outer();
     	// 创建里面的对象
     	Inner inner=outer.new Inner();
     	// 或者一步到位
     	Inner inner=new Outer().new Inner();
     }
     
     /**
      *在外部类的方法中生成
      */
      public void creatInner(){
      	Inner inner=new Inner();
      }
     

   • 方法内部类

     public class Outer{
     	public void sayHello(){
     		/**
     		 *方法中的内部类
     		 */
     		class Inner{
     			int i=10;
     			public void show(){
     				System.out.println(this.i);
     			}
     		}
     		
     		Inner inner=new Inner();
     		inner.show();
     	}
     	
     	public static void main(String[] args){
     		Outer outer=new Outer();
     		outer.sayHello();
     	}
     }
     

   • 匿名内部类

     btn.addActionListener(new ActionListener(){
     	@Override
     	public void actionPerformed(ActionEvent e){
     		System.out.println("点击");
     	}
     });
     

     • 用在事件处理方面使用比较广泛

         new 接口(){
         	接口的方法(){
         	
         	}
         }
         
         本质上是在 new 一个类的对象，只是这个类是没有名字的
       

3. 注意点
   • 内部类可以被 final ，abstract 关键字修饰

8.Java 祖宗类 Object 类和单元测试

1. Object 类

   • 处于 java.lang 包下面
   • Object 类的方法：

     public class Object{
     	// 判断是否相等
     	public boolean equals(Object obj)	{ return ( this == obj); }
     	
     	// 用于克隆对象
     	protected native Object clone() throws CloneNotSupportedException;
     	
     	// 用于输出的
     	public String toString(){
     		return getClass().getName()+"@"+Integer.toHexString(hashCode());
     	}
     	
     	// 多线程以后才会使用的方法
     	public final native void notify();
     	public final native void notifyAll();
     	public final native void wait(long timeout) throws InterruptedException;
     	public final void wait(long temeout,int nanos) throws InterruptedException{
     		// 代码
     	}
     	public final void wait() throws InterruptedException{
     		wait(0);
     	}
     	
     	// 用来在垃圾收集之前执行的代码
     	protected void finalize() throws Throwable {}
     }
     

     

2. 重点方法

   • equals()

       用来判断两个对象是否相等：
       	基本数据类型的比较可以使用 == 来判断
       	对象的比较使用 == 根本比较不出来，比较的结果永远是 false
       
       两个对象如果需要比较，用 equals 来比较
       如果我们依然使用祖宗的 equals 方法，那么得到的结论依然是错误的
       
       如果真的需要比较两个对象是否相等，我们需要将祖宗的方法进行重写
     

   • toString()

       该方法用于描述一个对象
       
       System.out.println(student);
       打印一个对象的时候，调用这个对象的 toString() 方法
     

   • clone()

     • 浅克隆（浅拷贝）
       • 重写 clone() 方法
       • 实现 Cloneable 接口（这是一个标记接口，没有任何的方法）
     • 深克隆（深拷贝）

       @Override
       protected Object clone() throws CloneNotSupportedException{
       	// 克隆第一级
       	Car car=(Car) super.clone();
       	
       	// 克隆第二级
       	Girl girl=(Girl) car.girl.clone();
       	
       	// 将新克隆的对象赋值
       	car.girl=gril;
       	
       	return car;
       }
       

3. 后面建立模块
   

4. 单元测试

   • junit：是一个三方组件

七 异常处理

1.什么是异常

• 程序运行过程中出现的错误，一些非正常情况导致程序出现的错误，称为异常，程序如果不处理异常，程序就非常的不健壮，很容易崩溃

2.异常为什么要处理

• 异常如果不处理，那么会导致程序终止
• 处理异常：是为了让程序更加健壮

3.异常的分类

• ArithmeticException：算数异常 /by zero
• ArrayIndexOutOfBoundsException：数组下标越界
• NullPointerException：空指针异常
• InputMismatchException：输入不匹配异常
• OutOfMemoryError：超出了内存错误
• …
  

异常	说明
Execption	异常层次结构的根类
RuntimeException	许多 java.lang 异常的基类
ArithmeticException	算数异常，如：除数为0
IllegalArgumentException	方法接收到非法参数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	访问空引用
ClassNotFoundException	不能加载所需的类
NumberFormatException	字符串转换数字失败
IOException	I/O 异常的根类
FileNotFoundException	找不到文件
EOFException	文件结束

4.如何处理异常

单词	说明
try	监视，考验，审问
catch	捕捉，捕获
finally	最后，终于，不可更改地
throw	抛出，扔
throws	抛出，扔

/**
 * 把可能发生异常的代码放在 try 部分，当发生异常以后，
 * 会触发 catch 部   分
 */
 try{
 
 }catch(异常对象){
 
 }
 
 /**
  * 当 try 语句中如果发生多种类型的异常，我们在捕获的时候
  * 为了精准的显示错误信息，所以会出现多个 catch 部分
  *
  * 放多个 catch 的时候不要将父类、高级别的异常类放在上面的位置
  */
  try{
  
  }catch{
  
  }catch{
  
  }
  
  /**
   * finally：最终部分，不论前面发生了什么，finally 部分的
   * 代码都会执行（只要进入了 try，除非 System.exit(0)，
   * 否则都不能阻止 finally 的执行，不考虑 try 前被
   * return 了）
   * 
   * 应用场景：
   * 		1.一般用于资源的释放
   * 		2.数据库的连接
   * 		3.文件的句柄
   * 		4.窗口的句柄
   */
   try{
   
   }finally{
   
   }
   
   try{
   
   }catch(){
   
   }finally{
   
   }

5.自定义异常

1. throw：主动的抛出异常
   • throw 异常对象：执行以后，后面的代码就不会执行了
2. throws：声明某个方法可能会丢出异常
   
3. 检查异常和非检查异常的区别
   • 检查异常( checked exception )：必须捕获或者抛出的异常，这些异常都是继承自 Exception
   • 非检查异常( unchecked exception )：运行时可以不用捕获或者抛出的异常，由虚拟机来负责抛出（运行时异常，一般继承自 RuntimeException）
     
4. 自定义异常
   • 继承异常类，一般为：Exception ，RuntimeException
   • 写构造方法，一般为带参数的构造方法

     public class MyExecption extends Exception{
     	public MyException(String message){
     		super(message);
     	}
     }