java基础，

java基础，

1.   jdk:java development kit-java开发工具包

-----java开发工具：编译器，调试器，javadoc.exe   java.exe  javac.exe

-----jre(java运行环境)java runtime environment

--jvm(java虚拟机)：使用程序模拟一台计算机，使java运行在jvm上

--类库（资源库）

2.  java语言特点：可以跨平台，比如linux ，window，mac因为都是用不同版本jvm都可以运行字节码class文件

还有一个特点就是强类型，就是java在定义变量的时候必须定义一个类型，而变量必须跟类型相匹配

3.  java语言的运行原理：java源文件(.java)(编译过程javac 源文件名称.java)--->java字节码文件(.class)(开启jvm，运行字节码文件)，(java 字节码文件名称，千万不要加文件名称)---->程序开始跑起来啦！！！

如果想使用简短的命令名称，我们需要配置换简变量：计算机-->属性-->高级系统设置-->高级-->环境变量

(1)新建一个环境变量名为：

JAVA_HOME变量值：D:\Users\Michael\Apps\Java\jdk1.8.0_172就是命令所在目录bin的父目录

(2)新建一个环境变量名为：

CLASSPATH变量值：,;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

(3)找到系统变量里的path：追加：;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

检查是否配置成功：

打开命令提示符界面：

输入两个命令：java -version 回车      或者       javac  回车

不出现不是内部或外部命令即成功

注释有三种：

1.文档注释：

/**  注释  */

2.多行注释：

/*  注释  */

3.单行注释：

//注释

通常：文档注释用于解释或方法

多行或单行注释用于解释方法内的逻辑

变量：

语文课本中可变化的量

java语言中：就是在jvm在内存中开辟的一个存储空间作用是用来存储数据

（1）程序通过操作变量名来操作储存空间

（2）变量必须定义一种类型

变量的命名规则：

（1）由字母  数字  _和$任意组成，数字不能开头

（2）大小写敏感

（3）可以使用汉字，但是不建议使用

（4）驼峰命名法

（5）见名知意

（6）不能使用关键字（java保留字）

变量的使用规则：

（1）必须先定义（声明，创建）和初始化

（2）可以重复使用，可以进行多次存取操作，不需要强调类型，但是存取数据时一定要与第一次声明时的类型匹配、

（3）变量的作用域：变量有自己的作用使用范围出了范围，变量无效，作用域：从所在大括号开始到到大括号结束，出了括号想使用，需要重新定义。和初始化

进入命令提示符界面：

d：表示计入硬盘 cd 表示进入文件夹   javac。exe调用编译器对源文件进行编译成字节码文件

java语言共分两大类：基本数据类型和引用数据类型

基本数据类型有8种：

byte short int long float double char boolean

整数类型：byte short int long

浮点数类型：float double

字符类型：char

布尔类型：boolean

类型转换：

1.自动转换（隐式转换）：占内存小的类型变量赋值给占内存大的类型变量会发生自动转换

2.强制转换：占内存大的赋值给内存小的类型变量，需要强制转换

如：int a=1；

byte a1 =（byte）a；

范围大小：double>float>long>int>short>byte

                                                       char(差不多大)

编码：将字符--->二进制

解码：将二进制--->字符读

java语言常用的字符：

A-Z----->65-90

a-z------>97-122

0-9------>48-57

java语言中的转义字符：

'\'：将特殊字符变成相应意义的字符

java语言中的特殊字符：

单引号:'\''

双引号:'\"'

制表符:'\t'

换行符:'\r'

回车符号:'\n'

反斜线：'\\'

如果想查看字符集中，某一字符对应的整数

int num = '加想要看的字符'

引用类型之一：

String：字符串类型

运算符：

两原一封：

两原

1.不同类型的数据做运算时，一定会先转换成较大范围类型后再运算

 2.byte short char这些类型运算时，一定会先转成int类型在运算，结果int类型

封：一定要注意封闭式运算

算数运算符：

+，-，*，/，%，++，--

/：都是整数做运算时，做取整运算，即 商n余m，结果为n

只要有一个浮点数参与，就会做类似精确运算

%：取余运算符，也叫取模运算符号，做除法运算时，商n余m，结果为m

参与运算都是整数时，余数时精确值

有浮点数参与时，余数不一定是精确值

注意：取余运算一般用来判断一个数是否能被另外一个数整除

