java基础知识

第一章：

1.代码规范快捷键（要关闭输入法才能有效）：ctrl+shift+f。

2.大写：项目名，类名。 小写：包名 大写和小写:变量名(第一 个首字母小写其余首字母大 写)

3.\n：换行 \t：光标固定到下一个制表位

4.编写源代码，编译器编译成 .class文件，java虚拟机运行

5.项目重命名（alt+shift+r）

6.文本域注释:/** 多行注释:/**/ 单行注释://

*

*

*/

第二章：

1.变量：一个数据存储空间的表示。不同的数据存入不同的内存地址空间，相互独立。

2.四种基本数据类型：int(整型) double(双精度) char(字符型，单引号) string(字符串，双引号).

3.变量命名：字母，下划线，$符号 + 数字，下划线，字母，$符号（第一个单词首字母小写其余大写）

4.变量必须先声明并赋值才可以使用。String str="qwe";String str="fd"(不可以) String str="qwe"; str="asdf"(可以)

5.Scanner sc=new Scanner(System.in):创建可在控制台输入的一个对象（可以从键盘获取输入的信息）。

6.int+double(int类型自动向上转型为double);

7.强制类型转换:(类型名)表达式 int i=(int)10.2; float a=1.3f;(单精度)

8.算术运算符>关系运算符>逻辑运算符 最高优先级：小括号里的。 最低优先级：赋值运算符(=)

第三章：

1.StringBuffer和Object:没有复写equals方法.他的equals方法比较的是地址.String和StringBuilder复写了equals方法,他比较的是内容.

2.StringBuffer,String,StringBuilder区别:String 类型的字符串每次进行改变时都等同于生成了一个新的String对象速度慢浪费资源,StringBuffer是对 对象本身进行操作不生成新的对象速度快占用资源少。StringBuilder单线程安全，StringBuffer多线程安全。StringBuilder>StringBuffer>String

3.==和equals()的区别:

A:==

基本类型：比较的是值是否相同

引用类型：比较的是地址值是否相同

B:equals()

只能比较引用类型,但是我们可以根据自己的需要重写该方法。

4.Random rd=new Random; int a=rd.nextInt(23);产生0~23间的随机数.(包括0不包括23)

第四章:

1.switch(整型或字符型){

case 常量1: (switch用于等值条件判断,常量1不能是表达式,eg:2<常量1<23)

语句;

break; (break跳出switch循环)

case 常量2:

语句;

break;

default:

语句;

break;

}

第五章:

1.for(i=0,j=5;j>=1;i++,j--){} for循环.

2.break:跳出for,do-while,while循环执行循环后的语句,可以和if组合使用.if里使用break可以跳出for,do-while,while循环.

(switch循环中使用if,if里不要使用break,没意义)

3.continue:跳出当前循环执行下次循环.

4.break:跳出循环.

5.wai:for (int i = 0; i < arr.length; i++) {

nei:for (int j = 0; j < arr.length; j++) {

System.out.println("要离开我么(y\n)");

String str=sc.next();

if(str.equals("y")){

break wai;

}

}

}

第六章:

1.数组:存储相同类型的数据. int arr[][]=new int[][]{{1,3,2},{2,4,3}} int arr[][]={{1,3,2},{2,4,3}} int arr[][]=new int[5][]

int arr[]=new int[]{2,4,5} int arr[]={3,5,6} int arr[]=new int[5]

int arr[]=new int[]:这样写错误,声明一维或二维数组时必须指定行数.不可以指定行数的同时进行初始化.

eg:int arr[]=new int[3]{2,4,5}:错误.

2.Arrays.sort(数组名):对数组进行升序排列.

3.String str=""与String str=null区别:

(1)解释 string a=null ->创建一个变量a,但他没有初始化,因此没有任何值,又不等于空字符串值(就好象手

上没有东西与拥有0个苹果这样的微弱语意差异,因为也可以类似地解释成拥有0个梨),微软把它叫做NULL

,机器原理是它没有指向内存的某个位置,所以它不存在任何值

string a="" ->创建一个变量a,指向内存某个存储位置,并且该位置初始化有一个具体的字符串值,叫做

空字符串,即""或\0(字符串结束符号,任何字符串最后都以\0做结束)

(2)比较: 既然a=null是未初始化,如果对它进行某些操作, 比如它和"ABC"连接, 会引起系统错误,因为它还没有分配

内存给它,无法操作但a=""就不会有引发系统错误,它和"ABC"连接后等于"ABC", 因为可以通过a对某个内存

进行读取操作

(3)使用: 前面如果是a=null,后面要使用它,先直接赋值或赋指针就等于被初始化可以正常使用,而在程序运行过程中

,如果程序消耗内存比较大,那么我们要释放一些已不用的内存,如果a决定已不再用,那么可以用a=null来释

放它原来占用的内存

