java se学习总结（自用）

第一章 开发前奏

1、常用dos命令

盘符： 进入指定的盘下面，例如： d： 进入d盘

操作文件夹：

dir: 列出当前控制台所在的路径下的所有文件以及文件夹

cd 路径 : 进入指定路径下

cd..: 退回到上一级目录

cd\: 退回到根目录

md 文件夹的名字: 创建一个文件夹

rd 文件夹的名字: 删除一个空文件夹   注意：rd不能删除非空的文件夹，而且只能用于删除文件夹。

操作文件：

type 文件名：查看指定文件内容，例a.txt

del文件名 : 删除指定的文件  注意：del后面如果跟一个文件夹，那么是删除一个文件夹中的所有文件。

*:  是通配符（可以匹配任意的文件名）

其它：

exit :关闭dos命令

cls  : 清屏，通知计算机将当前的命令清空

tab  ：命令补全

上下方向键：找回上次你写过的命令

 

2、注释

文档注释   （编写软件说明书）

1. 需要使用sum给我们提供的javadoc工具生成一个html的说明文档。
2. 只能抽取public的属性或者方法内容。

格式：

Javadoc –d 指定存储文档的路径  -version –author（可选）  目标文件

@author 作者

       @version 版本

       @param 方法的参数

       @return 返回值

注释的使用细节：

       三种注释可以出现在程序的任何地方，但是不推荐找任意位置。

1. 编程习惯：

              1. 给那条语句进行说明，注释应该写在该语句的旁边。

2. 单行注释一般写在语句的后面多行注释和文档注释一般写在语句的上面

       注意：文档注释只能出现在类、属性、方法的上面。

      

2.注释的嵌套

1.单行注释可以在单行注释里面。

              2.多行注释不能嵌套在多行注释里面。

 

第二章 关键字、标识符、变量

1、关键字

关键字都是小写，goto、const是保留字

 

2、标识符

2.1标识符必须遵循以下规则

1.  标识符由26个英文字母大小写（a~zA~Z）、数字(0~9)、下划线(_)和美元符号($)组成

2.  不能以数字开头，不能是关键字、保留字，可以包含关键字

3.  严格区分大小写

4.  包含的符号只能是$、_，不能有空格

注：其中字母可以为中文、日文

 

2.2java中的标识符命名规范

1. 包名（文件夹，用于区分同名的类）

多个单词组成时所有字母小写（例:package  com.etc）

域名反写，多级包用.隔开

1. 类名和接口

如果是一个单词，首字母大写（例Demo,HelloWorld）

多个单词组成时所有单词的首字母大写(例：HelloWorld)

1. 变量名和函数名

多个单词组成时第一个单词首字母小写，其他单词首字母大写（例：lastAccessTime、getTime）。

1. 常量名

多个单词组成时，字母全部大写，多个单词之间使用_分隔（例：INTEGER_CACHE）

注意：只是为了增加规范性、可读性而做的一种约定，标识符在定义的时候最                 好见名知意，提高代码阅读性。

 

3、变量

1. 整型

byte   代表一个字节的大小   8bit  2(8)   -128~127       

short  代表两个字节的大小  16bit  2(16)  -2(15)~2(15)-1

       int    代表四个字节的大小  32bit  2(32)  -2(31)~2(31)-1

long   代表八个字节的大小  64bit  2(64)  -2(63)~2(63)-1

如果一个数值没有采取特殊的处理，那么该整数默认的类型是int。

可以使用数值后面添加L或小写l改变默认的整数类型。

2. 浮点型

float  代表四个字节的大小  32bit  -3.403e38~3.403e38

double 代表八个字节的大小  64bit  -1.798e308~1.798e308

java程序中所有的小数默认的类型是double类型，所以需要使用特殊的符号改变默认的小数类型。float类型的数据，在数值后添加f或F

 

4、运算符

4.1逻辑运算符

“&”和“&&”的区别：单与时，左边无论真假，右边都进行运算；双与时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，双或时，左边为真右边不参与运算。

 

4.2 位运算符

位运算符	运算符含义
&	与（AND）
|	或（OR）
^	异或
~	取反

 

4.3位移操作符