++/--：是自增自减运算符表示变量会自动加一或减一

符号在前先运算在赋值

符号在后先赋值在运算

被除数为正取余结果一定为正，被除数结果为负取余结果一定为负

关系运算符：

>,>=,<,<=,==,!=

用来判断条件是否成立，一般都用在分支结构或循环结构中

逻辑运算符：

又称之为短路运算符：如果第一个条件就能判断结果，就不会执行后面的条件了

当有两个条件以上进行判断是否成立时，需要使用逻辑运算符            与或非

&&：需要同时成立

||：有一个成立即可

！：用于条件的否定

赋值运算符：+=，-=，*=，/=，%=

a+=1    a=a+1

a-=b    a=a-b

字符串拼接符号：当+前后只要有一个是字符串类型，就做拼接操作，拼接后的结果是字符串类型

其他的不管

三目运算符：

变量类型       变量=条件表达式？值1：值2；

变量类型：需要与值1或值2的类型相同。而值1与值2的类型要么相同要么自动转换

程序的运行顺序：

顺序结构：从程序开始，到程序结束

分支结构：在顺序结构基础上，根据条件进行选择执行方向。

循环结构：在顺序结构基础上，根据条件进行多次执行相同的或相似的代码

分支结构：根据条件的成立与否，选择执行方向。

分支结构：根据条件的成立与否，选择执行方向。

 

           

分支结构：
(一) if语句
      
     当if语句中含有else{}部分时，一定会执行其中一条分支。
     没有else{}部分时，有可能一条分支都不执行
(二)switch-case语句
    格式：

    switch(整数表达式){
    case value1: 代码块1;[break];
    case value2: 代码块2;[break];
    ..........
    [default: 代码块n;]---[]表示可有可无
    }

    整数表达式：即能获得一个整数的表达式。
    但是jdk1.7版本以后，支持字符串表达式

    case后的值与()内的结果类型要相同

    break:有打断，毁掉，跳出，结束的含义

    执行逻辑：
         当程序遇到switch时，计算表达式的值，然后
     匹配case后的值，然后，执行对应的分支逻辑。
     如果此分支有break.就结束分支结构，如果此分支
     没有break,就继续执行下一条分支逻辑，直到
     遇到break或default或全部执行完后续的所有分支。

引用类型之
  Math类和Scanner类

  Math:是一个数学类型，此类型中有很多方法:即功能
  如:
     Math.random():功能是随机产生一个[0,1)区间内的
                  任意浮点数
          范围：0~0.9999999999999999999999999;

     double num = Math.random();

  Scanner:是一个开启键盘输入的类型,此类型中有很多方法。
       如：可以扫描键盘输入的整数，浮点数，布尔类型，
           字符串

       nextInt():扫描整数
       nextDouble():扫描浮点数
       nextBoolean():扫描布尔类型
       next():扫描字符串
       nextLine():扫描字符串

       这些功能都有阻塞程序的效果，当扫描到数据后，并
       回车，阻塞效果消失，程序继续向下运行

使用步骤：
    (1)导包
       import java.util.Scanner;
    (2)新建对象
       Scanner scan = new Scanner(System.in);
    (3)使用功能
         int num = scan.nextInt();
    double num = scan.nextDouble();
    String str = scan.nextLine();
    String name = scan.next();

循环结构
        ：当重复执行相同的代码或者是相似的代码时。

循环三要素：
   1): 循环变量的声明:用于控制循环次数的循环因子
   2): 循环条件: 用于判断是否执行相同或相似内容(循环体)的条件
   3)：循环变量的改变方向:
             向着循环结束的方向改变。
(1)for循环:

   语法:
      for(变量的声明和初始化;循环条件;变量的改变方向){
        循环体;
      }

数组:
1、概念：一组相同类型的数据的组合
         数组也是一种引用类型，
2、名称：数组名称不是固定的，与存放的数据的类型有关。
         如:  存放一组int类型的数据，

3、元素的概念：
      数组中的每个数据，都是这个数值的元素。
