java基础概念整理综合 及补充（jdk1.8）

2018 java基础 笔记回顾摘要

一

1，html 与 注释：

        <!--   -->  注释不能嵌套 

代码都得有注释。

 

2，空格符： &nbsp;  

   

3，css选择的优先级： id选择器 > class选择器 > 标签选择器

 

4，dos命令： cd\ 退回到根目录

                dir: 列出当前目录下的文件及文件夹

                cd 文件名 ：进入指定目录

                cd..：退回到上级目录

                exit：安全退出dos命令窗口

                cls：清屏

                盘符： 切换到指定盘

 

5，开发时，先定好框架，再填入内容。

 

6，标识符（命名）：

a，合法的标识符：

    只能包含字母，数字，下划线_，美元符号$ 这些

    不能以数字开头

    不能是单独的_或者$

    不能是关键字 或 保留字，不能是 mian

    区分大小写

b，合理的标识符：

标识符载满足合法的条件下，还应该满足以下命名规范。

    Java中一般采用驼峰式命名

    类名，接口名 所有的单词首字母大写

    变量名，方法名，第一个单词首字母小写，其余单词首字母大写

    常量名所有单词字母均大写，且单词与单词之间用_连接

 

6，关键字 48个 ，保留字 2个 ，所有字母都是小写

 

7，java数据类型：基本数据类型（4类8种）

         引用数据类型：数组，类，接口

基本数据类型：a,整型 ：字节型 byte 占1个字节(byte)（8位(bit)） 范围：-2^7 -- 2^7-1 (-128 -- 127)

短整型 short 占2个字节(byte) 范围：-2^16 -- 2^16-1 (-65536 -- 32767)

整型 int（java默认整形） 占4个字节(byte) 范围：-2^31 -- 2^31-1 (-20多亿 -- 20多亿)

长整型 long 占8个字节(byte) 范围：-2^62 -- 2^63-1 ( 表示long时要在数字末尾加上l/L 以示区别)

b,浮点型（小数）： 单精度浮点型 float 占4个字节 有效数字8位 范围：3.4x10^38（ 表示float时要在数字末尾加上f/F 以示区别）

双精度浮点型 double（java默认） 占8个字节 有效数字16位 范围：1079x10^308

c,字符型 char 单引号引起 如：'A' '你' （占1--3 个字节）

d,逻辑型（布尔型） boolern 值只有2个 true|false

 

基本数据类型坑点总结：

（1）java默认整形是 int ,ava默认浮点形是 double； 表示 long 时要在数字末尾加上l/L 以示区别，表示 float 时要在数字末尾加上f/F 以示区别。

（做运算时一定要注意数据的范围，临界值，还有溢出情况。）

（2）double 有效数字超过16位，第17位为随机数，数字无效；只有double 才有随机数(不确定 位)生成，float没有，float超长会截掉（不会四舍五入）

（关于转型的）

（3）自动类型转换 （范围 小--> 大） 隐式类型转换

存储数据范围小的数据可以直接赋值给存储范围大的数据类型的变量：

byte --> short --> int --> long --> float --> double

 

字符型和整型之间也可做自动类型转换，java采用的是unicod编码（包含世界所有已知文字，unicode编码可以换算成数字）

字符型和整型之间的转换（1个字符占1--3 个字节）：

char --> int --> long

一般情况下，char不和小数进行转换。字符型和byte，short数据类型之间的转换，都是强制类型转换。

 

（4）强制类型转换（范围大的类型 --> 范围小的类型） 显式类型转换（明显指出）

存储数据范围大的数据不能直接赋值给存储数据范围小的数据类型的变量，必须显示的写出需要转换的数据类型。

注意：强制类型转换可能会造成数据类型失真，所以在你不确定这个数一定小于指定的数据类型的最大值时，不建议做强制类型转换。

字符型和byte，short数据类型之间的转换，都是强制类型转换。

小数和整数之间爱的强制转换，转换后的值是整数部分，不会四舍五入。

 

8，运算符：三目运算符   _x_ ? _y_ : _z_ （结果是什么类型就可以用什么类型接收）

