循序渐进学java-创新互联

/-matool API查询网站

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：空间域名、虚拟空间、营销软件、网站建设、淮北网站维护、网站推广。

重点内容：

第一阶段：

变量：数据类型

运算符：二进制

控制结构：循环

数组排序和查找：数组

面向对象编程：成员方法，成员方法传参机制，构造器

面向对象编程（中级）：封装，继承，多态

第二阶段：

面向对象编程（高级）：类变量和类方法，接口，内部类

Exception：异常体系图，异常处理

常用类：string，stringbuffer，stringbuilder

集合：

泛型：自定义泛型

线程：线程使用，Synchronized，互斥锁

IO流：输入流，输出流

开发注意事项：

1一个源文件中最多只能有一个public类，其他类的个数不限

2如果源文件包含一个public类，则文件名必须按该类名命名

3.一个源文件中最多只能有一个public类。其它类的个数不限，也可以将main方法写在非public类中，然后指定运行非public类，这样入口方法就是非public的main方法

/r为回车：回车后光标会回到“韩”字前，然后“韩顺”被“北京”代替

使用tab键，实现缩进，整体右移。Shift+tab整体左移。

相对路径和绝对路径：

加号的说明：

两边都是数值型的时候做加法运算，左右两边有一方为字符串时做拼接运算

基本数据类型：

+byte

使用long类型时，需要在变量后面加一个‘l’或“L“

例：long a = 10l;

Java默认浮点型常量为double型，因此在使用float型时需要在变量后面加上l或L

例：floa a = 1.1l;

浮点型可以写成.123 等价于0.123

对于运算结果时小数的进行判断时，应该用两个数的差值的绝对值，在某个精度范围内判断。

不同的字符编码表之间有所不同：

ASCII编码表：一个字符一个字节

Unicode编码表：字母和汉字都占用两个字节（最多编码2的16次方个字符）

utf-8：字母一个字节，汉字三个字节

等等。

布尔类型（boolean）：赋值只能为true/false

在将精度（容量）大的数据类型转换成精度（容量）小的数据类型时会报错。

（Byte，short）和char之间不能相互转换，也不能自动转换

Byte，short，char之间或者同类型之间进行运算时，会转换为int类型。

Boolean不参与类型的自动转换。

字符串和其它数据类型之间的转换：

其它类型转字符串：+“”

字符串转其它类型：

取模：a % b =a-a/b*a;

结果的正负值要取决于a的负号。

重点：

关系运算符的运算结果为布尔类型：即ture或false

短路与：&& 逻辑与：&

对于短路与，如果第一个条件为假，则后面的条件不再判断，即不执行，效率高

对于逻辑与，如果第一个条件为假，后面的语句仍会执行

短路或：|| 逻辑或：|

效果同短路与和逻辑与

^：逻辑异或

复合赋值运算符会进行类型转换

byte b = 3;

b +=2;等价于b = (byte)(b+2);

输入的实现：

1引入java.util.Scanner，java.util下的Scanner类

2.创建一个类的对象,new创建对象

Scanner myScanner = new Scanner(System.in);

3.接收

String name = myScanner.next();输入为字符串类型

int age = myScanner.nextInt();输入为整形

double salary = myScanner.nextDouble();输入为浮点型

四种进制：

二进制：以OB或Ob开头

八进制：以数字0开头

十六进制：以OX或Ox开头 ，并且A-F不区分大小写

按位与：&

按位或：|

按位异或：^

按位取反：~

位运算符：

>>算数左移：地位补0

<<算数右移：高位补符号位

>>>逻辑右移：地位溢出，高位补0

没有逻辑左移

switch：返回类型必须是byte,short,int,char,enum,String类型之一。

case：值必须为常量或者常量表达式

break后面加标签：可以表示终止某个循环，类似于goto

判断两个字符串：推荐第二种

如：String name;

Name.equals(“字符串内容”)或”字符串内容”.equals(name)

数组：

数组类型[ ] 数组名 （[ ]）= new 数组类型[个数]

double[] score = new double[5];

或

double score[];

score = new double[5];

数组赋值：arr2是arr1的一份拷贝，当arr2改变时，arr1也改变

冒泡排序：优化：j初始值为1，增加count变量，若执行一次交换则count增加，若count在循环后为0则提前终止循环。

动态开辟二维数组空间：

面向对象（基础）：

对象中的整型放在堆区，字符串类型放在方法区中的常量池。

过程：

1先加载类信息（属性和方法信息，只会加载一次）