位运算符
运算符	运算	范例
<<	左移	3 << 2 = 12 --> 3*2*2=12
>>	右移	3 >> 1 = 1  --> 3/2=1
>>>	无符号右移	3 >>> 1 = 1 --> 3/2=1
&	与运算	6 & 3 = 2
|	或运算	6 | 3 = 7
^	异或运算	6 ^ 3 = 5
~	反码	~6 = -7

>>被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。

>>>被移位二进制最高位无论是0或者是1，空缺位都用0补。

 

 

第三章 流程控制语句

1、switch语句

switch(表达式) {     case 取值1:        执行语句；        break；     case 取值2:        执行语句；        break；     …...     default:        执行语句；        break； }

特点：

1,switch语句选择的类型只有四种：byte，short，int ， char。

2,case之间与default没有顺序。先判断所有的case，没有匹配的case执行default。

3,switch语句停止的条件是遇到了break关键字或者结束switch语句的大括号。

4,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

5，switch case中的值必须要与switch表达式的值具有相同的数据类型。而且case后跟的值必须是常量，不能跟变量。

 

2、while语句

1、while语句格式： while(条件表达式) {     执行语句； }

最简单无限循环格式：while(true) , for(;;)

其中：while循环的判断条件表达式，最终结果应为Boolean型，不能是int,char,byte之类的

 

第四章 方法和数组

1、方法

注：

1、main()是程序的入口由虚拟机调用，方法和方法之间不能嵌套，方法之间通过调用来使用。

2、当执行完return语句，或者执行到方法末尾的花括号时方法结束。

3、有些内容只能在方法中使用，如调用对象的方法、使用输出语句等。

4、方法中只能调用方法，不能定义方法，没有定义方法之前，不能调用方法。

 

1.1 辨析

override->重写(=覆盖)、overload->重载

override发生在继承关系中，有与父类想用的方法名和参数

overload发生在一个类中，参数个数、类型不同

 

2、数组

2.1定义

int[] arr = new int[5];

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

 

2.2增强for循环

       int[] x = { 1, 2, 3 };

       for (int t: x) {

           System.out.println(t);         

       }

 

 

 

第五章 初始java面向对象

1、成员变量与局部变量

成员变量:  定义在类中变量

局部变量:  定义在方法中变量

 

2、构造方法

1. 构造方法是在对象建立时由jvm调用, 给对象初始化。一般方法是对象建立后，当对象调用该功能时才会执行。
2. 普通方法可以使用对象多次调用，构造方法就在创建对象时调用。
3. 构造方法的方法名要与类名一样，而普通的方法只要符合标识符的命名规则即可。

构造方法没有返回值类型。

 

细节：

1. 当类中没有定义构造方法时，系统会指定给该类加上一个无参数的构造方法。当类中如果提供了有参构造方法，这时默认的构造方法就没有了。

2.在一个类中可以定义多个构造方法，以进行不同的初始化。多个构造方法存在于类中，是以重载的形式体现的；因为构造方法的名称都相同。

 

3、构造代码块

class Perosn{    {        cry();// 每个Person对象创建出来都会执行这里的代码     }       public void cry(){        System.out.println("哇哇哇....");     } }

cry()就是构造代码块

作用：

1：给对象进行初始化，对象一旦建立就运行并且优先于构造方法。

2：与构造方法区别

1：构造代码块是给所有对象进行统一初始化， 构造方法给对应的对象初始化。

2：构造代码块的作用：它的作用就是将所有构造方法中公共的信息进行抽取。

例如孩子一出生统一哭

 

第六章 面向对象—static和继承

1、static

1：使用类名直接调用

    1：静态函数：

       1：静态函数中不能访问非静态成员变量，只能访问静态变量。

       2：静态方法不可以定义this,super关键字.

       3：因为静态优先于对象存在.静态方法中更不可以出现this

       4：静态函数存在于共享区中，对象地址在栈中，成员在堆中

    2：非静态函数：非静态函数中可以访问静态成员变量

2：细节：

       1：静态函数中不能使用非静态变量

       2：非静态函数可以访问静态变量

3：static特点

1 随着类的加载而加载，静态会随着类的加载而加载，随着类的消失而消失。