x:判断条件（true|false） y:值1(x为true时) z:值2(x为false时)

做运算时一定要注意数据的范围，临界值，还有溢出情况。

        取模（取余）：% ；自增 ++ ，自减 -- ；

比较运算符：所有的类型都能进行相等的比较，但不都能进行大小的比较，对象不能比较大小。

逻辑运算符：与（& && ），或 （| ||），非（！）

 

9，流程控制语句: if-else,while(do-while),swith开关，for循环

if-else:单分支结构，双分支结构，多分支结构 以及 嵌套

while：找出口（满足条件，跳出循环）

for（x;y;z）循环：x:初始数据 y:判断条件 z:循环表达式。

 

swith语句：

    Swith （）{

    case  xxx : 

    case  xxx :  [break;]

    default :     

}

switch 语句， default放最后。如果没有break，程序会依此从上往下执行，直到执行完 default 后的程序（语句）, default后会完全执行玩。如果有break,则满足case遇到break跳出。

 

 

10，循环语句

break 与 continue

 

11,数组 ： 长度不可变，都有初始值

   数组名.length   属性

 

12，排序：冒泡 和 选择

/*冒泡排序

* 说明：相邻 两数之间的比较，每一趟出来一个数，该数不参与下一趟比较

* 重点：比较的趟数-->数组长度-1 （外大循环），每趟比较的次数-->数组的长度-第几趟（内循环）。

* i:第几趟；j：第几次 ；比较的两个数 下标 关系如下

*/

public static void maoPao() {

int[] arr = { 99, 28, 54, 88, 65, 12, 6, 9, 1 };

int b = arr.length;

for(int i=1;i<b;i++) {

for(int j=1;j<=b-i;j++) {

if(arr[j-1]>arr[j]) {

int temp=0;

temp = arr[j-1];

arr[j-1] = arr[j];

arr[j] = temp;

}

}

}

//遍历输出

for(int z:arr) {

System.out.print(z+",");

}

}

 

/*选择排序

*说明： 第一轮：第一个数与第2，3，4...n个数依次比较，每一轮出来一个数；

* 第二轮：第二个数与第3，4...n个数依次比较，每一轮出来一个数；

* 重点：比较的轮数-->数组长度-1 （外大循环），每轮比较的次数-->数组的长度-第几轮（内循环）。

* i:第几趟；j：第几次 ；比较的两个数 下标 关系如下

*/

public static void xuanZe() {

int[] arr = { 99, 28, 54, 88, 65, 12, 6, 9, 1 };

int b = arr.length;

for(int i=1;i<b;i++) {

for(int j=1;j<=b-i;j++) {

if(arr[i-1]>arr[i-1+j]) {

int temp=0;

temp = arr[i-1];

arr[i-1] = arr[i-1+j];

arr[i-1+j] = temp;

}

}

}

//遍历输出

for(int z:arr) {

System.out.print(z+",");

}

}

/*选择排序

*说明： 第一轮：第一个数与第2，3，4...n个数依次比较，每一轮出来一个数；

* 第二轮：第二个数与第3，4...n个数依次比较，每一轮出来一个数；

* 重点：比较的轮数-->数组长度-1 （外大循环），每轮比较的次数-->数组的长度-第几轮（内循环）。

* i:第几趟；j：第二项的下标 ；比较的两个数 下标 关系如下

*/

public static void xuanZe2() {

int[] arr = { 99, 28, 54, 88, 65, 12, 6, 9, 1 };

int b = arr.length;

for(int i=1;i<b;i++) {

for(int j=i;j<b;j++) {

if(arr[i-1]>arr[j]) {

int temp=0;

temp = arr[i-1];

arr[i-1] = arr[j];

arr[j] = temp;

}

}

}

//遍历输出

for(int z:arr) {

System.out.print(z+",");

}

}

 

13，遍历，foreach:

    语法： for(数据类型 变量名 ： 数组名 或 集合名 ){     }

 

14，二维数组 或 多维数组

    语法： int[][] a = new int[3][4];

            A[0][0] = 10;