2在堆中分配空间，进行默认初始化

3把地址赋给用类创建的变量，变量指向对象

4.进行指定初始化

方法重载：减轻记名麻烦

要求：方法名相同，形参的类型或个数或顺序不同。

注意：返回类型不同不能构成重载。

可变参数，写法（变量类型... 变量名）

可以接受0-多个参数，此时的变量名相当于数组名，可以用变量名.length获得参数个数，用变量名[i]访问每个变量。

细节：

可变参数的实参可以为数组，即直接传入一个数组。

可以同时存在普通类型的参数和可变参数，但是可变参数必须在最后。

一个形参列表中只能出现一个可变参数。

作用域细节：

属性和局部变量可以重名，访问时遵循就近原则。如：

此时name的值为“king”

全局变量可以加修饰符

局部变量不能加修饰符

构造方法/构造器：完成对新对象的初始化，类似于构造函数

细节：

一个类可以定义多个构造器，即构造器重载

This指针：当构造方法中的形参的类的对象名字相同时，可以在对象前加this.来区分

在一个构造器中访问另一个构造器时（本类），需要使用this（参数列表）

注意：需要将this语句放在第一条语句，只能在构造器中使用。

在需要获取数组的大值时，为了避免传入的数组为空值，或者数组地址为null时，需要加上判断，当地址为null时，arr.length语句会报错。

直接new 类名（），此方法只创建一个对象，而没有返回，属于匿名对象，匿名对象在使用后，就不能使用。

IDEA中的快捷键：

Ctrl+D 删除当前行（自己配置）

Alt+/ 补全代码

Ctrl+alt+l 格式化代码

Alt+r 运行程序（自己配置）

将光标放在方法上，ctrl+B（或鼠标左键）可以定位到方法

模板快捷键：

Fori，输出for循环

Sout，输出System.out.println语句

包

创建不同的文件夹来保存类文件

方法如下：

命名规则：不能以数字开头，不能是关键字或保留字。

命名规范：com.公司名.项目名.业务模块名

如：

Arrays.sort（数组名），对数组进行升序排列。

Package的作用是声明当前类所在的包，需要放在类（或者文件）的最上面。

类只能用public和默认来修饰。

类的成员方法和属性可以用四个来修饰。

封装：

可以隐藏实现细节

可以对数据进行验证，保证安全合理

实现：

将属性私有化

提供一个公共的set方法，用于修改私有属性的值

提供一个公共的get方法，用于获取私有属性的值

构造器也同样需要对数据进行检测，因此可以把set方法写入构造器中，实现对数据赋值的同时完成验证。

继承：

可以解决代码复用。

基本语法：

class 子类（派生类） extends 父类（基类）{}

细节：

子类必须调用父类的构造器，完成对父类的初始化

子类在调用构造器时，会自动调用父类的无参构造器，super语句（被隐藏）

若父类中无无参构造器，则需要用super语句指定构造器

super()和this()都只能放在构造器第一行,因此这两个方法不能共存在一个构造器。

Object类时所有类的基类

父类构造器的调用不限于直接父类！将一直追溯到Object类，即父类的父类的无参构造器也会被调用等。

Java中是单继承机制，即一个类只能继承一个，可以用A继承B，B继承C，来实现A同时继承B和C。

继承访问：

此时aa.name的值为大头儿子，aa.hobby的值为旅游：以此方法在访问变量时，会从当前类开始寻找，若当前类没有，会依次往上寻找，直到找到为止或报错。

此时aa.age会报错，在Father类中有age但是没有权限，不会再往上寻找。

Super的使用：（访问父类）

super.语句，访问父类属性和方法，private属性除外

访问父类构造器

语句：super（）；

方法重写（覆盖）：

实现条件：子类和父类的方法，参数，方法名均相同。此时子类的方法覆盖父类的方法。

1返回类型可以相同，或者子类的返回类型是父类返回类型的子类。如：

String是Object的子类

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

错误示例：子类是protected，父类是public。

多态：

方法的多态：体现在方法的重载和重写

对象的多态：

一个对象的编译类型和运行类型可以不一致。

编译类型看定义时 = 号的左边，运行类型看 = 号的右边

animal1的编译类型时animal，运行类型时cat。

此时animal1.cry（）相当于cat.cry（），因为animal的运行类型时cat。

重新指定后：

animal1的编译类型依然是animal，运行类型变为dog。

细节：

1向上转型：父类的引用指向了子类的对象。如上图举例。