        2 优先于对象存在。-->静态是先存在，对象是后存在。

        3 被所有实例(对象)所共享。

        4 可以直接被类名调用  

4：静态变量（类变量）和实例变量的区别:

        1存放位置

            1：类变量随着类的加载而加载存在于方法区中.

            2：实例变量随着对象的建立而存在于堆内存中.

        2生命周期

            1：类变量生命周期最长,随着类的消失而消失.

            2：实例变量生命周期随着对象的消失而消失.

5：静态优缺点

1： 优点:对对象的共享数据进行单独空间的存储,节省空间 例如Person 都有

国籍。该数据可以共享可以被类名调

2：缺点：生命周期过长访问出现局限性。（静态只能访问静态）

 

2、继承

继承细节：

1：父类定义完整的静态成员，非静态构造方法。静态变量和静态方法都可以通过子类名.父类静态成员的形式调用成功。

2：所有的private成员和构造函数不能被继承,其他都能继承，包括static静态成员。

 

super和this：

this指向的是当前对象的调用，super指向的是当前调用对象的父类

3、instanceof

比较运算符

 检查是否是类的对象

    可以判断对象是否是某一个类的实例

    用法

    对象  instanceof 类;

 

4、final

final关键字主要用于修饰类、类成员、方法、以及方法的形参；final修饰的都不能被修改

 

6：思考

1：为什么子类一定要访问父类的构造函数呢？

子类继承了父类的属性，如果要使用父类的属性必须初始化，创建子类对象，必须先初始化父类属性，必须调用父类的构造方法。

2：为什么调用父类无参的构造函数？

设计java语言之时，只知道编译器会默认添加无参的构造函数，有参的无法确定。但是可以通过super关键字显式调用父类指定构造函数。

3：为什么super()this()语句要放在构造函数的第一行？

子类可能会用到父类的属性，所以必须先初始化父类。

 

第七章 抽象类、接口、多态

1、抽象类

1：抽象类的特点

1：有抽象函数的类，该类一定是抽象类。// 不全，接口

2：抽象类中不一定要有抽象函数。

3：抽象类不能使用new创建对象

4：抽象类主要为了提高代码的复用性，让子类继承来使用。

5：编译器强制子类实现抽象类父类的未实现的方法。

（可以不实现，前提是子类的也要声明为抽象的）

2：抽象的优点

1：提高代码复用性

2：强制子类实现父类中没有实现的功能

       2：提高代码的扩展性，便于后期的代码维护

3：抽象类不能创建对象，那么抽象类中是否有构造函数？

1：抽象类中一定有构造函数。主要为了初始化抽象类中的属性。通常由子类实现。

接口中没有构造函数

       4：final和abstract是否可以同时修饰一个类？ 

           一定不能同时修饰。

2、接口

1. 类实现接口可以通过implements实现，实现接口的时候必须把接口中的所有方法实现,一个类可以实现多个接口。
2. 接口中定义的所有的属性默认是public static final的，即静态常量既然是常量，那么定义的时候必须赋值。
3. 接口中定义的方法不能有方法体。接口中定义的方法默认添加public abstract
4. 有抽象函数的不一定是抽象类，也可以是接口类。
5. 由于接口中的方法默认都是抽象的，所以不能被实例化。
6. 对于接口而言，可以使用子类来实现接口中未被实现的功能函数。
7. 如果实现类中要访问接口中的成员，不能使用super关键字。因为两者之间没有显示的继承关系，况且接口中的成员成员属性是静态的。可以使用接口名直接访问。

8.   接口没有构造方法。

 

3、多态

Father f=new Son();

1：当父类和子类具有相同的非静态成员变量，那么在多态下访问的是父类的成员变量

2：当父类和子类具有相同的静态成员变量，那么在多态下访问的是父类的静态成员变量。

所以：父类和子类有相同的成员变量，多态下访问的是父类的成员变量。

3：当父类和子类具有相同的非静态方法（就是子类重写父类方法[不是]），多态下访问的是子类的成员方法。

4：当父类和子类具有相同的静态方法（就是子类重写父类静态方法），多态下访问的是父类的静态方法。

除了第三条（多态，访问重写的方法），其他访问的都是父类的

 

3：多态前提