a.length 得到的是 行的数量，是外下标。

    二维数组的遍历 或 多维数组的遍历，从外到内，一层一层的遍历。

 

15，java之面向对象（java，万物皆对象）

    方法就是用来放代码的。（变量是用来放一个数据的。数组和集合是用来放一群数据的。）

    方法的创建

    语法：[修饰符]  void|数据类型  方法名（参数类型 参数名，......）{

                    方法体

}

方法的调用只能存在与方法中。main方法是主方法，是程序的入口。

 

16，return 的作用：

    a,返回数给调用者

    b,结束当前方法的执行，凡是位于return语句之后的代码，均不会被执行。（结束该段代码块）

 

17，类（对象的描述）：类是用来描述对象的，对象是用来解决问题的。

类 生成.class源文件，对象都是通过 它 来的；对象是类的实例（类实例化后为对象）。

    在java中，属性用变量来描述，功能用方法来描述。

定义类的语法：

 

    [修饰符] class 类名{

        属性；

[构造方法（构造器）]

        方法{}

}

 

18，三个过程： OOA ,面向对象分析；

               OOD，面向对象设计；

               OOP, 面向对象编程。

 

19，类与对象的关系： 类是对象的描述，也叫做对象的抽象；对象是类的实例（有详细数据的）。

 

20，成员变量（属性）：也叫全局变量。作用域在整个类中，从声明这个变量的地方开始，以后的任意位置均可使用。成员变量是有初始值的，如果没有显式的赋值，则初始值为默认值（与数据类型有关）。成员变量可以用修饰符修饰。

    备注：用 final修饰的成员变量必须显式的赋默认值（立马赋值），且值不能被改变（不能被重新赋值）。

 

21，功能：成员方法，只要成员方法有声明，则在该类中任意一个方法中均可以调用。

 

22，局部变量：定义在方法体 或 代码块中的变量，称之为局部变量。

              作用域在 方法体中。

              局部变量没有初始值，使用前须先赋值。

局部变量不可用 public 或 static，private等修饰符修饰，但是可以被final修饰。

被final修饰之后，只能被赋值一次（被final修饰过的变量其实是常量）。

 

23，final修饰测试：被final修饰的全局变量必须立马赋值；被final修饰的局部变量可以先声明再赋值，但只能被赋值一次。（否则会抛运行期异常）

 

24，构造器（构造方法）

    构造器是用来创建对象的。构造器是一种方法(比较特殊的)

    声明构造器的语法:

        [修饰符] 类名 （[参数类型 参数名，......]）{  方法体 }

构造器必须无返回值，他的名字和类名一致（构造方法不能被继承的原因之一）。

一个类中如果没有显式的提供构造器，则java会提供一个默认的无参构造器，如果一个类中显式的提供了构造器，那么java就不在提供无参构造器。

如果这时还需要无参构造器，就必须写一个无参构造器。

 

25，方法的重载：在同一个类中定义了多个方法名相同，但是参数类型不同的方法，那么这个过程叫做方法的重载，这些方法叫做重载的方法。

    规则：a,在同一个类中

          b,方法名相同

          c,参数不同（参数个数不同； 或 参数类型不同； 或 不同类型的参数顺序不同）

26，jvm（java虚拟机）中三大内存空间：

    a，栈内存：每运行一个方法，就会在栈中申请一个空间，用来保存方法中的变量；如果变量数据类型是基本数据类型，则栈中保存的是真是数据；如果是引用数据类型（String例外），则栈中保存的是该对象在内存中的地址（指向引用）。

    栈内存：只有一个出口，先进后出。

    String字符串类型（被final修饰的类），有字符串常量池。

   

    b,堆内存：每次创建一个对象，就会在堆内存中申请一个空间，用来保存对象的属性（全局变量）。如果是引用数据类型的变量，则栈内存中存的是该对象在堆内存中的地址。

 

    c，方法区（静态区）：所有类的方法都在方法区中保存。

 

27，this：

    每一个类中都有两个特殊的成员变量，this和super；

    this表示的是当前对象的引用，存储的是当前对象的地址；