2向下转型：

animal可以通过强转再次变成cat类型，因为animal本身在编译后为cat类型，但是不能转换成dog类型。

属性没有重写之说！属性的值看编译类型，如下图输出结果为10.

Instaniof语句，用于判断对象的运行类型是否是XX类型或其子类型。

动态绑定机制：

1当调用对象方法的时候，改方法会和该对象的内存地址/运行类型绑定

2当调用对象属性时，没有动态绑定机制，哪里声明哪里使用

多态数组：如

Object类：

==运算符：判断两个值是否相等，或是两个地址是否相同

equals是Object类中的方法，只能判断引用类型地址

查看方法源码：ctrl+左键

注意：

在Object子类中往往重写改方法，用于判断内容是否相等。

HashCode方法：

1提高具有哈希结构的容器的效率

2两个引用，如果指向的是同一个对象，则哈希值肯定是一样的，如果不是，则哈希值肯定不一样。

3哈希值主要根据地址号来，但是不完全等价于地址

Tostring方法：

方法重写后：把对象的属性输出，也可以自己修改

直接用sout输出一个对象等价于sout 对象名.toString

Debug断点调试：可以在调试过程中加断点

F8逐行执行

F7跳入方法（查看方法）

Shift+F8跳出方法

F9直接跳到下一个断点

零钱通：

日期显示：

类变量：

用static修饰的变量，是类共有的变量，可以通过类名来访问。同时需要遵守访问修饰符的权限。

类方法和类变量相似。

细节：

类方法中不能使用和对象有关的关键字，如this和super。

类方法只能访问静态变量或静态方法。

要在静态方法中访问，非静态方法或变量的话，可以通过在静态方法中new一个类，通过类访问非静态成员。

main方法：

由java虚拟机调用，而虚拟机所在为不同类，因此为public

Java虚拟机在执行main方法时，不必创建对象，所以为static

Java执行的程序，参数1，参数2，参数3，作为三个字符串数组传入args数组中

代码块：

（修饰符（static））{

代码

}（；）

代码块在构造器被调用时优先执行。

当有static修饰时，代码块随着类的加载而执行，并且只会执行一次

普通代码块：在对象创建时执行（new）

类的加载：在创建对象实例时（new）

创建子类对象实例，父类也会被加载（父类先加载）

使用类的静态成员时

创建对象时：在一个类中调用顺序：

（1）使用new创建对象之后，静态代码块和静态属性初始化调用的优先级一样，哪个在前先调用哪个，如上图先调用静态代码块。多个静态代码块和多个静态属性初始化的调用顺序同样。

（2）普通代码块和普通对象初始化，顺序同上

（3）调用构造方法

构造器代码顺寻：

（1）.父类构造器

（2）本类代码块

（3）本类构造器代码

总结：先执行静态（先父类后子类），再普通（先父类后子类）。

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

单例模式-饿汉式：

1将构造器私有化

2在类的内部直接创建

3提供一个公共的static方法，返回对象

缺点：创建了对象但是没有使用，造成资源浪费

单例模式-饿汉式：

1构造器私有化

2定义一个static静态对象

3提供一个public的static方法，可以返回一个对象

4当用户使用getInstacnce时才返回对象，再次使用时返回同一个对象。

final关键词：

1可以用来修饰类：使类无法被继承（不希望被其中方法被重写）

2修饰方法，使方法无法被改写

3修饰属性，使属性无法被修改

4修饰局部变量，使无法被修改

细节：

1被final修饰的变量，需要在进行初始化,如在定义时,通过构造器，通过代码块

如果还有static修饰，则不能在构造器中赋值（代码块为静态）

2.final不能修饰构造器

3..final和static搭配使用，效率更高，不会导致类加载

4.包装类都是final类型，如String

抽象类：

当父类的一些方法不能确定时,用abstra修饰该方法。

1. 用abstra修饰的方法没有方法体

2. 抽象类不能被实例化（不能通过new的方式创建）

3. 抽象类可以没有抽象方法，有抽象方法的类必须是抽象类

4. abstra只能修饰类和方法

5. 抽象类本质还是类，可以有任意成员

6. 当一个类继承抽象类后，它本身必须是一个抽象类或者实现父类中所有的抽象方法

7. 抽象方法不能被private，final，static关键词修饰

接口：

interface 接口名{}

class 类名 implements 接口{

自己的属性

自己的方法：

必须实现的接口的抽象方法

}

细节：

8. 接口不能被实例化（即new）