    1：类与类之间有关系，继承或者实现

4：多态弊端

    1：提高扩展性，但是只能使用父类引用指向父类成员。

5：多态特点

    非静态

1：编译时期，参考引用型变量所属的类是否有调用的方法，如果有编译通过。没有编译失败

    2：运行时期，参考对象所属类中是否有调用的方法。

    3：总之成员函数在多态调用时，编译看左边，运行看右边。

    在多态中，成员变量的特点，无论编译和运行参考左边（引用型变量所属的类）。

    在多态中，静态成员函数特点，无论编译和运行都参考左边

 

 

第八章 javaAPI常用类

E:\暑期中软培训\第八章JavaAPI中常用类.doc

1、Object对象

1.1 toString方法

重写toString方法，使他能达到要求

    public String toString() {

       return "People 姓名=" + name + ", 年龄=" + age + ", 性别=" + gender ;

    }

使用：

       People p = new People("张三",20,'男');

       System.out.println(p);

结果：

People 姓名=张三, 年龄=20, 性别=男

1.2 equals方法和 ==

 == 的作用：
　　基本类型：比较的就是值是否相同
　　引用类型：比较的就是地址值是否相同
equals 的作用:
　　引用类型：默认情况下，比较的是地址值。
注：不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同

1.3 hashCode方法

判断两个对象相等，首先比较hashCode值，在比较equals，都相同，就说明是同一个对象

 

2、Date

第九章 异常处理

1、异常与错误

异常：能够被程序处理，运行下去，如除0异常

错误：无法处理，需要程序员修改源代码

 

2、exception的层次关系

exception分为：运行时异常和非运行时异常

常见运行时异常：

    NullPointerException-空指针异常

    ArithmeticException-数学异常

    IndexOutOfBoundsException：索引越界异常

    NumberFormatException-数字格式异常

    ClassCastException-类型转换异常

 

3、异常处理流程及语句

/*

catch可以有一个或者多个，catch语句的异常类型必须从子类到父类的顺序，否则编译错误

    不论是否有异常，finally都会被执行，除非前面有System.exit(0)

*/

try{

      可能抛出异常的代码块;

}catch(异常类型  变量名){

       处理异常的代码;

}catch(异常类型  变量名){

       处理异常的代码;

}finally{

   

}

 

/*

thorw 在方法体内使用

throws在方法声明出使用

*/

throw new Exception();

或者

catch(Exception e){

    throw e;

}

public void div(int x,int y)  throws Exception

 

 

第十章 集合

1、集合和数组的区别

数组和集合类都是容器

数组长度是固定的，集合长度是可变的

数组中可以存储基本数据类型，集合只能存储对象

数组中存储数据类型是单一的，集合中可以存储任意类型的对象

总结：

用于存储对象，长度是可变的，可以存储不同类型的对象。

 

2、集合分类

---|Collection: 集合            ---|List: 有存储顺序, 可重复               ---|ArrayList:    数组实现, 查找快, 增删慢                                   由于是数组实现, 在增和删的时候会牵扯到数组 增容, 以及拷贝元素. 所以慢。数组是可以直接 按索引查找, 所以查找时较快               ---|LinkedList:   链表实现, 增删快, 查找慢                                   由于链表实现, 增加时只要让前一个元素记住自 己就可以, 删除时让前一个元素记住后一个元 素, 后一个元素记住前一个元素. 这样的增删效 率较高但查询时需要一个一个的遍历, 所以效率 较低               ---|Vector:   和ArrayList原理相同, 但线程安全, 效率略低                               和ArrayList实现方式相同, 但考虑了线程安全问 题, 所以效率略低            ---|Set: 无存储顺序, 不可重复               ---|HashSet               ---|TreeSet               ---|LinkedHashSet ---| Map: 键值对        ---|HashMap        ---|TreeMap        ---|HashTable        ---|LinkedHashMap

 

Collection	我们需要保存若干个对象的时候使用集合。
List	如果我们需要保留存储顺序, 并且保留重复元素, 使用List. 如果查询较多, 那么使用ArrayList 如果存取较多, 那么使用LinkedList 如果需要线程安全, 那么使用Vector
Set	如果我们不需要保留存储顺序, 并且需要去掉重复元素, 使用Set. 如果我们需要将元素排序, 那么使用TreeSet 如果我们不需要排序, 使用HashSet, HashSet比TreeSet效率高. 如果我们需要保留存储顺序, 又要过滤重复元素, 那么使用LinkedHashSet

 

3、List的操作

3.1 String泛型