4、数组的声明与初始化
     声明：元素类型[]  变量名;
           元素类型   变量名[];--不建议此写法
     变量的初始化的时机：2种
       (1)声明时直接初始化
       (2)先声明，再初始化(使用前初始化)
     数组的变量初始化：3种情况
           (1)静态初始化
          String[] names = {"A","B"};
          int[] nums = {};
       (2)动态初始化
          --规定数组长度的写法
            int[] ages = new int[length];
        其实有默认元素：
        整数类型：默认是0
        浮点数类型：默认0.0
        字符类型：默认'\u0000'
        布尔类型：默认false
        引用数据类型：默认值null

          --不规定长度的写法
        int[] ages = new int[]{};
        double[] counts = new double[]{1.2,3.14};

5、数组的长度：
     即数组元素的个数
     表示方式：变量名.length;
6、数组的下标(index):
      下标从0开始，最后一个元素的下标为：length-1;
      下标范围：0~length-1
7、数组元素的访问(查看):
      通过下标进行查看
      语法:变量名[index];
     
   元素的遍历(从头到尾依次查看)
   for(int i=0;i<变量名.length;i++){
    System.out.println(变量命[i]);
   }
8、数组元素的覆盖(赋值，替换)
      
      语法：变量名[index] = value;

9、数组间的赋值
    就是指变量之间的赋值。
    
    通过一个变量对数组的元素进行修改，
    那么与之相关的变量对应的数组的元素
    也会发生变化。
10、数组下标越界异常：
    java.lang.ArrayIndexOutOfBoundsException

    出现的原因：
        访问数组元素时的下标超出了范围
    正确范围：0~length-1
    错误下标：
           变量名[-1]
           变量名[length]

11、引用类型之Arrays
    是数组的工具类。此类提供了很多对数组操作的功能方法
    如：
    String info = Arrays.toString(数组名);
    Arrays.toString():此方法是将数组的元素
    一一拼接成字符串.
    格式如下：
       "[元素1,元素2,.....元素length-1]"

12、数组的复制
     
     数组的特点：一经创建，长度不可变。

     系统复制法：
       System.arraycopy(src,start1,des,start2,length);
       src:源数组，即被复制的数组名
       start1:源数组复制的开始下标
       des:目标数组，即复制到的数组名
       start2:目标数组复制的开始下标
       length:复制的长度

     工具类提供的复制方法:
      元素类型[] 变量名=Arrays.copyOf(src,newLength);
      src:源数组
      newLength:新数组的长度

     功能解释：从src的下标为0的元素开始复制
               复制到长度为newLength的新数组中
           新数组存放元素的开始位置为0

二维数组的初始化：
  静态初始化
      如：int[][] a = {{1},{1,2},{2,3,4}};
  动态初始化：
      (1)等长式初始化
          int[][] a = new int[3][2];
      表示a有三个元素，每个元素都是2个长度的数组。
      (2)只规定高维数组的长度
          int[][] a = new int[3][];
      表示a有三个元素，但是都是null.
      null在使用时，需要新建数组对象(长度任意)

this关键字：（这个）

成员变量前系统默认提供了this

类是对象的模板，对象是对类的实例化

当形式参数与对象变量名称一致时，为了区分开，需要在成员变量前添加this

this指向的是将要创建的那个对象即变量  方法 （）时的变量

方法：

概念：类的共同行为，封装了一段逻辑代码，在封装方法时尽可能的只完成一项功能

避免将多个功能封装到一个方法里

方法的使用：方法属于对象的行为，应该使用  引用.方法 这些方法动态绑定到对象上

方法的签名：方法名+形参=方法签名

如：public void num(int a,int b){}

num+int,int

形参列表：指的是形参的类型顺序列表

方法的重载：在同一个类型中，方法名不变，参数列表不同的方法就是重载关系

在方法调用时，编译器会检查类的信息中是否有符合此签名的方法

内存管理机制：

jvm将内存分为三大主要区域：

方法区：jvm将字节码文件加载到这里，用来储存类的信息

  栈：用来储存方法内地局部变量

  堆：用来储存引用类型的对象

方法区：用来储存字节码文件

空指针异常：
   java.lang.NullPointerException
   在程序运行时，可能会出现此异常，出现的原因：
   Car  c = new Car();
   System.out.println(c.color);//0
   Car c = null;
   System.out.println(c.color);//就会出现空指针异常
   
   
   null:是引用类型的默认值

 

   构造方法(构造器)：
      是特殊的方法，作用是用来给成员变量(Field,字段，属性)
      初始化。
      特殊在
      (1)没有返回值这个位置
      (2)方法名与类型相同

