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

一

1，html中的注释：

注释不可以嵌套

代码都得有注释。

2，空格符：

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

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

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

cd 文件名 ：进入指定目录

cd..：退回到上级目录

exit：安全退出dos命令窗口

cls：清屏

盘符： 切换到指定盘

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

6，标识符（命名）：

a，合法的标识符：

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

不可以以数字开头

不可以是单独的_或者者$

不可以是关键字 或者 保留字，不可以是 mian

区分大小写

b，正当的标识符：

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

Java中一般采使用驼峰式命名

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

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

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

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

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

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

8，运算符：三目运算符 __ ? __ : __ （结果是什么类型即可以使用什么类型接收）

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

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

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

9，swith语句

Swith （）{

case xxx :

case xxx : [break;]

default :

}

dfault ,无论如何都是最后执行。

10，break 与 continue

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

数组名.length 属性

12，排序：冒泡 和 选择

13，遍历，foreach:

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

14，二维数组 或者 多维数组

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

A[0][0] = 10;

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

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

15，java之面向对象

方法就是使用来放代码的。

方法的创立

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

方法体

}

方法的调使用只可以存在与方法中。

16，return 的作使用：

a,返回数给调使用者

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

17，类（对象的形容）：类是使用来形容对象的，对象是使用来处理问题的。

在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中经典的设计模式。

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

1，公告一个 当前类的静态成员变量

2，将构造器私有化

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