9. 接口中的方法都是public方法，抽象方法可以不用abstra修饰

10. 一个普通类实现接口，必须将改接口所有方法实现，可以使用alt+enter

11. 抽象类去实现接口时，可以不实现接口的抽象方法

12. 一个类可以实现多个接口

13. 接口中的属性都是public static final 修饰符

14. 接口可以继承接口，不能继承类

15. 接口的修饰符只能是public或者默认，和类相同

接口可以解决单继承的问题

内部类：

16. 局部内部类：

即在类中的一个方法中的类，该类可以直接访问外部类所有的成员（包括私有），不能使用修饰符（本质上是局部变量），但是可以用final修饰

作用域：仅仅在定义它的方法或代码块中。

外部类在方法中可以创建内部类对象，然后调用成员

当外部类和内部类的成员重名时，访问时默认遵循就近原则，可以通过外部类.this.成员，来访问

匿名内部类：

是一个类，同时是一个对象。是一个局部变量。

作用：简化开发

匿名内部类的本质是一个匿名类继承一个类或者实现一个接口

第二个演示表示匿名内部类是一个对象。

匿名内部类可以当作实参直接传递

创建内部成员类的方法：

2.

静态内部类：

是类的成员，遵循相同的访问规则。

枚举：

将构造器私有化，删掉set方法，将定义常量对象写在前面。

细节：

创建枚举对象时，自动继承了Enum类。

成员必须放在前面，且用逗号隔开，最后一个用分号。

如果调用的构造器是无参时，“（）”可以省略。

Enum的成员方法：

name()返回成员名称

ordinal()返回成员序号（从0开始）

values()返回成员数组

可以通过增强for循环来实现遍历

valueOf（“常量名”）,在枚举中寻找该常量名

常量1.compare To（常量2），返回得到常量1的编号减常量2的编号。

注解：

如：重写方法上的@Override

只能用在方法上，可以删掉，加上后编译器会检验方法是否被重写。

@Deprecated

可以修饰方法，类，字段，参数等到，用于做版本升级过渡

@SuppressWarnings

用于抑制警告，可以使用@ SuppressWarnings（{“all“}）抑制所有警告，也可以换成其它类型用于抑制相应类型的警告。

异常处理：

当程序出现一个异常后，可以让程序继续向下执行

使用ctrl+alt+t对可能出现异常的代码块进行异常处理。

细节：

当异常发生时，异常后面的代码不再执行，直接跳入catch代码块中

如果异常没有发生，则catch代码块不执行

finall代码块无论如何都会执行

可以没有catch，只有try和finally，此时若发生异常，程序会在执行完finally后结束。

Finally代码块必须执行，虽然在catch中返回3

Throws：

Throws的对象可以是异常类型本身也可以是它的父类

子类在重写父类的方法时，抛出的异常类型要么和父类一致，要么是父类所抛出异常的子类异常

包装类：

精度提升，三元运算符是一个整体

包装类的转换

包装类中的方法：

String类

String类有很多构造器：

用finally修饰的变量指向的地址不可改变。

当常量池中有变量时

String字符串特性：

该语句创建了两个对象（若常量池中无haha）

说明：String时一个finally类，其内容不可改变。

编译器会优化：判断创建的常量池对象是否有引用的指向

等价于 Sting a = “helloabc”;

String 中的intern方法：

如果池中有“s1+s2“字符串，则返回该字符串的地址，若没有则创建一个该字符串

常用方法：

示例：如果找不到，则返回-1；第一次出现的位置。可以找字符串

从下标6开始截取字符串

前闭后开截取字符串

示例：

注意：原字符串没有被替换

StringBuffer:

直接父类：AbstractStringBuilder

父类中有属性 char[] value 不是final类型

StringBuffer是一个finally类，不能被继承

String转StringBuffer

StringBuffer转String

StringBuffer中的方法：

如果要对String进行大量修改，就不要使用String，考虑StringBuffer，如果是单线程同时考虑StringBuilder

Math方法：

round为四舍五入保留整数

Arrays类：

如果传入的值为负数，则会报错

System方法：

System.exit(0)

0表示程序正常退出

Src：原数组

0：从原数组开始拷贝的位置

Dest：目的数组

0：从目的数字开始拷贝的位置

处理大数和需要保持高精度计算时使用

Date：

Calendar：

Local：

集合：

ArrayList演示：

迭代器：

List接口：

17. 集合中的元素有序，且可以重复

18. 每个元素都有对应的索引