面向过程:C,Basic,Pascal
        核心思想: 自顶向下，逐步细分，模块化
        程序的基本单元:函数
            针对于函数来说：会接收一些数据，进行处理，然后再输出
                                         一些数据。
                               主函数 
              函数1        
                         函数2     函数3 
           如：吃(猪八戒，西瓜) 
面向对象：C++,java,C#...相对面向过程，简单，好学。
        核心思想：使用类，对象，继承，封装，消息，动态绑定，静态绑定等进行程序设计
        程序的基本单元：类 
    
        如: 
              首先：设计猪妖类型，
              然后: 实例化一个猪妖
              其次: 初始化信息
              使用: 猪八戒.吃(西瓜)

继承：

java继承是定义一种的新的类型，从已有的类中吸收成员变量和方法，新的类型可以添加新的方法和成员变量这种方式可以提高代码的复用性，缩短开发周期减少开发费用

子类：派生类////////父类：超类，基类

exends  用于继承语法

格式：public  class a  exends  b{}

构造器：

子类不能继承父类的构造器，使用super（有参传参）只能调用父类的构造器，

子类中的构造器，至少有一个调用了父类的构造器

super（有参传参）与this（有参传参），不能共存，而且只能放在首行首句

相同点：都是调用构造器，而且首行首句

不同点：super'调用时父类构造器     this 调用是本类构造器

特点!!!!!!继承有传递性：  a继承b   c继承a  c就继承了b 

单继承：一个子类只能继承一个父类，但是一个父类可以有多个子类

一个源文件只能有一个public修饰的类 而且此类必须与文件名一致

方法的重写：

子类可以重新编写继承父类的方法

（1）方法名相同，参数列表相同

（2）返回值类型相同，也可以是父类方法的返回值类型的子类型

（3）修饰词可以不变，或者可以比父类的修饰词权限更大

父类型的变量引用子类型的对象

变量能调用的方法与成员变量

如：Animal   a   =  new  GoldFish（）；

这条金鱼是动物符合人类思维

方法：

编译期：变量只能调用出本类型中的方法

运行期：变量调用出方法执行逻辑与对象的类型有关

成员变量：

变量调用出的成员变量一个是本类型中的成员变量、

如：Person p = new Student();

p.name-------super.name

p.age--------super.age

创建子类对象时，在内存中会不会产生父类对象？

1.会：没有父类，哪来的子类

2.不会：创建子类对象时，子类对象的成员变量包含两部分：

一部分从父类继承过来的：在成员变量前默认super。

一部分是自己类中的：在成员变量前有默认this。

如果子类中独有的与继承过来的成员变量重名时，必须显示指定使用super。或者this。

如不重名则可以隐式不写或者写两个中的一个

-----------------------------

Object:是所有引用类型的顶级父类，

系统都会默认使引用类型extends Object，

此类中提供了常用的方法：

1.toString():

此方法会在输出变量时，或引用变量进行拼接时默认调用

在Object中，返回值的是类全名@HashCode值

即对象的内存堆中的位置信息

{类有类名和类全名之分：

类名：即最短的名称

类全名：从包名开始写的名称

如:Strng 是类名

java.lang.String是类全名

我们不需要查看地址信息：

所以我们要重写toString（)方法用于查看对象的详情

格式：

public String toString() {
        return "类名 [name=" + name + ", age=" + age + ", hiredate=" + hiredate + ", salary=" + salary + "]";
    }                        成员变量1                   2                                   3                               4

2.equals（Object  obj）

Object类型中的此方法中的逻辑是比较调用者this与形参obj的地址信息是否相等

简单说成：比较this与obj是不是同一个对象