this的作用：a，当成员变量和局部变量重名时，用this.变量名来表示成员变量。

             b,当一个构造器需要引用本类中的其他构造器时，可以使用 this([参数值，......]); 必须写在构造器的方法体中的第一行。

 

28，static关键字（静态的）

    Static修饰的成员变量叫做类变量，也叫做静态变量。

    静态变量是所有对象共享的，他不属于类，只要有一个对象去改变了该变量的值，那么在其他的地方出现的该变量的值也会发生相应的改变。

    推荐使用 类名.变量名 来访问静态变量。

 

    没有 static修饰的成员变量叫做实例变量，也有叫做对象变量的。推荐使用  对象名.变量名来访问实例变量。

 

Static修饰的成员方法：叫做类方法，也叫做静态方法。推荐使用 类名.方法名（[.....]）来访问。

 

没有static修饰的成员方法，叫做实例方法。使用： 对象名.方法名（[......]）来访问。

 

静态常量 ： static final double PI 

 

注意：静态方法只能调用静态方法，也只能访问静态变量；

      实例方法既可以访问静态方法和静态变量，也可以访问实例方法和实例变量。

 

Static修饰代码块:   static {   }

    有static修饰的代码块叫静态代码块，一般用作类变量（静态变量）的初始化。

    Static修饰的代码块在整个程序运行期间，只会被执行一次。

    静态代码块只能访问静态变量和静态方法。

 

没有static修饰的代码块，叫做实例代码块，可以初始化实例变量。

    实例代码块，每次创建对象的时候都会被执行一次。

    实例代码块既可以访问静态方法和静态变量，也可以访问实例方法和实例变量。

    在创建对象时，实例代码块优先执行（执行的顺序时源码编写的顺序），然后是构造器。

    代码块无名字，不可被访问。

 

29，java运行机制（说明了先有什么，后有什么）；[优先加载static修饰的（先于类加载），]

    Java程序运行时，将class文件加载到jvm内存中，同时加载的还有静态变量和静态方法，静态代码块；只有在创建对象的时候才会去加载实例变量和实例方法。

 

二

30，项目文件介绍：

1，包：是用来管理源文件的

    包的声明： package 包命；    //这行代码必须写在源文件的第一行

 

包 的命名： a,包名所有字母小写

            b,包名不能以java,javax开头

            c,主包名一般采用倒置的域名+工程名，例如：com.qianlima.testpackage

            d,一般采用多级包名，用 . 来分级

            e,包名也必须满足标识符的命名规则

        子包名：在主包名的基础上+功能名， 例如：com.qianlima.testpackage.utils

 

如果一个类中，需要用到其他包中的类 或 接口，就需要导包。（import关键字）；

    导入指定的类： import 包名.类名；

    导入一个包中所有的类:  import 包名.* ；

   

导包语句应该写在 包 的定义 和 类 的定义的中间

 

2，访问权限修饰符：

    a,private 私有权限： 被private修饰的成员变量和成员方法只能在本类中进行访问，其他类均不能访问。他是访问权限最小的一个。

 

    b,(default) 默认权限： 当成员变量和成员方法没有显式的指出访问权限时，是默认的访问权限。默认的访问权限修饰的成员变量和成员方法，在本类中可以访问，同一个包中的其他类可以访问，非同一个包中的其他类不能访问。

 

    C,protected 受保护的 权限： 在没有继承关系的情况下，访问权限和默认权限一致，如果有继承关系，那么与该类不在一个包的子类也可以访问被protected修饰的成员变量和成员方法。

 

    D，public 公共的权限： 所有的类均可以访问被public修饰的成员变量和成员方法。Public是访问权限最大的一个。

 

* ,引用数据类型作为方法的形参时，则调用方法时，传的实参是一个对象。

 

 

31，面向对象的3大特点：封装，继承，多态。 （抽象）

1，封装： 对属性和方法的封装；

    将属性私有化，同时提供公共的方法，让外界可以设置属性的值 或 得到属性的值（get 和 set 方法）。

    对方法的封装，将不需要暴露给外界的方法用private修饰。

 