19. 可以根据其索引号来获取元素

ArraysList:

1.ArrayList基本等同于vector，效率高，但是不安全

2.ArrayList中维护了一个Object类型的数组

Transient表示该属性不会被序列化

20. 当创建ArrayList对象时，如果用的是无参构造器，则初始容量为0，第一次添加时数组扩容为10，如果需要再次扩容则扩容为当前容量的1.5倍。

21. 如果使用指定大小的构造器，则在需要再次扩容则扩容为当前容量的1.5倍。

Vector:

22. 底层依然是一个可变的数组

23. 安全，但是效率不高

24. 如果是无参，则在第一次添加后扩容为10,以后每次需要扩容为当前的2倍

ArrayList和LinkList都是不安全的

Set接口：

25. 无序，没有索引

26. 不允许重复元素

虽然取出的顺序不是添加的顺序，但是顺序是固定的。

可以用迭代器和增强for循环进行遍历，不能用普通for循环，因为没有get方法

HashSet底层是hashmap，是一个数组加链表的结构

27. 再添加一个元素时，先得到hash值，然后转换成索引值。

28. 根据索引值存放到数组对应的位置

29. 若对应的位置已有元素，则调用equals方法与元素进行比较，如果相同则放弃添加，如果不相同则添加到最后。

30. 当一条链表的元素个数超过8以后，并且table的大小>=64，就会进行树化。

31. 当添加的元素个数大于阈值（当前数组大小的0.75倍，数组初始化大小为16）时，数组会进行扩容，扩大为原来的两倍，同时阈值也会扩大为2倍。

Map:

32. 保存具有映射关系的数据

33. Key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中

34. Key不允许重复，否则会覆盖

35. Key和value都可以为null，但是key只能有一个，value可以有多个

5.k-v最后是HashMap$Nodenode = newNode（hash，key，value，null）

6.为了方便程序员遍历，还会创建EntrySet集合，该集合存放的元素的类型Entry，而一个Entry对象就有k，v，EntrySet>

7.entrySet中定义的类型是Map.Entry，但是实际上存放的还是HashMap$Node，因为Node实现了Map.Entry

8.当把HashMap$Node对象存放到EntrySet就方便我们的遍历，因为Map.Entry提供了重要的方法：getKey和getValue

遍历方式：

HashTable：

36. 键和值都不能为空，否则会抛出异常

37. 使用方法基本和HashMap一样

38. 每次扩容变为原容量的2倍+1，初始容量为11

Properties：

Treeset：有序，可以自定义

自定义比较器的作用：决定了数据的顺序，同时决定了数据能否被添加进去的规则，如上图：以长度升序排列字符串，如果有长度相同的情况则无法添加

Collection工具类：

下面的代码会报错，原因是在底层要尝试把加进去的对象转换成Comparable，对象没有实现comparable接口，因此会有转换类型的异常。

泛型：

1.为了约束数据类型

2.省去转型的麻烦

约束加入的类型只能为Dog

不用再向下转型

用来解决数据的安全性问题

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

泛型使用细节：

1.泛型指向的数据类型要求是引用类型，不能是基本数据类型。如：

Int是基本数据类型

2.在指定泛型后，传入的数据类型可以是其本身。也可以是其子类

3.使用形式：后面的括号里的内容可以省略，推荐这种写法

4.如果没有指定泛型，则默认为Object类型

自定义泛型：

1.泛型标识符可以有多个，一般都是大写字母

2.普通成员（属性，方法）可以使用泛型

3.使用泛型的数组不能初始化（因为数组在new时，不能确定类型，因此无法开辟空间）

4.静态方法中不能使用泛型（静态方法在类加载时，对象还未创建，无法完成初始化）

自定义泛型接口：

1.接口中，静态成员不能使用泛型

2.泛型接口的类型，在继承接口或实现接口时确定

3.没有指定类型，默认为Object

泛型在方法中的使用：

1.泛型方法可以定义在普通类中，也可以定义在泛型类中

2.当泛型方法被调用时，类型会确定

3.泛型方法，可以使用类声明的泛型类型，也可以使用自己声明的泛型

4.注意泛型方法和方法使用了泛型的区别

形如：

R要在参数中使用，在调用方法时，会根据传入的参数的类型，变化R的类型

Say1方法使用了泛型

Say2方法是泛型方法，同时也使用了泛型

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

文章题目：循序渐进学java-创新互联
当前地址：http://cqcxhl.cn/article/csgipo.html