       List <String> list = new ArrayList<String>();

       list.add("i ");

       list.add("can ");

       list.add("fly ");

      

       for (String s : list) {

           System.out.println(s);

       }

      

       for (int i = 0; i < list.size(); i++) {

           System.out.println(list.get(i));

       }  

      

//     迭代器遍历数组

       Iterator<String> it = list.iterator();

       while(it.hasNext()) {

           System.out.println(it.next());

       }

3.2 User泛型

       List <User> list2 = new ArrayList<User>();

       list2.add(new User("飒飒","123"));

       list2.add(new User("飒飒","123"));

       list2.add(new User("沙发","123"));

       list2.add(new User("浮点数","123"));

 

//     删除重复的

       for (int i = 0; i < list2.size()-1; i++) {

           for (int j = i + 1; j < list2.size(); j++) {

              if(list2.get(i).equals(list2.get(j))) {

                  list2.remove(j);

              }

           }

       }

 

//     输出User类的对象实例

       Iterator<User> it2 = list2.iterator();

       while(it2.hasNext()) {

           User u = it2.next();   //   重要，User可以换成Object，多态

           System.out.println(u.getUserName()+" : "+u.getPassword());

       }

 

4、Set的操作

4.1 HashSet，去重复，无序

//     不用泛型，默认object类，会出现警告

//     Set<String> has = new HashSet<String>();

       Set hs = new HashSet();

       hs.add("哲学");

       hs.add("数学");

       hs.add("物理");

       hs.add("生物");

       System.out.println(hs);

      

       Iterator it = hs.iterator();

       while(it.hasNext())

           System.out.println(it.next());

 

 

4.2 TreeSet 去重复，有序

给TreeSet指定排序规则

    1)元素自身具备比较性，需要实现comparable接口，重写compareTo方法

    2)容器自身具备比较性，自定义比较器，实现Comparator 接口，覆盖compare方法

 

4.2.1 元素比较

       TreeSet<Student> ts = new TreeSet<Student>();

       ts.add(new Student("aa", 20, "男"));

       ts.add(new Student("bb", 18, "女"));

       ts.add(new Student("cc", 17, "男"));

       ts.add(new Student("dd", 17, "女"));

       ts.add(new Student("dd", 15, "女"));

       ts.add(new Student("dd", 15, "女"));

//     System.out.println(ts); 输出地址

       Iterator<Student> it = ts.iterator();

       while(it.hasNext()) {

           Student s = it.next();

           System.out.println(s.getName()+" : "+s.getAge()+" : "+s.getGender());

       }

 

// 要有hashCode，equals方法，最后重写compareTo

// HashSet内的元素顺序是根据hasCode确定的，先比较hashCode，相同在比较equals，最后equals返回false，说明两个元素不相同

public class Student implements Comparable {

 

    public int hashCode() {

       return name.hashCode() + age * 31;

    }

 

    public boolean equals(Object obj) {

       System.err.println(this + "equals :" + obj);

       if (!(obj instanceof Student)) {

           return false;

       }

       Student p = (Student) obj;

       return this.name.equals(p.name) && this.age == p.age;

    }

 

    @Override

    public int compareTo(Object obj) {

       // TODO Auto-generated method stub

       Student p = (Student) obj;

       System.out.println(this+" compareTo:"+p);

       if(this.age > p.age)

           return 1;

       else if(this.age < p.age)

           return -1;

       return this.name.compareTo(p.name);

    }

}

 

4.2.2 容器比较

适用情况：元素自身不具备比较性，或者元素自身具备的比较性不是所需的

class MyComparator implements Comparator {

 