2，继承： 作用，减少代码冗成

    将具有相同属性和方法的多个类的这些相同属性和方法抽取出来形成一个新的类，其他的类继承这个新的类，这个新的类叫做父类，继承子这个新的类的其他类叫做他的子类，子类具有父类非私有的属性和方法。注:子类不能继承父类的构造器（因为构造方法名与类名一样）。

 

备注：java中，所有的类都直接 或 间接的继承了Object类，如果没有显式的指出一个类的父类，那么该类的父类就是Object（超类）。

 

关键字：extends；

继承语法：  [修饰符]  class  子类名 extends 父类名{  }

 

子类可以扩展自己的属性和方法

继承关系注意点：不要为了获得某种功能去随意的继承，子类和父类之间有一定的从属关系，子类是父类的一种。如：狗（子类）是动物（父类）的一种。

 

继承关系的特征：

    A,java中只支持单继承，即一个子类只能有一个父类。

    B,java中支持多层继承（继承体系）。

C,java中只能继承父类 非私有的属性和方法，不能继承父类的构造器。

 

访问权限修饰符对继承的影响：

    A,protected  被protected修饰的成员变量和成员方法，可以被非同包的子类访问。

    （测试证明以下内容是错的，实际上是可以访问的，jdk1.8）

    B,如果测试类与子类在同一个包中，与父类不在一个包中，那么，测试类中的子类对象不能直接访问继承自父类被protected修饰的成员变量和成员方法。

    C,如果测试类与子类不在同一个包中，与父类在同一个包中，那么，测试类中的子类对象可以直接访问继承自父类被protected修饰的成员变量和成员方法。

 

*，方法的重写： 当子类从父类继承过来的方法不能满足子类需求的时候，那么子类可以重写父类继承过来的方法。

    规则：1，子类方法是从父类继承过来的。

          2，不能改变其返回值的数据类型，不能改变参数。

          3，访问权限要大于或等于父类的权限。

          4，不能比父类抛出更多的异常（更大范围的异常）。

 

*，子类对象创建流程：当创建子类对象时，会默认创建父类；在子类的构造器中第一行有一行隐式的语句  super();  隐式调用父类的无参构造器。

 

*，super()关键字：

    每一个类中，都有两个特殊的成员变量，一个是this 代表当前对象；一个是super 代表父类对象。

    Super的三大作用：

        1，当子类的构造器需要显式调用父类构造器时，用super（实参1，...）；

        注意：super（实参1，...）； 语句必须写在子类构器方法体中的第一行。显式的调用父类构造器时，不能调用自身构造器（因为都得写在第一行）。

        2，当子类属性和父类属性发生重名的时候，可以使用 super.属性名 来表示父类的属性。

        3，当子类中重写的方法需要调用父类的方法的时候，可以使用super.方法名（参数，...）； 来调用。  当子类中的方法与父类的方法发生重名的时候，可以使用super.方法名（参数，...）；来表示父类对象的方法。

 

3，多态，一种事物的多种形态。

    ①方法的多态： 重写，重载。

    ②变量的多态（对象的多态）

        向上转型

        向下转型

A,（变量的）向上转型：父类变量可以直接保存子类对象的引用，

    语法： 1，优化写法 ： 父类名  对象名 = new 子类名（）；

            2， 子类名 对象名1 = new 子类名（）；

                父类名 对象名  = 对象名1；

    注意：  向上转型后，不会保留子类扩展的属性和方法。

            向上转型后，会保留子类重写的方法。

            向上转型后，会保留父类非私有的属性和方法。

 

B,（变量的）向下转型：子类变量可以保存父类对象的引用（但是需要显式的指出子类的类型）

    注意：在向下转型之前，一定要先进行向上转型。

   

三 ，抽象类，接口，内部类

一：抽象类 ，关键字 ：abstract