4.int arr[]=new int[0]与int arr[]=null的区别 和String str=""与String str=null的区别一样.

5.int arr[] = { 1,3,5,7,9,78}; arr=Arrays.copyOf(arr,arr.length+1);//数组扩容.

6.String s="asdaf"; char[] c=s.toCharArray(); //字符串变成字符数组

7.String常用方法：length():得到字符串长度. equals():比较字符串内容equalsIgnoreCase():比较字符串内容不区分大小写toLowerCase():转换成小写.

toUpperCase():转换成大写. concat()或+：连接字符串. indexOf(String str):从前往后搜索字符str第一次出现的位置，找到返回角标否则返回-1.

lastIndexOf(String str)：从前往后搜索字符str最后一次出现的位置，找到返回角标否则返回-1.

substring(int beginindex, int endindex)：提取beginindex和endindex之间的字符串部分不包括角标为endindex的字符

substring(int beginindex):提取从位置索引开始的字符串部分. charAt(int index):获取指定角标的字符。

trim():去除字符串前后的空格不包括中间的. split(String str):根据指定的分隔符对字符串进行分割。

8.StringBuffer常用方法(它具有String类型的所有方法)：append()：连接字符串. insert()：插入字符串. toString()：转换成String类型

第七章:

1.一个循环内又包含另一个完整的循环叫做二重循环.

2.插入排序,选择排序,冒泡排序. 二分查找,线性查找

***************************************************************************************************************************************

类 对象

第八章:

1.属性:对象具有的各种特征.每个属性都有特定值.

2.方法:对象执行的操作.

3.对象的属性和方法通常被封装在一起,共同体现事物的特征,二者相辅相成不能分割.

4.类是对象的类型.

第九章:

1.构造方法:访问权限修饰符+类名(){};没有返回值,方法名与类名相同;当你自己写了构造方法后系统不调用默认的构造方法,没写构造方法时系统认 的 构造方法;

2.方法重载:方法名相同,参数列表不同.(同一个类中)

3.方法覆盖:权限必须大于等于原方法.(子类中)

4.static:静态方法只可以访问静态方法和静态属性. 一般方法即可以访问静态方法和静态属性也可以访问一般方法和一般属性.

5.static只能修饰成员属性和成员方法不可以在成员方法中定义静态变量.静态代码块中的东西不能通过类名.或者对象名.直接访问到.

6.正则表达式使用顺序(常规):

Pattern p=Pattern.compile("[0-9]");//创建模板

Matcher m=p.matcher("23");//与模板比较

boolean b=m.matches();//比较结果

封装:

步骤:1.私有化成员属性. 2.创建公有的getter和setter方法. 3.在getter/setter方法中加入属性控制语句

继承: class extends

1.编写父类:公共的属性方法. 编写子类:子类特有的属性方法(也可覆盖父类中的方法).

2.子类构造方法默认调用父类无参的构造方法,当父类没有无参的构造方法时子类需要用super显示指明要调用的父类的构造方法.

3.多重继承关系的初始化顺序: 1. public class Test extends Parent {

2. private String name;

3. private int age;

4. public Test() {

5. name="Tom";

6. age=20;

7. }

8. public static void main(String[] args) {

9. Test t = new Test();

10. System.out.println(t.name + "的年龄是" + t.age);

11. }

12. }

13. class Parent {

14. private int num = 1;

15. public Parent() {

16. System.out.println("现在初始化父类");

17. }

18. public void test() {

19. System.out.println("这是父类的test方法");

20. }

21. }

上述类的基本运行顺序是：

先运行到第 8 行，这是程序的入口。

然后运行到第 9 行，这里要 new 一个 Test，就要调用 Test 的构造方法。

就运行到第 4 行，注意：初始化子类必先初始化父类。

要先初始化父类，所以运行到第 15 行。

然后是第 14 行，初始化一个类，必须先初始化它的属性。

然后是第 16 行。

然后是第 17 行，表示父类初始化完成。

然后是回到子类，开始初始化属性，因此运行到第 2 行，然后是第 3 行。

子类属性初始化完过后，才回到子类的构造方法，执行里面的代码，也就是第 5、6 行。

然后是第7 行，表示 new 一个 Test 实例完成。

然后回到 main 方法中执行第 10 行。

然后是第 11 行。

4.父类的静态变量->父类的静态块->子类的静态变量->子类的静态块->父类的实例化变量->父类的实例化块->父类的构造函数

->子类的实例化变量->子类的实例化块->子类的构造函数.(父类属性->父类构造方法->父类属性->父类构造方法)

5.super关键字来访问父类的成员:

super只能出现在子类的方法和构造方法中

super调用构造方法时，只能是第一句

super不能访问父类的private成员

6.final修饰符:

修饰的类，不能再被继承

修饰的方法，不能被子类重写