所以在定义类型时，继承过来的equals方法 我们要重写。
  重写规则：
   (1)   查看传进来的obj是不是null
             if(obj==null){
                  return false;
             }
   (2)： 查看传进来的obj是不是this.
         if(obj==this){
             return true;
         }
   (3)   查看穿进来的obj是不是本类型
            if(obj.getClass()!=this.getClass()){
                return false;
            }    
            可以改成
            if(!(obj instanceof Person)){
                return false;

instanceof关键字：
     作用是判断引用变量指向的对象是否属于某一类型
    语法：
     boolean f =  变量名  instanceof  类型名

      ==：比较的是两个字符串内存地址的数值是否相等，属于数值比较； 
 equals()：比较的是两个字符串的内容，属于内容比较。 

package： 包.  
        作用：用于管理源文件,区分类全名
        命名规则:域名后缀.域名.项目名.模块名
        声明位置：在源文件的首行首句。
        类全名:从包开始写起的名称
    常用的包:
    java.lang.*,因为里面的类型非常常用。因此不需要导包
    java.util.*,此包下封装了很多常用的工具类 
    java.io.*,此包下封装了io流的类型
    java.net.*,此包下封装很多关于网络的多种类型 

import: 导包关键字：
        在class之上，package之下。
        用于声明 类的 类全名，在逻辑中就可以使用短的类名。
        优点: 可以减少代码的书写。   

访问权限控制修饰词
    private,protected,public,默认的(default) 
    
    修饰类时:
        外部类:可以使用public和默认的
        内部类:可以使用public,protected,默认的,private
        
    修饰成员变量:四个都可以进行修饰       
                可见性不一样

                         本类中     同包下    不同包子类中      其他    
public       true    true     true       true
protected    true   true     true
default      true   true
private      true

在实际开发中，成员变量要尽可能的设置成不可见

可以提高代码安全性。private

子类不能重写父类的私有方法

修饰词final:最终的，最后的

(1)修饰类，
          被final修饰的，不能再有子类了。         
(2)修饰成员变量
           可以直接初始化   
           也可以在构造器中初始化
           不能再其他任何地方再次赋值
      修饰局部变量
           只能初始化一次。   
(3)修饰方法
       被final修饰的方法，不能再子类中重写      
       
       
 常量：
        因为常量是一些特殊值，我们可以定义成final, public,static进行修饰。

 

static：英文含义：静态‘

1.修饰成员变量

（1）修饰的成员变量，不属于对象的数据结构

（2）静态变量属于类的，通常使用类名去调用

（3）静态变量与类的信息一起存在方法区中，只存在一份，是对象的公共资源

2.修饰方法

（1）通常的方法都是与具体对象有关系，即对象的方法（行为）

（2）如果是static方法则与对象毫无关系，是类的方法，通常用类名去调用常常与参数有关系

（3）static方法内因为无法使用this关键字，因此不能直接访问非静态成员

（4）static方法的作用一般都用于设计成“工具方法”和“工厂方法”

如：Arrays sort（数组名）；

Math.random();

Math.sqrt(参)；

Math.abs(参);

Math.sin(参);

3.static修饰代码块

static{

逻辑代码块

}

静态块储存在方法区中，只加载一次，与对象无关。

执行时机为加载类的信息期间，可以理解为在实例化之前

作用：通常用于加载程序中所需要的静态资源：如图片，音频，视频等

非静态代码块与静态代码块，成员变量，方法都是类的成员

运行时机：在实例化之前执行，每次实例化之前都会执行一次

常量：
一般都是一些特殊值

一般都是用成员变量，修饰词为public static final

声明时必须初始化

命名规则：字母全都大写

如：Math.PI

------------

设计模式之单例模式：

需求：在程序中的任何地方，我们想要获取某一个类的唯一对象我们称之为类的单例

Singleton

（1）提供一个私有的静态的本类型的成员变量

（2）构造器私有化

（3）提供公有的静态的方法获取本类中创建的实例

饿汉式写法：加载期间就实例化对象

public class Singleton{

private static Singleton instance  = new Singleton();

private Singleton(){}

public static Singleton getInstance(){

return instance;

}

}

懒汗式写法：调用方法时才创建对象

public  class Singleton{

private static Singleton instance;

private Singleton(){}

public static Singleton getInstance(){

if(instance ==null){

instance =new Singleton();

}

return instance;

}

}

抽象类：

因为继承的关系，子类的功能可以越来越具体，相对来说，父类更加一般化，通用化，因为父类封装了子类的共同行为，所以在定义时，我们可以定义方法的逻辑。有的时候，在父类中无法完成子类的功能需求，此时，不如不写，即不写方法体，代码简单化。但是此方法必须使用abstract修饰，那么此类型也必须使用abstract修饰，即抽象类

（1）抽象方法与抽象类

         1）用abstract修饰的方法，不需要写方法体，但是得用分好号来结尾

         2）有抽象方法的类，必须使用abstract声明（修饰）

（2）抽象方法不能实例化

          1）抽象类不能创建对象，没有意义

          2）抽象类可以提供构造器

          3）抽象类中可以没有抽象方法

           4)abstract和final不能同时修饰一个类型