1，当父类不知道子类的方法的具体实现的时候（即不知道子类的方法体的内容），就可以将这个方法定义为抽象方法。

    语法： 抽象类：

            [修饰符] abstract class 类名 [extends 父类名]{  变量  方法   }

         

 抽象方法：

            [修饰符] abstract void|数据类型 方法名（参数类型 参数名）；

注意：抽象方法的修饰符不能是private和final。

    抽象方法没有方法体（没有{ }）。

    抽象方法必须存在于抽象类中。

 

备注：  1，抽象类不能用来创建对象（不能new）

        2，抽象类必须要有子类继承。

        3，抽象类的子类必须重写抽象类中所有的抽象方法，并给这个方法加上方法体。

            重写规则：将抽象方法中的 abstract 关键字去掉，并加上方法体（方法的具体实现）。

        4，抽象类有构造器，抽象类可以有具象方法，也可以有抽象方法。

        5，抽象类中不一定有抽象方法，但是抽象方法一定要在抽象类中（有抽象方法的类一定是抽象类）。

 

二，接口

    定义：和抽象类一样，也是程序编码过程中的约定，可以降低代码耦合性， 接口是一种比抽象类更抽象的存在。

在jdk1.8以前，接口中只能存在常量和抽象方法，在jdk1.8及以后可以存在具象方法，

具象写法： public default void|数据类型 方法名（[参数类型 参数名，...]）{

    方法体

}

 

如果是静态的，将default改为static即可，访问推荐是 接口名.方法名（）；

1，定义接口的语法， 关键字 interface；

    [修饰符] interface 接口名{   方法体  }

    注：接口中的属性（是常量） 默认被 public static final 修饰。

        接口中的方法（是抽象方法） 默认被 public static final修饰。

 

实现类：接口的使用，需要类去实现接口，实现类必须重写接口中所有的抽象方法，否则这个类只能定义为抽象类。

    接口的实现类：  [修饰符] class 类名 [extends 父类名] implements 接口名1，接口名2，...  {   必须重写所实现的所有接口的所有抽象方法  }

 

    接口与接口之间的继承，是多继承，一个接口可以继承多个父接口。

    语法： [修饰符] interface 子接口名 extends 父接口名1，父接口名2，...{   }

    注：一旦子接口继承了父接口，那么，那个子接口就拥有了所有父接口中所有的常量和抽象方法。

 

思考题：1，接口和实现类之间能不能进行向上转型和向下转型？ 

        答：可以。

        2，向上壮行之后能保留什么？

        答：接口中的常量和被重写的方法。

 

final关键字：1，修饰类：类不能继承

              2，修饰变量：该变量为常量

              3，修饰方法：该方法不能重写

• final类不能被继承，没有子类，final类中的方法默认是final的。 
• final方法不能被子类的方法覆盖，但可以被继承。 
• final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 
• final不能用于修饰构造方法。 

注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类

final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2、final方法 

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。使用final方法的原因有二：

①把方法锁定，防止任何继承类修改它的意义和实现。 

②高效，编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。 

 

 

关键字  intenseof  检查是否为继承关系（同类或 父子类关系）

 

三，内部类：定义在类中的类叫做内部类

    成员内部类，

    静态内部类，

    局部内部类

    匿名内部类

内部类和外部类一样，可以继承，有接口。

    + [extends 父类名] + [implements 接口名1，接口名2，...]

 

1，成员内部类

    成员内部类的访问：

        A，在外部类中访问内部类：

            可以直接将内部类声明为成员变量，进行使用。

            可以将内部类声明为局部变量，进行使用。

        B，在其他类中访问一个类的成员内部类：

            创建外部类对象

                外部类类名 （外部类）对象名 = new 外部类类名（[参数，...]）；

            使用外部类对象创建内部类对象

外部类名.内部类名  （内部类）对象名 = 外部类对象名.new 内部类类名（[参数，...]）；

            调用内部类对象的方法

                内部类对象名.方法名（[参数，...]）；

 