    public int compare(Object o1, Object o2) {

       Book b1 = (Book) o1;

       Book b2 = (Book) o2;

       System.out.println(b1+" comparator "+b2);

       if (b1.getPrice() > b2.getPrice()) {

           return 1;

       }

       if (b1.getPrice() < b2.getPrice()) {

           return -1;

       }

       return b1.getName().compareTo(b2.getName());

    }

}

 

// 主函数

       TreeSet ts = new TreeSet(new MyComparator());

       ts.add(new Book("think in java", 100));

       ts.add(new Book("java 核心技术", 75));

       ts.add(new Book("现代操作系统", 50));

       ts.add(new Book("java就业教程", 35));

       ts.add(new Book("think in java", 100));

       ts.add(new Book("ccc in java", 100));

       System.out.println(ts);

 

5、Map的操作

5.1 Map介绍

Map存储的是键值对key和value

Map中的元素是两个对象，一个对象作为键，一个对象作为值。键不可以重复，但是值可以重复。

Map存储元素使用put方法，Collection使用add方法

Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素

Map集合中键要保证唯一性

Map学习体系：  ---| Map  接口    将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。            ---| HashMap  采用哈希表实现，所以无序             ---| TreeMap   可以对健进行排序

 

---|Hashtable: 底层是哈希表数据结构，线程是同步的，不可以存入null键，null值。 效率较低，被HashMap 替代。 ---|HashMap: 底层是哈希表数据结构，线程是不同步的，可以存入null键，null值。 要保证键的唯一性，需要覆盖hashCode方法，和equals方法。 ---| LinkedHashMap： 该子类基于哈希表又融入了链表。可以Map集合进行增删提高效率。 ---|TreeMap: 底层是二叉树数据结构。可以对map集合中的键进行排序。需要使用Comparable或者Comparator 进行比较排序。return 0，来判断键的唯一性。

 

5.2 HashMap & 三种遍历方式

三种方式：

1、将map 集合中所有的键取出存入set集合。        Set<K> keySet()   返回所有的key对象的Set集合                              再通过get方法获取键对应的值。 2、 values() ，获取所有的值.        Collection<V> values()不能获取到key对象 3、 Map.Entry对象  推荐使用   重点        Set<Map.Entry<k,v>> entrySet() 将map 集合中的键值映射关系打包成一个对象 Map.Entry对象通过Map.Entry 对象的getKey， getValue获取其键和值。

创建：

       Map<Integer , String> map = new HashMap<Integer , String>();

       map.put(1, "aaa");

       map.put(2, "aaa");

       map.put(3, "ccc");

       map.put(4, "aaa");

       map.put(5, "aaa");

 

第一种：

       /*

        * 遍历第一种方法，使用keySet

        * Map——>Set

        * Set迭代器取出元素（键）

        * get获取键对应的值

        */

       Set<Integer> ks = map.keySet();

       Iterator<Integer> it = ks.iterator();

       while(it.hasNext()) {

           Integer key = it.next(); //map.keySet() 里面存只有key

           String value = map.get(key);// value通过map取出

           System.out.println(key + " : " + value);

       }

 

第二种：只能获取value

       /*

        * 遍历第二种方法，values

        * 通过values获取值

        * 但是获取不到key对象

        * map.values()得不到key，只有value

        * map.keySet()

        */

       Collection<String> vs = map.values();

       Iterator<String> it2 = vs.iterator();

       while(it2.hasNext()) {

           String value = it2.next();

           System.out.println(value);

       }

 

第三种：一般使用这种方式Map.Entry

       /*

        * 遍历第三种方法，Map.Entry

        * 将键值对关系打包成一个对象，作为entry

        * 存入set集合，就具备了getKey和getValue

        */

       Set<Map.Entry<Integer, String>> es = map.entrySet();

       Iterator<Map.Entry<Integer, String>> it3 = es.iterator();

       while(it3.hasNext()) {

           Map.Entry<Integer, String> en = it3.next();

           Integer key = en.getKey();

           String value = en.getValue();

           System.out.println(key+" : "+value);

       }

 

5.3 TreeMap

排序：方式一：元素自身具备比较性

      方式二：容器具备比较性，常用，类似TreeSet