修饰的变量将变成常量，只能在初始化时进行赋值

可以修饰对象.此时对象的属性可以随意改变,但不能重新new对象.

7.abstract 抽象类:

抽象类中可以没有抽象方法,但有抽象方法的类一定是抽象类.(抽象方法没有方法体).

抽象方法必须在子类中被实现，除非子类是抽象类.

抽象类必须被子类继承,才能实例化对象.

不想让某个类被实例化的时候用抽象类.

让某个方法必须被重写的时候用抽象类.

应用场合：限制实例化。

8.interface 接口(类与类之间是单继承,一个类可以实现多个接口.接口与接口之间是多继承.)interface implements

接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量.没意义.

接口中的变量会被隐式地指定为public static final变量并且只能是public static final变量

方法会被隐式地指定为public abstract方法且只能是public abstract方法

应用场合：实现与功能的分离。

多态:同一个引用类型,使用不同的实例而执行不同的操作.

1.向上类型装换:运行时使用父类的类型,子类的对象. Pet pet=new Dog();

2.对象 instanceof 类或接口 (用来判断对象是否属于某个类的实例,通常和强制类型转换结合使用.)

第十章:

1.异常：程序运行过程中发生的不正常事件，它会中断正在运行的程序。

2.捕获异常：

try {

执行可能产生异常的代码

}

catch(异常类型 e){

e.printStackTrace()//输出异常信息(全名包括位置名称)。

System.err.println("sds")//用户自定义异常信息。

System.out.println(e.getMessage())//输出异常信息(简单的信息)

捕获异常(产生异常执行的操作)

}

catch(异常类型 e){

//对异常进行处理的代码片段

}

finally{

无论是否发生异常是否有return代码总能执行，

当有System.exit(1)时，finally代码块不执行。

}

3.声明异常(方法体上)：

throws：声明方法可能要抛出的各种异常

4.抛出异常(方法体内)：

throw：在方法体内抛出异常对象

5.throw与throws区别：如果函数内使用throw抛出异常对象，那么必须要给出对应的处理动作，要么进行try-catch处理要么继续throws向上抛出。

如果函数上使用throws抛出异常，调用它的函数必须要给出对应的处理动作，要么进行try-catch处理要么继续throws向上抛出。

第十一章：

1.集合：集合可以存储任何类型.默认存储的是Object类型。

Collection List ArrayList LinkedList Set HashSet TreeSet Map HashMap TreeMap

2.Collection：存储一组不唯一，无序的对象. List:存储不唯一，有序(插入顺序)的对象. Set:存储一组唯一，无序的对象.

Map:存储一组键值对对象，键是唯一的，值可不唯一(无序）.

3.ArrayList:采用长度可变的数组，遍历元素和随机访问元素效率高. LinkedList:采用链式存储方式，插入，删除元素效率高.

4.add()：在列表的末尾顺序添加元素，起始索引位置从0开始。

add(int index,Object o)：在指定的索引位置添加元素，索引位置必须介于0和列表中元素个数之间

get(int index)：返回指定索引位置处的元素，取出的元素是Object类型，使用前需要进行强制类型转换

contains(Object o)：判断列表中是否存在指定元素 remove(Object o)：从列表中删除元素

remove(int index)：从列表中删除指定位置元素，起始索引位置从0开始

clear()：从此列表中移除所有元素 size():返回此列表的元素数.

5.Iterator:迭代器用来遍历集合. for(String string:args){}:也可以遍历集合。

6.Map接口常用方法：

put(Object key, Object val)：以“键-值对”的方式进行存储

get(Object key)：根据键返回相关联的值，如果不存在指定的键，返回null

remove (Object key)：删除由指定的键映射的“键-值对”

keySet()：返回键的集合 values()：返回值的集合

containsKey (Object key)：如果存在由指定的键映射的“键-值对”，返回true

containsKey (Object key)：如果存在由指定的键映射的“键-值对”，返回true

第十二章:

1.字节输入流：InputStream. 字节输出流:OutputStream

2.字符输入流：Reader 字符输出流：Writer

3.把文件按字节读取：FileInputStream, FileOutStream 把文件按字符读取：BufferedWriter,BufferedReader

4.在读写文件的时候需要对内容进行处理，比如比较特定字符等一般会选择字符流。只是读写文件，和文件内容无关的，一般选择字节流。

5.BufferedWriter file=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("./Test.txt")))

6.BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("./Test.txt")));

FileInputStream in=new FileInputStream("./Test.txt"); FileOutputStream out=new FileOutputStream("./Test.txt");

7.当对同一个文件进行读和写操作时，创建的输入流和输出流对象不能写在一起。(先对文件进行写操作创建输入流对象写完了，再进行

读操作创建输出流对象，不要把创建两个对象的代码写在一起)

8.输入输出流是相对于计算机内存来说的