3.继承抽象类

          1）若一个类继承了抽象类，那么这个类必须重写（实现）抽象类的所有抽象方法

          2）若一个类没有实现抽象类的所有抽象方法，那么这个类必须使用abstract修饰

4.抽象类的意义：

          1）给不同的子类定义一个父类

          2）抽象类可以封装子类的共同特征与共同行为

          3）虽然子类方法可能有不能的实现逻辑，但是方法的定义一致

接口:
        有时我们需要从多个不相关的类中设计出一个子类型，而java继承
        是单继承的特点，无法满足我们的需求，所以，我们可以使用接口来达到
        多继承的目的。 
        
        接口实际上就是一种规范制度。   (规范与规则的理解)
接口的特点：
   (1)接口使用interface关键字，而不是class,
            但是我们可以理解成接口是特殊的抽象类
   (2)接口里只能有抽象方法和常量     
   (3)接口不能实例化，没有任何意义
   (4)接口不能提供构造方法
 
接口中的常量：
       默认使用修饰词为public static final                      
接口中的方法
        默认使用public abstract
   
接口的实现
   (1)子类需要实现接口中的所有抽象方法，
   (2)使用implements关键字进行实现
   (3)如果子类没有实现所有抽象方法，那么子类需要使用abstract修饰
   (4)子类可以实现多个接口，接口间使用逗号分开
  
  
接口间的继承
   (1)接口与接口之间可以使用继承。
             子接口继承了父接口的抽象方法
   (2)支持多继承                
   
======================================
多态：面向对象的特征之一  

     向上造型：
             父类型的变量引用子类型的对象
    (1) 父类型的变量指向不同的子类型对象，
                调用的功能有不同的实现       
       Animal  a =  new  Dog();
                   a.noise();//叫   
               a =   new  Cat();
                a.noise();//叫   
         
    (2)不同的父类型变量指向同一个对象有不同的功能
       ZhengYangDoor  a  = new  ZhengYangDoor();
            a.theftproof();//防盗
            a.openDoor();//开门
       InterA   ia = a;
               ia.theftproof();   
               
    向下造型：
        将父类型(接口)的变量赋值给子类型或者是其他父类型(接口)的变量
        Animal a = new Dog(); 
        Dog dog   =(Dog)a;
        dog.吃骨头();
        
        Cat cat = (Cat)a;//编译通过，语法正确，运行期间，造型错误
        cat.扑捉老鼠();
        
       运行期间有可能会发生类造型异常：java.lang.ClassCastException 
        
    
             为了避免出现错误：我们需要使用关键字instanceof来判断
             对象是不是要转换成的类型
         if(a instanceOf Cat){
             Cat cat = (Cat)a;
         }

内部类:
    是定义在一个类的内部的新类型。即内部类，另外一个类称之为
    外部类。
   
  根据位置不同：
   可以有  成员内部类
                方法内部类(局部内部类)
  带static修饰词的类   静态内部类
 没有名称的类：   匿名内部类  
 
 最不常用的：方法内部类，静态内部类
     方法内部类：定义在方法中，相当于局部变量，仅限于在方法中使用
                  定义时不能使用修饰词，可以直接访问外部类的非静态成员变量
     静态内部类:也是以类的成员来定义的，只不过多了一个修饰词static
                        可以直接访问外部类的静态成员
 
相对而言，成员内部类和匿名内部类比较常用。
      成员内部类：以类的成员来定义，可以使用任何修饰词来修饰。

成员内部类访问外部类的成员
 方法内隐藏一个指向外部类对象的引用。
 外部类名.this.

             
成员内部类的使用：
    创建对象：
       要先创建一个外部类的对象outer
    然后使用外部类对象去使用new调用内部类的构造器实例化
     Inner  inner = outer.new Inner(有参传参);    
外部类访问成员内部类的成员
       在外部类添加一个内部类的成员变量进行访问  
       
       
匿名内部类：
    没有名字的类型，写在外部类的方法中，只用一次，不需要定义类的结构，
    通常都是为了实现接口，抽象类或某一现有的类的子类     
    子类没有名称，所以称之匿名