*，成员内部类使用注意事项：

    1，内部类可以直接访问外部类的成员变量。

    2，当内部类的变量与外部类的成员变量发生重名时，可以使用 外部类名.this.变量名 来表示外部类的成员变量。

    3，当内部类中的方法名与外部类的成员方法发生重名时，可以使用 外部类.this.方法名（）  来访问外部类的成员方法。

    4，成员内部类的成员变量和成员方法不能使用 static 修饰。（运行机制导致）

    5，凡是可以修饰成员方法的修饰符，均可以用来修饰成员内部类。

 

2，静态内部类（就是被static修饰的成员内部类）

   

静态内部类的使用：

    1，只有静态内部类的成员可以使用static修饰。

    2，静态内部类的成员只能访问外部类的静态成员，访问方式  外部类.变量名； ，

外部类.方法名（[]）； 。

    3，外部类是否可以访问静态内部类成员？

    答：可以。外部类可以通过 内部类名.变量名 来访问 静态内部类的静态变量，可以通过 内部类名.方法名（） 来访问静态内部类的静态方法。

 

静态内部类可以直接声明为外部类的成员变量，使用静态内部类可以声明为外部类的局部变量进行使用。

 

在其他类中如何访问静态内部类？

答：1，直接创建内部类对象

        语法：外部类.内部类名 内部类对象名 = new 外部类名.内部类名（）；

 

    2，调用静态内部类对象的实例方法

        内部类对象名.方法名（）；

在其他类中如何访问静态内部类的静态成员？

    外部类.内部类 静态变量；

    外部类.内部类名.静态方法（[]）；

 

3，局部内部类（鸡肋）

    定义在方法体或者代码块中的类叫做局部内部类，局部被不累是不能被其他类访问的。

注意：1，凡是对局部变量有的限制，同样适用于局部内部类。

      2，局部内部类不能修改与之再同一个代码块中的变量的值，final修饰的除外（变量名不能重名）。

      3，局部内部类的作用域：从定义他的地方开始，直到代码块的结束。

      4，局部内部类的使用 一定要在定义完成之后。

 

4，匿名内部类

    1，匿名对象：没有名字的对象。

        匿名对象只能被使用一次。

如：new 类名（[]）.方法名（[]）； //匿名内部类的创建及使用

 

    2，匿名内部类（只能使用一次）：是内部类的一种简写形式，只能且必须继承一个父类或者实现一个接口。

    语法： new  父类名 | 接口名（）{

                类体

                必须重写父类或者接口中的所有的抽象方法，可以扩展自己的属性和方法

}.方法名（）；

 

注：匿名内部类可以访问外部类的成员变量和成员方法。

 

 

四，补充

1，递归算法： 比较耗栈内存，计算机运行的步骤较多，效率较低。

    在不满足结束方法的前提下，方法体中会调用自身，如果满足就结束方法。（找出口）

 

2，Object类中有9大比较好用的方法，如：hashCode()，该方法返回对象在内存中的地址。

用==比较两个对象，实际上是比较两个对象在内存中的地址。

 

3，java中大概有23中经典的设计模式。

 

java的设计模式大体上分为三大类：

• 创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
• 结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
• 行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
•  

设计模式遵循的原则有6个：

1、开闭原则（Open Close Principle）

　　对扩展开放，对修改关闭。

2、里氏代换原则（Liskov Substitution Principle）

　　只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

3、依赖倒转原则（Dependence Inversion Principle）

　　这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

　　使用多个隔离的借口来降低耦合度。

5、迪米特法则（最少知道原则）（Demeter Principle）

　　一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

　　原则是尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类的封装性，超类的方法可能会被子类修改。

 

常见的：工厂模式，代理模式，单例模式，迭代模式

 

    单例模式： 私有的，静态的，本类（当前类）。7中写法

1，声明一个 当前类的静态成员变量

2，将构造器私有化

3，提供一个公共的静态方法，返回 第一步声明的静态变量（当前类）。

 

五，java中常用工具类（jdk自带的）(待整理...)

java.lang.xxx

String：属性

方法

java.util.xxx

 

java.text.xxx

 

java.io.xxx

......

 

六，javaWeb 及 前端常用框架

 

七，java后台框架 与 缓存

 

八，数据库

 

九，服务器 (一般为linux)