JAVASE总结笔记

Posted 强强强子

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JAVASE总结笔记相关的知识,希望对你有一定的参考价值。

代码下载地址:http://download.csdn.net/download/sinat_25926481/9567455

day1

1:面向对象(理解)
(1)面向对象是相对应面向过程而言的一种编程思想,是基于面向过程的。
(2)思想特点:
A:是一种更符合我们思考习惯的思想。
B:把复杂的事情简单化。
C:让我们从执行着变成了指挥者。
(3)案例:
A:买电脑
B:吃饭,洗衣服
C:我要喝水
(4)把大象装进冰箱,让大家对面向对象有一点点的了解。
面向过程:
class Demo {
public static void main(String[] args) {
open();
in();
close();
}

            public static void open() {
                System.out.println("开门");
            }

            public static void in() {
                System.out.println("我要进去");
            }

            public static void close() {
                System.out.println("关门");
            }
        }

    面向对象:
        如何让我们的代码更符合面向对象思想
            A:有哪些类
            B:类有哪些功能
            C:类与类的关系

        class 大象 {
            public void in() {
                System.out.println("我要进去");
            }
        }

        class 冰箱 {
            public void open() {
                System.out.println("开门");
            }

            public void close() {
                System.out.println("关门");
            }
        }

        class Test {
            public static void main(String[] args) {
                冰箱 b = new 冰箱();
                大象 d = new 大象();

                b.open();
                d.in();
                b.close();
            }
        }

2:类与对象的关系(掌握)
(1)现实世界的事物:
属性:事物的特征
行为:事物的功能
(2)java中最基本的单位是类。所以,我们要把事物转换为对应的类。
(3)如何转换呢:
类 事物
成员变量 属性
成员方法 行为

    成员变量:属性,字段
    成员方法:函数,方法
(4)类与对象的概念
    类:是一组相关的属性和行为的抽象的集合体。
    对象:是该类事物的具体存在的个体。

    类:学生
    对象:林青霞

3:类与对象的使用(掌握)
(1)学生类的制作和使用
(2)手机类的制作和使用

4:内存图(理解)
(1)一个对象的内存图:
一个对象的基本初始化过程。
(2)二个对象的内存图:
方法的共用。
(3)三个对象的内存图:
两个引用变量指向同一个对象。

5:成员变量和局部变量的区别?
(1)在类中的位置不同:
成员变量:类中方法外。
局部变量:方法中或者方法声明上。
(2)在内存中的位置不同:
成员变量:堆中。
局部变量:栈中。
(3)生命周期不同:
成员变量:随着对象的存在而存在,随着对象的消失而消失。
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失。
(4)初始化值不同;
成员变量:有默认初始化值。
局部变量:没有默认初始化值。

问题:
    成员变量和名称可以不可和局部变量一样呢?
        可以。

    class Demo {
        int x = 10;

        public void show() {
            int x = 20;
            System.out.println(x);
        }

        public void method() {
            System.out.println(x);
        }
    }

day2

1:变量什么时候该定义成员变量(掌握)
(1)如果变量和类之间存在这描述性的关系,就该定义为成员变量。
(2)注意:
变量的定义范围越小越好。

2:引用类型作为形式参数和返回值(掌握)
(1)顾客点菜案例。
顾客–服务员–厨师
(2)引用类型作为参数和返回值的问题:
A:如果一个方法的形式参数是一个类名,那么,这里肯定需要的是该类的对象。
B:如果一个方法的返回值是一个类名,那么,这里返回的肯定是该类的对象。

    class Demo {
        public void printStudent(Student s) {
            s.show();
        }

        public Student getStudent() {
            Student s = new Student();
            return s;
        }
    }

3:匿名对象(理解)
(1)就是没有名字的对象。
(2)应用场景:
A:调用方法。但是仅仅只调用一次的时候使用。
B:作为实际参数传递。
Demo d = new Demo();
d.printStudent(new Student());

4:封装(理解)
(1)隐藏实现细节,提供公共的访问方式。
(2)体现有哪些呢?
A:类
B:方法体
C:private修饰成员变量
(3)private关键字:
是私有的意思。可以修饰类中的成员变量和成员方法。
注意:被它修饰的成员只能在本类中被访问。
(4)标准代码:
class Student {
private String name;
private int age;

        public void setName(String n) {
            name = n;
        }

        public String getName() {
            return name;
        }

        public void setAge(int a) {
            age = a;
        }

        public int getAge() {
            return age;
        }
    }

5:构造方法(掌握)
(1)创建对象,并对对象的内容进行初始化。
(2)特点:
A:方法名和类名相同。
B:没有返回值类型。
C:没有返回值。
(3)注意事项:
A:如果我们没给构造方法,系统给出一个默认构造。无参构造。
B:如果我们给出了构造方法,系统将不再提供构造方法。
这个时候,要么我们不使用无参构造方法。
要么,自己定义一个,然后使用。

        推荐:自己给出无参构造方法。
(4)给成员变量赋值的方式:
    A:无参+setXxx()
    B:带参
(5)获取值:
    getXxx()
(6)标准代码:
    class Student {
        private String name;
        private int age;

        public Student() {}

        public Student(String n,int a) {
            name = n;
            age = a;
        }

        public void setName(String n) {
            name = n;
        }

        public String getName() {
            return name;
        }

        public void setAge(int a) {
            age = a;
        }

        public int getAge() {
            return age;
        }
    }

6:this关键字。(掌握)
(1)代表当前类的一个对象。谁调用代表谁。
(2)应用场景:
A:使用本类的成员变量(掌握)
this.变量名;
B:使用本类其他构造方法
this(…)
C:使用本类的其他成员方法
this.方法名();
(3)标准代码:
class Student {
private String name;
private int age;

        public Student() {}

        public Student(String name,int age) {
            this.name = name;
            this.age = age;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public int getAge() {
            return age;
        }
    }

    测试类:
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(27);
        System.out.println(s.getName()+"---"+s.getAge());

        Student ss = new Student("林青霞",27);
        System.out.println(ss.getName()+"---"+ss.getAge());
(4)案例:
    A:手机标准代码案例及测试。
    B:长方形标准代码案例及测试。

7:static关键字(理解)
(1)是静态的意思,可以修饰类中成员变量和成员方法。
(2)静态的特点:
A:随着类的加载而加载。
B:优先于对象存在。
C:被所有对象共享的数据。
这个也被我们作为为什么要使用静态的一个判断条件。
举例:饮水机和水杯。
D:让我们的调用多了一种方式:
a:非静态的数据,必须创建对象访问。
b:静态的数据,可以通过对象访问,也可以通过类名访问。
(3)静态的访问问题:
A:非静态方法
非静态成员变量
静态成员变量
非静态成员方法
静态成员方法
B:静态方法
静态成员变量
静态成员方法

    总之:静态只能访问静态。

    称呼:
        静态的成员被成为类成员。跟类相关。
        非静态的成员被称为实例成员。跟对象相关。
(4)main方法的解释以及如何接收键盘录入数据:
    public:权限最大
    static:静态,不用创建对象。
    void:返回没有意义。
    main:大家都是这样做的。
    String[] args:接收键盘录入数据。
    接收键盘录入的格式:
        java HelloWorld hello world java
        java HelloWorld 10 20 30

8:代码块(理解)
(1)用{}括起来的代码。
(2)分类:
A:局部代码块。
方法内。
作用:限定变量的生命周期,提高效率。
B:构造代码块。
类中,方法外。
作用:把所有构造方法中相同的代码定义到一处。
C:静态代码块。
类中,方法外,加static。
作用:在整个系统运行过程中只执行一次的内容。
(3)面试题:
构造方法,构造代码块,静态代码块的执行流程?
静态代码块 – 构造代码块 – 构造方法。

    特点:
        静态代码块只执行一次。
        构造代码块每次调用构造方法都执行。

9:一个类的实例化过程(理解)
Person p = new Person();

A:把Person.class加载到内存。
B:在栈内存为p变量开辟空间。
C:在堆内存为Person对象开辟空间。
D:对成员变量进行默认初始化。
E:对成员变量进行显示初始化。
F:如果有构造代码块,通过构造代码块对成员变量进行初始化。
G:通过构造方法对成员变量进行初始化。
I:对象初始化完毕,把堆内存的地址给p变量。

day3

1:制作工具类和API。(了解)
(1)静态的使用场景:
A:被所有对象共享的数据。
B:工具类一般成员都是静态修饰。
(2)如何通过javadoc命令制作帮助文档呢?
A:写一个java源程序。
B:对java源程序加入文档注释。
C:通过javadoc命令生成即可。
javadoc -d doc -author -version ArrayTools.java

2:使用API(掌握)
(1)使用API的步骤:
参照:day08\\code\\02_如何使用API和Math类的学习\\如何使用API.txt
(2)通过Math类的学习来实践。
A:绝对值
B:向上/下取整
C:最大/小值
D:四舍五入
E:平方根
F:次幂
G:随机数
(3)案例:
猜数字小游戏。

3:继承(掌握)
(1)把多个类中相同的内容提取出来,定义到一个类中。
然后让这多个类和这个类产生一个关系,这多个类就具备该类的数据了。
这种关系叫:继承。
(2)表现形式:
class SonClass extends FuClass {}

    SonClass: 子类,派生类
    FuClass: 父类,基类,超类
(3)继承的好处:
    A:提高了代码的复用性。
    B:让类与类之间产生了一个关系,是多态的前提。
(4)Java中继承的特点:
    A:Java中类只支持单继承。
    B:Java中类可以多层(重)继承。
(5)继承间的成员关系:
    A:成员变量
        在子类方法中使用变量:
            局部范围
            成员范围
            父类成员范围
    B:构造方法
        a:子类构造方法中默认去访问父类的无参构造方法。
            原因:因为子类要使用父类的数据,父类的数据必须先初始化。
        b:假如父类没有构造方法
            要么,使用super(...)调用带参
            要么,使用this(...)访问本类其他构造,本类至少有一个构造方法访问了父类构造方法。
    C:成员方法
        通过子类对象使用成员方法:
            子类
            父类

4:方法重写(掌握)
(1)子类中出现了和父类中方法声明一模一样的方法。
复写,覆盖。
(2)注意事项:
A:子类方法的权限不能低于父类方法的权限
B:父类私有的不能被重写
C:静态只能重写静态。(多态中讲解一个问题)

5:面试题:(理解)
(1)程序分析题中的所有题目。
(2)方法重载和方法重写的区别?
(3)this和super的区别?

6:案例:(掌握)
(1)猫狗案例使用继承和不使用继承的实现。
(2)学生和老师的案例。


day4

1:final(掌握)
(1)是一个关键字,表示的是最终的意思。
(2)它可以修饰类,修饰成员变量,修饰成员方法。
(3)特点:
它修饰的类不能被继承。
它修饰的变量是常量。
它修饰的成员方法不能被重写。
(4)面试题:
修饰局部变量。

    方法的形式参数:
        基本类型:基本类型的值不能发生改变。
        引用类型:引用类型的地址值不能发生改变,但是内容可以发生改变。

2:多态(掌握)
(1)同一个对象在不同时刻表现出现的多种状态。
举例:
水(水蒸气,冰,水)
理解:
编译时期状态和运行时期状态不一致的现象。

        判断下面哪个有问题:从右边往左边念。
        Fu f = new Fu();
        Zi z = new Zi();
        Fu f = new Zi(); //多态
        Zi z = new Fu(); //报错
(2)多态的前提:
    A:要有继承或者实现关系。
    B:有方法重写。
        因为一般都是抽象类或者接口的多态。
    C:要有父类/父接口的引用指向子类对象。
(3)多态访问的成员特点:
    Fu f = new Zi();

    A:成员变量
        编译看左边,运行看左边。
    B:成员方法
        编译看左边,运行看右边。
    C:静态方法
        编译看左边,运行看左边。
(4)多态的好处和弊端:
    A:好处
        提高了程序的可维护性和可扩展性。
        维护性:继承保证
        扩展性:多态保证
    B:弊端
        父类/父接口不能访问子类特有功能。
(5)多态中的类型转换:
    A:向上转型
        Fu f = new Zi();
    B:向下转型
        Zi z = (Zi)f;

    举例:孔子装爹。
(6)多态的体现形式:
    A:具体类多态
        class Fu {}
        class Zi extends Fu {}

        Fu f = new Zi();
    B:抽象类多态
        abstract class Fu {}
        class Zi extends Fu {}

        Fu f =  new Zi();
    C:接口多态
        interface Inter {}
        //接口的实现类命名:接口名+Impl
        class InterImpl implements Inter{}

        Inter i = new InterImpl();

3:抽象类(掌握)
(1)把多个类中相同的方法声明给抽取出来。定义到一个类中。
一个方法如果只有方法声明,没有方法体,那么该方法必须定义为抽象方法。
而一个类中如果有抽象方法,那么,该类必须定义为抽象类。
(2)抽象类的特点:
A:抽象方法和抽象类都必须用abstract表示。
B:一个类继承抽象类的时候;
要么:本身是一个抽象类。
要么:实现抽象类中的所有抽象方法。
C:抽象类不能实例化。可以按照多态的使用方式使用。
D:成员特点:
a:成员变量
可以是变量,也可以是常量。
b:构造方法

c:成员方法
可以是抽象,也可以非抽象。
(3)抽象类的好处:
A:抽象类中的非抽象方法提高了代码的复用性。
B:抽象类中的抽象方法强制要求子类必须重写某些方法。
(4)抽象类的案例:
A:猫狗案例
B:老师案例
C:学生案例(自己做的)
D:员工案例
(5)抽象类中的几个小问题:
A:抽象类不能实例化,构造方法有什么用呢?
用于子类访问父类数据的初始化。
B:如果一个类中没有抽象方法,而类却被定义为了抽象类,请问为什么?
不让创建对象。
C:abstract不能和哪些关键字共存:
private: 冲突
final: 冲突
static: 无意义

4:接口(掌握)
(1)如果一个抽象类中的所有成员方法都是抽象的,java就提高了一种更抽象的表达方式:接口。
(2)接口的特点:
A:接口用interface定义。
类实现接口用implements关键字。
B:一个类要实现接口:
要么:本身是抽象类。
要么:实现接口中的所有抽象方法。
C:接口不能实例化。可以按照多态的使用方式使用。
D:成员特点:
a:成员变量:只能是常量。
默认修饰符:public static final
b:成员方法:只能是抽象方法。
默认修饰符:public abstract
(3)类与接口的关系:
A:类与类的关系
继承,单继承。
B:类与接口的关系
实现,单实现,多实现。
继承一个类的同时实现多个接口。
C:接口与接口的关系
继承,单继承,多继承。
(4)案例:
A:猫狗案例用接口实现基本版本。
(5)抽象类和接口的区别:
A:成员区别
抽象类:
a:成员变量
可以是变量,也可以是常量。
b:构造方法

c:成员方法
可以是抽象,也可以非抽象。
接口:
a:成员变量:只能是常量。
默认修饰符:public static final
b:成员方法:只能是抽象方法。
默认修饰符:public abstract
B:关系区别
a:类与类的关系
继承,单继承。
b:类与接口的关系
实现,单实现,多实现。
继承一个类的同时实现多个接口。
c:接口与接口的关系
继承,单继承,多继承。
C:设计理念不同
抽象类被继承体现的是:is a的关系。抽象类中定义的是继承体系共性功能。
接口被实现体现的是:like a的关系。接口中定义的是继承体系的扩展功能。

    案例:
        运动员和教练案例。

        分析:从具体到抽象。
        实现:从抽象到具体。
        使用:具体。

day5

1:包(掌握)
(1)其实就是文件夹。
(2)作业:把同名称的类放到不同的文件夹下使用。
(3)格式:
package xxx.yyy.zzz;
(4)带包的类的编译和运行:
A:手动式
a:javac编译当前类文件。
b:手动建立包对应的文件夹。
c:把a的class文件放到b的最终文件夹下。
d:通过java命令执行。注意了:需要带包名称的执行。
java cn.itcast.HelloWorld
B:自动式
a:javac编译的时候带上-d即可
javac -d . HelloWorld.java
b:通过java命令执行。注意了:需要带包名称的执行。
java cn.itcast.HelloWorld

2:导包(掌握)
(1)不同包下的类之间的访问。
我们发现,每次使用不同包下的类的时候,都需要加包的全路径。
比较麻烦。这个时候,java就提供了导包的功能。
(2)格式:
import xxx.yyy.zzz.类名;

    扩充格式:
        import xxx.yyy.zzz.*;
        但是不建议使用这种做法。
(3)面试题:
    package,import,class的有没有顺序呢?
    package > import > class

    唯一    多个       多个

3:权限修饰符(掌握)
(1)案例:
cn.itcast
Fu
Zi
Demo
com.liuyi
Zi
Demo
(2)结论:
本类 同一个包下 不同包下的子类 不同包下的无关类
private Y
默认(什么都没有) Y Y
protected Y Y Y
public Y Y Y Y

4:常见的修饰符的使用(掌握)
类 成员变量 构造方法 成员方法
private Y Y Y
默认 Y Y Y Y
protected Y Y Y
public Y Y Y Y
final Y Y Y
static Y Y
abstract Y Y

类:public
成员变量:private
构造方法:public 
成员方法:public

5:内部类(理解)
(1)把类定义在其他类的内部,就被称为内部类。
(2)内部类的访问特点:
A:内部类可以直接访问外部类的成员,包括私有。
B:外部类要访问内部类的成员,必须创建对象。
(3)内部类的分类:
A:成员内部类
a:private 访问的安全性
b:static 访问的方便
B:局部内部类
a:带名字的(类)
b:不带名字的(对象)
(4)面试题:
局部内部类访问局部变量必须加final修饰。
(5)匿名内部类:(掌握)
格式:
new 类名或者接口名() {
重写方法;
};

     本质:是继承类或者实现接口的子类匿名对象。
(6)案例:
    开发中怎么用:
        interface Inter {
            public abstract void show();
        }

        class InterDemo {
            public void method(Inter i) {
                i.show();
            }
        }

        class InterTest {
            public static void main(String[] args) {
                InterDemo id = new InterDemo();
                id.method(new Inter(){
                    public void show() {
                        System.out.println("HelloWorld");
                    }
                });
            }
        }

    面试题:
        interface Inter {
            void show();
        }

        class Outer {
            //补齐代码
            public static Inter method() {
                return new Inter(){
                    public void show() {
                        System.out.println("show");
                    }
                };
            }
        }

        class OuterDemo {
            public static void main(String[] args) {
                Outer.method().show();
            }
        }

day6

1:Object(理解)
(1)是类层次结构的根类,所有的类都直接或者间接的继承自该类。
(2)成员方法:
A:toString()
返回对象的字符串表示。
默认格式:包名.类名@哈希值的十六进制。
建议重写该方法。而且,不用自己动手。
B:getClass()
返回对象的字节码描述文件。反射时候再讲。
C:hashCode()
返回对象的哈希值。可以理解为地址值。
D:finalize()
被对象的垃圾回收器调用,用于垃圾回收。
E:equals()
默认情况下,比较对象的地址值。
建议重写该方法。而且,不用自己动手。
一般重写方法的时候:都是比较的是对象的成员变量值。
(3)==和equals()的区别?
A:==
a:基本类型 比较的是基本类型的值
b:引用类型 比较的是引用类型的地址值
B:equals()
只能比较引用类型。
默认比较地址值。

2:Scanner(了解)
(1)用于键盘录入的。
(2)使用步骤:
A:导包
B:创建对象
C:调用方法
(3)成员方法:
int nextInt()
String nextLine()
(4)小问题:
int – int
String – String
String – int
int – String 有问题。

    解决方案:
        A:要么都是字符串,然后要什么转成什么。
        B:重新创建一个新的录入对象。

3:String(掌握)
(1)多个字符组成的一串数据。
(2)构造方法:
A:String s = new String();
B:String s = new String(byte[] bys);
C:String s = new String(byte[] bys,int index,int count);
D:String s = new String(char[] chs);
E:String s = new String(char[] chs,int index,int count);
F:String s = new String(String str);
G:String s = “hello”;
(3)面试题:
A:字符串一旦被赋值就不能被改变。
请自己理解这句话。
B:String s = new String(“hello”)和String s = “hello”;的区别
前者创建了2个对象
后者创建了1个对象
C:看程序写结果
String s1 = new String(“hello”);
String s2 = new String(“hello”);
System.out.println(s1==s2);
System.out.println(s1.equals(s2));

        String s3 = new String("hello");
        String s4 = "hello";
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5==s6);
        System.out.println(s5.equals(s6));
    D:看程序写结果
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3==s1+s2);
        System.out.println(s3.equals(s1+s2));
(4)常见方法:(补齐中文意思)
    A:判断功能
        boolean equals(Object obj)
        boolean equalsIgnoreCase(String str)
        boolean contains(String str)
        boolean startsWith(String str)
        boolean endsWith(String str)
        boolean isEmpty()
    B:获取功能
        int length()获取字符串长度。
        char charAt(int index)
        int indexOf(int ch)
        int indexOf(int ch,int fromIndex)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)
    C:转换功能
        byte[] getByteds()
        char[] toCharArray()
        static String copyValueOf(char[] chs)
        static String valueOf(char[] chs)j
        static String valueOf(int i)基本类型
        String toLowerCase()
        String toUpperCase()
        String concat(String str)
    D:其他功能
        String replace(char old,char new)
        String replace(String old,String new)
        String trim()
        int compareTo(String str)
        int compareToIgnoreCase(String str)
(5)案例:
    A:模拟登录
    B:遍历字符串
        a:length()和charAt()
        b:把字符串转成字符数组
    C:统计字符串中大写,小写,数字字符个多少个
    D:把字符串的首字母转成大写,其他小写
    E:查找大串中小串出现的次数

day7

1:StringBuffer/StringBuilder(掌握)
(1)字符串缓冲区类。
(2)String,StringBuffer/StringBuilder的区别?
A:String的字符串长度固定。而StringBuffer/StringBuilder的字符串长度是可以改变的。
B:StringBuffer是线程安全的,效率低。
StringBuilder是线程不安全的,效率高。
(3)构造方法:
A:StringBuffer sb = new StringBuffer();
B:StringBuffer sb = new StringBuffer(50);
C:StringBuffer sb = new StringBuffer(“hello”);
(4)成员方法:
A:添加功能
append,insert
B:删除功能
delete,deleteCharAt
C:替换功能
replace
D:截取功能
substring
E:反转功能
reverse
(5)案例:
A:把一个数组转成一个字符串:
[11, 22, 33, 44, 55]
B:把一个字符串反转输出:
输入:abc
输出:cba
(6)两个类可以相互转换,其实是为了使用别人的功能。

2:数组操作(掌握)
(1)基本操作:
A:遍历
B:获取最值
C:数组发转
D:基本查表法
E:基本查找
(2)高级操作:
A:排序
冒泡:相邻元素依次比较。
public static void bubbleSort(int[] arr) {
for(int x=0; x

day8

1:正则表达式(理解)
(1)符合一定规则的字符串。
(2)规则:
A:字符
x 字符 x
\\ 反斜线字符
\\r 回车
\\n 换行

    B:字符类
        [abc] a、b 或 c(简单类) 
        [^abc] 任何字符,除了 a、b 或 c(否定) 
        [a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内 
        [0-9] 0-9的数字字符

    C:预定义字符类
        . 任何字符
        \\d 数字:[0-9]
        \\w 单词字符:[a-zA-Z_0-9]
            在正则表达式中可以组成单词的字符。 

    D:边界匹配器
        ^ 行的开头 
        $ 行的结尾
        \\b 单词边界 (出现的地方不能是单词字符。)
            hello,world ja?v;a

            hello
            world
            ja
            v
            a

    E:数量词
        X? X,一次或一次也没有 
        X* X,零次或多次 
        X+ X,一次或多次 
        X{n} X,恰好 n 次 
        X{n,} X,至少 n 次 
        X{n,m} X,至少 n 次,但是不超过 m 次9 
(3)正则表达式的功能:
    A:判断功能
        String -- public boolean matches(String regex)
    B:分割功能
        String -- public String[] split(String regex)
    C:替换功能
        String -- public String replaceAll(String regex,String replacement)
    D:获取功能
        Pattern -- public static Pattern compile(String regex)
               public Matcher matcher(String input)
        Matcher -- public boolean find()
                   public String group()
(4)案例:
    A:校验QQ号码。
    B:校验电话号码。
    C:校验邮箱。
    D:按要求分割字符串。
    E:把论坛中的所有数字用*替换。
    F:获取三个字符组成的单词。

2:Random(理解)
(1)用于产生随机数的类。
(2)构造方法:
Random:没有种子。每次产生的都是变化的。
Random(long seed):有种子。种子一样,产生的随机数一致。
(3)成员方法:
int nextInt():返回int范围
int nextInt(int n):返回[0,n)范围
(4)案例:
获取随机姓名。

3:System(理解)
(1)系统类,提供了一些静态的功能供我们使用。
(2)成员方法:
A:public static void gc() 运行垃圾回收器。
B:public static void exit(int status)
终止当前正在运行的 Java 虚拟机。
参数用作状态码;根据惯例,非 0 的状态码表示异常终止。
C:public static long currentTimeMillis()返回以毫秒为单位的当前时间。
D:public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)

4:Date/DateFormat/Calendar(掌握)
(1)Date 日期类。可以精确到毫秒。
A:构造方法
Date()
Date(long time)
B:成员方法
void setTime(long time)
long getTime()
C:要掌握的内容
如何得到毫秒值:
Date – getTime()
System – currentTimeMillis()
如何设置日期的毫秒值:
Date – Date(long time)
Date – setTime(long time)
(2)DateFormat 对日期进行格式化和解析的类。
A:Date – String
public final String format(Date date)
B:String – Date
public Date parse(String source)
C:DateUtil的使用。
(3)Calendar 日历类。把时间给分割成一个个的日历字段,
你可以通过get方法根据给定的日历字段获取对应的值。来组合一个完整的时间。
A:根据给定的日历字段获取对应的值
public int get(int field)
B:设置年月日
public final void set(int year,int month,int date)
C:根据给定的日历字段和值,来决定是加还是减去对应的值
public void add(int field,int amount)
D:获取任意一年的2月份有多少天?


day9

1:对象数组(掌握)
(1)其实就是数组中存储的元素是对象。
(2)案例:
创建一个对象数组存储5个学生对象。并遍历。

2:Collection(掌握)
(1)我们学习的是面向对象的语言,而面向对象的语言操作的时候,是以对象为主。
我们如果想操作多个对象,就必须首先把这个多个对象给存储起来。
到目前位置,我们仅仅只能使用数组来做这个事情。
而数组有一个弊端,就是对象的个数必须是固定的。
这个时候,java就提供了另外的一种容器:集合。
(2)数组和集合的区别?
A:数组
长度固定
元素可以是基本类型,也可以是引用类型。
只能存储同一种数据类型。
B:集合
长度可变
元素只能是引用类型。
可以存储不同的数据类型。
(3)Collection继承体系结构图:
Collection
|–List
|–ArrayList
|–Vector
|–LinkedList
|–Set
|–HashSet
|–TreeSet

    分析:从具体到抽象
    实现:从抽象到具体
    学习:抽象
    使用:具体
(4)Collection集合的功能概述:(自己补齐 补齐方法名称和方法的解释)
    A:添加功能
    boolean add(Object e):往集合中添加一个元素。
    boolean addAll(Collection c):往集合中添加一个集合的元素。

    B:删除功能      
    void clear():移除集合中的所有元素。
    boolean remove(Object o):移除集合中指定的一个元素。
    boolean removeAll(Collection c):移除集合中指定的一个集合的元素。

    C:判断功能
    boolean contains(Object o):判断集合中是否包含指定的元素。
    boolean containsAll(Collection c):判断集合中是否包含指定的一个集合的元素。
    boolean isEmpty():判断集合是否为空。

    D:迭代器   Iterator iterator()用于获取集合中的元素。

    E:长度功能
    int size():获取集合中元素的个数。

    F:交集功能
    boolean retainAll(Collection c)

    G:转换为数组
    Object[] toArray():把集合转换为数组。
(5)迭代器
    A:迭代器是集合的一种遍历方式。
    B:迭代器的使用步骤
        a:通过集合对象获取迭代器对象。
        b:通过迭代器对象判断是否有元素。
        c:通过迭代器对象获取元素,并移动到下一个位置。

    C:每种具体的集合的迭代器的具体实现是在每个具体集合类中。
      以内部类的方式实现的。
(6)案例:
    创建集合对象
    创建元素对象
    把元素添加到集合中
    遍历集合

    A:Collection存储字符串并遍历。

        Collection c = new ArrayList();

        c.add("hello");
        c.add("world");
        c.add("java");

        Iterator it = c.iterator();
        while(it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }

    B:Collection存储自定义对象并遍历。(自己补齐)

3:List(掌握)
(1)List的特点
Collection
|–List
元素有序(存储顺序和取出顺序一致),可重复。
|–set
元素无序,唯一。
(2)List集合的特有功能:(自己补齐 补齐方法的返回值类型和方法说明)
A:添加功能
add(int index,Object) 在指定的位置添加元素。
B:删除功能
remove(int index) 删除指定索引位置的元素,并返回该元素。
C:修改功能
set(int index,Object obj) 用指定的元素修改指定位置的元素,并把修改前的元素返回。
D:获取功能
get(int index) 根据给定的索引,获取元素。
E:列表迭代器
(3)案例:
A:List集合存储字符串并遍历。
a:迭代器
b:普通for(get()和size()结合使用)
B:List集合存储自定义对象并遍历。
(4)ListIterator的使用:
A:可以逆向遍历,但是要先正向遍历,一般不用。
B:并发修改异常的问题:
用迭代器迭代元素的时候,不能通过集合去改变集合。

        解决方案:
            a:集合遍历,集合修改。
            b:列表迭代器遍历,列表迭代器修改。

day10

1:泛型(理解)
(1)泛型类
class Demo {
public void show(QQ qq) {

}
}
(2)泛型方法
class Demo {
public void method(T t) {

}
}
(3)泛型接口
interface Inter {
void show(QQ qq);
}

    //方式1
    class InterImpl implements Inter<String> {
        public void show(String s){

        }
    }

    //方式2
    class InterImpl<QQ> implements Inter<QQ> {
        public void show(QQ qq){
            ...
        }
    }

2:Set(掌握)
(1)Collection
List 有序,可重复。
Set 无序,唯一。
(2)HashSet
如何保证元素唯一性的呢?
底层数据结构是哈希表(散列表)。具体的是由一个元素是单向链表的数组组成。
它依赖于两个方法:hashCode()和equals()方法。
执行顺序:
先判断hashCode()是否相同,
如果相同
继承执行equals()方法,看其返回值:
true:元素重复,不存储。
false:元素不重复,存储。
如果不同
存储。

    记住:
        看到HashXxx结构的集合,就要知道,被该集合存储的元素要重写hashCode()和equals()方法。
        而且,是自动生成的。
(3)TreeSet  
    底层数据结构是二叉树。

    如何保证元素的唯一性的呢?
        根据比较的返回值是否是0来决定。
    如何保证元素的排序的呢?
        A:自然排序 元素具备比较性
            让集合中被存储的元素所属的类实现Comparable接口。
        B:比较器排序 集合具备比较性
            在创建集合对象的时候,让构造方法接收一个Comparator接口的子类对象。
(4)LinkedHashSet
    底层由链表和哈希表组成。
    由链表保证有序。
    由哈希表保证唯一。
(5)案例:
    HashSet:
        存储String
        存储Student
        存储Person
    TreeSet:
        存储String
        存储Integer
        存储Student
        存储Person

3:静态导入(了解)
(1)以前的导入是导入到类的级别,现在可以通过静态导入,导入到方法的级别。
(2)格式:
import static java.xxx.xxx.方法名;

    注意:
        要能看懂这种东西,自己一般不用。

4:可变参数(理解)
(1)针对在写一个方法的时候,不知道具体要有多少个形式参数的时候。
java提供了可变参数的用法。
(2)格式:
修饰符 返回值类型 方法名(数据类型… 变量) {

    }

    注意:
        A:变量其实是该数据类型的一个数组。
        B:形式参数如果有多个的话,可变参数只能是最后一个。
        C:数据类型要一致。
(3)Arrays工具类的asList方法的使用。
    注意:用数组转换后的集合的长度不能发生改变。


        (集合数组之间的相互转换是个不明白的点儿)

day11

1:Map集合(掌握)
(1)Map集合存储是键值对形式的元素。
(2)Map和Collection集合的区别(面试题)
A:Map集合存储的是键值对形式的元素。
Collection集合存储的是单个的元素。
B:Map集合的键是唯一的。
Collection的儿子Set集合元素是唯一的。
C:Map集合的值是可以重复的。
Collection的儿子List集合的元素是可以重复的。
(3)Map集合的功能概述:(自己补齐 方法的名称,返回值,参数列表及解释说明)
A:添加功能
V put(K key,V value):如果键不存在,就是添加功能。如果键存在,就是修改功能。返回的是被修改前的值。

    B:删除功能
    void clear():清空集合中的所有键值对元素。
    V remove(Object key):根据键删除键值对元素,并把值返回。

    C:判断功能
    boolean containsKey(Object key):判断集合中是否包含指定的键。
    boolean containsValue(Object value):判断集合中是否包含指定的值。
    boolean isEmpty():判断集合是否为空。

    D:获取功能
    Set<Map.Entry<K,V>> entrySet():
    V get(Object key):根据键去集合中获取值。
    Set<K> keySet():返回的是集合中所有键的元素。
    Collection<V> values():返回的是集合中所有值的元素。


    E:长度功能
    int size():集合中的键值对元素的对数。
(4)Map集合的遍历:
    A:通过键找值
        a:获取所有键的集合。keySet()
        b:遍历键的集合,得到每一个键。增强for。
        c:根据键去map集合中找值。get(K key)。

    B:通过键值对对象找键和值(理解)
        a:获取所有键值对对象的集合。entrySet()。
        b:遍历键值对对象的集合,得到每一个键值对对象。增强for。
        c:根据键值对对象获取键和值。getKey(),getValue()。
(5)HashMap案例:
    A:HashMap<String,String>
    B:HashMap<Integer,String>
    C:HashMap<String,Student>
    D:HashMap<Student,String>
(6)TreeMap案例:
    A:TreeMap<String,String>
    B:TreeMap<Student,String>
(7)其他的案例:
    A:HashMap嵌套HashMap并遍历。
    B:HashMap嵌套ArrayList并遍历。
    C:ArrayList嵌套HashMap并遍历。
    D:统计字符串中每个字符出现的次数。
(8)Hashtable和HashMap的区别?(面试题)
    A:HashMap 线程不安全,效率高。允许null键和null值。
    B:Hashtable 线程安全,效率低。不允许null键和null值。

2:Collections工具类的使用。
(1)Collections是针对集合进行操作的工具类。
(2)Collection和Collections的区别?
A:Collection 是集合的顶层接口,定义了集合中的共性功能。
B:Collections 是针对集合进行操作的工具类。提供了排序,查找等功能。
(3)Collections常见的功能:
A:排序
B:二分查找
C:最大值
D:反转
E:随机置换
(4)扑克牌案例:
A:模拟洗牌
B:模拟洗牌,并对牌进行排序。


day12

1:总结集合,请参照集合的总结图.bmp即可。

2:异常(理解)
(1)程序出现的不正常的情况。
(2)异常的继承体系结构:
Throwable
|–Error 严重的问题,一般我们解决不了。
|–Exception
|–RuntimeException 运行时期异常,这种问题一般要修正代码。
|–非RuntimeException 编译时期异常,必须进行处理,否则代码不能够通过。

    举例:
        石家琦骑自行车去山区旅游。
        问题1:山路塌陷
        问题2:车没有轮胎
        问题3:好路不走,偏偏走石子路
(3)JVM针对异常的默认处理方案:
    默认情况下,会把异常的类名,原因,及错误出现的位置输出在控制台。
    并从这个地方终止程序运行。
(4)我们自己如何针对程序进行处理:
    A:try...catch...finally
        基本格式:
            try {
                可能有问题的代码。
            }catch(异常类名 变量名){
                异常的处理。
            }finally {
                释放资源。(IO,数据库操作比较常见)
            }
        变形格式:
            try...catch...
            try...catch...catch...
            try...catch...finally...
            try...catch...catch...finally...
            try...finally...

        针对一个try多个catch的情况:

            父异常必须放最后。
            try{

            }catch(){

            }catch(){

            }

            JDK7的新特性:这个要求都是平级关系。

            try{

            }catch(异常1 | 异常2 ... 变量){}
    B:throws
        后面跟的是异常类名。
        位置:在方法的()后面。

    注意:
        能try...catch就不要throws。
        但是,目前讲课为了方便,我都throws。
(5)编译时期异常和运行时期异常的区别?
    A:编译时期异常 必须进行处理的。
    B:运行时期异常 可以处理,也可以不处理。
(6)throws和throw的区别?
    A:throws
        位置:在方法()后面,跟的是类名。
        如果后面根据的是RuntimeException及其子类,那么,该方法可以不用处理。
        如果后面根据的是Exception及其子类,那么,必须要编写代码进行处理,或者调用的时候抛出。
    B:throw
        位置:在方法中,跟的对象名称。
        如果方法中,有throw抛出RuntimeException及其子类,那么,声明上可以没有throws。
        如果方法中,有throw抛出Exception及其子类,那么,声明上必须有throws。
(7)自定义异常
    只需要继承自Exception或者RuntimeException。
    提供构造方法即可。

3:File(理解)
(1)IO流操作最主要的作用就是上传文件和下载文件。
而File类是java提供给我们用来表示文件的类。
(2)File的构造方法:
A:File file = new File(“d:\\a.txt”);
B:File file = new File(“d:\\”,”a.txt”);
C:File file = new File(“d:\\”);
File file2 = new File(file,”a.txt”);
(3)File类的常见功能:(自己补齐)
A:创建功能
创建文件
public boolean createNewFile():如果文件存在,就不创建。否则,创建。
创建文件夹
public boolean mkdir():如果文件夹存在,就不创建。否则,创建。
public boolean mkdirs():如果多级文件夹存在,就不创建。否则,创建。
B:删除功能
public boolean delete() 删除文件或者文件夹。
C:重命名功能
public boolean renameTo(File dest):
如果路径相同,就是改名。
如果路径不同,就是剪切。
D:判断功能
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏
public boolean isDirectory():是否是文件夹
public boolean isFile():是否是文件
public boolean exists():是否存在
E:获取功能
public String getAbsolutePath():获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称
public long length():获取文件字节数
public long lastModified():获取最后一次修改时间的毫秒值
F:高级获取功能
public String[] list():获取指定目录下的所有文件或者文件夹的名称(String)数组。
public File[] listFiles():获取指定目录下的所有文件或者文件夹的文件(File)数组。
G:带过滤器的高级获取功能
public String[] list(FilenameFilter filter):
(4)案例:
A:获取指定目录下指定后缀名的文件的名称。
a:基本做法。先获取所有的,然后遍历的时候,判断。
b:用过滤器的做法。先判断,获取,最后遍历。
B:批量修改文件名称。


day13

1:递归(理解)
(1)方法定义中调用方法本身的现象。
举例:
老和尚给小和尚讲故事。
我们学编程。
(2)递归的注意事项:
A:递归一定要有出口,否则就是死递归。
B:递归的次数不能太多,否则内存溢出。
C:构造方法不能递归使用。
(3)递归解决问题的基本思想:
A:分解和合并。
B:找哪些东西
出口
规律
(4)递归的题目:(至少看一遍)
A:递归求阶乘
B:兔子问题
C:递归输出指定目录下指定后缀名的文件绝对路径
D:递归删除带内容的目录

2:IO流(掌握)
(1)IO流的作用:上传文件和下载文件。
上传文件:
数据源:本地
目的地:服务器
下载文件:
数据源:服务器
目的地:本地
(2)IO流的分类:
A:流向
输入流 读取数据
输出流 写出数据
B:数据类型
字节流
字节输入流
字节输出流
字符流
字符输入流
字符输出流

    一般来说,如果没有说明按照哪种类型分,指的是按照数据类型分。
(3)什么时候使用字符流,什么时候使用字节流。
    如果一个要操作的文件,通过记事本打开并能够读懂其内容,就可以考虑使用字符流。
    否则,就使用字节流。

    什么都不知道,就用字节流。
(4)IO的基类及具体类
    IO
        |--字节流
            字节输入流
                InputStream
                    FileInputStream
            字节输出流
                OutputStream
                    FileOutputStream
        |--字符流
            字符输入流
                Reader
                    FileReader
            字符输出流
                Writer
                    FileWriter
(5)FileWriter写数据的步骤及代码体现:
    步骤:
        A:创建字符输出流对象。
        B:调用write方法。
        C:释放资源。

    代码体现:
        FileWriter fw = new FileWriter("fw.txt");

        fw.write("hello,io");

        fw.close();

    几个要注意的小问题:
        A:创建字符输出流对象做了哪些事情?
        B:为什么要刷新缓冲区?
        C:为什么要释放流资源?
        D:刷新和释放有什么区别?
        E:如何实现数据的换行?
        F:如何实现数据的追加写入?
(6)FileReader读数据的步骤及代码体现:
    步骤:
        A:创建字符输入流对象。
        B:调用read方法,并把数据显示在控制台。
        C:释放资源。

    代码体现:
        FileReader fr = new FileReader("fr.txt");

        //方式1:一次读取一个字符
        int ch = 0;
        while((ch=fr.read())!=-1) {
            System.out.print((char)ch);
        }

        //方式2:一次读取一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while((len=fr.read(chs))!=-1) {
            System.out.print(String.valueOf(chs,0,len));
        }

        fr.close();
(7)复制文本文件:
    两种方式操作。代码自己补齐。

    数据源:c:\\\\a.txt
    目的地:d:\\\\b.txt
(8)加入异常后的代码(看懂即可)
    A:FileWriter写数据
    B:字符流复制文本文件

day14

1:字节流(掌握)
(1)继承体系
InputStream
FileInputStream
OutputStream
FileOutputStream
(2)案例:
A:字节流复制文本文件。
B:字节流复制图片。
C:字节流复制MP4并测试效率。

2:高效流(掌握)
(1)字符高效流
BufferedReader
BufferedWriter

    案例:
        高效流复制文本文件。
(2)字节高效流
    BufferedInputStream
    BufferedOutputStream

    案例:
        高效流复制图片。
(3)字符高效流的特殊功能
    BufferedReader
        String readLine()
    BufferedWriter
        void newLine()

    案例:
        高效流特殊功能复制文本文件。
(4)IO流的使用
    文本文件的复制:9种。
        字节流:4种
        字符流:5种

    二进制流数据的复制:4种。
        音视频文件。

3:转换流(理解)
(1)键盘录入写到文本文件。
用Scanner实现。
(2)用System.in录入数据,写到文本文件。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    理解:从字节到字符
    使用:从字节到字符
(3)把文本文件的数据,用System.out写到控制台
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    理解:从字符到字节
    使用:从字节到字符
(4)案例:
    数据源     目的地
    a.txt       b.txt
    a.txt       System.out
    System.in   b.txt
    System.in   System.out
(5)案例:
    System.in -- a.txt -- b.txt -- System.out
(6)案例:
    A:ArrayList<String> -- a.txt
    B:a.txt -- ArrayList<String>

4:登录注册案例(理解)
注册:写数据
登录:读数据

接口:定义要做什么,但是不提供实现。

day15

1:字符编码(理解)
(1)编码表:由字符及其对应的数值组成的一张表。
(2)常见的编码表:
ASCII
ISO-8859-1
gb2312
gbk
gb18030
big5
utf-8
(3)编码问题:
A:IO流中的编码问题
B:String类中的编码问题

    记住:统一编码最好。

2:Properties(理解)
(1)是键值对形式的属性列表。是Map体系的一个集合类。
可以和IO流进行结合使用。
(2)案例:
A:作为Map集合的使用。
B:作为集合的特有功能使用
a:setProperty(String key,String value)
b:getProperty(String key)
stringPropertyNames()
C:和IO流结合使用的例子
a:load() 把文件中的数据加载到集合中
b:store() 把集合中的数据存储到文件中
D:给你一个文件,user.txt。请判断里面是否有键为”lisi”的,如果有,则修改其值为100。

3:打印流(掌握)
(1)打印流仅仅是用来写数据的,没有读取数据的。
(2)打印字节流 PrintStream
System:
public static final PrintStream out

        System.out.println();

   打印字符流 PrintWriter
(3)特点:
    A:可以把任意类型的数据写到文本文件。
    B:如果启动了自动刷新,在调用println()的方法的时候,可以自动刷新,并换行。
    C:可以直接对文件进行操作。
        问题:哪些流可以直接对象文件进行操作。
        看API,流的构造方法,如果可以同时有File和String类型的参数,就可以。
(4)案例:
    通过打印流改进复制文本文件的代码

    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);

    String line = null;
    while((line=br.readLine()) != null) {
        pw.println(line);
    }

    pw.close();
    br.close();

4:序列化和反序列化流(理解)
(1)序列化:把对象按照流一样的方式存储到文件中或者在网络中传输。
简记:把对象按照流一样操作。
反序列化:把文件中或者网络中的流数据还原成对象。
简记:流数据还原对象。
(2)对象怎么才能实现序列化呢?
让对象所属的类实现序列化接口。
(3)记住:
看到一个类实现了序列化接口,就要知道,该类的对象可以被序列化流进行操作。
将来还可以通过反序列化流还原。
如果想在序列化后,对java文件做一些简单的改动,不影响以前写过的数据,
那么,就应该在java文件中给出固定的序列化id值。
而且,这样做了以后,还可以解决黄色警告线问题。

5:其他的几个了解的流对象(理解)
(1)DataOutputStream/DataInputStream
可以把基本数据类型的数据写到文件,也可以还原为基本的数据类型的数据。
只不过,要注意还原时候的顺序和写的顺序要一致。
(2)ByteArrayOutputStream,ByteArrayInputStream
(3)CharArrayWriter,CharArrayReader


day16

1:多线程(理解)
(1)多线程:应用程序有多条执行路径。
进程:正在运行的应用程序,系统会为其分配空间。
每个进程具备独立的空间。
线程:应用程序的执行单元,执行路径。
线程共享同一个进程的资源。
单线程:应用程序只有一条执行路径。
多线程:应用程序有多条执行路径。

    举例:
        迅雷下载。
(2)多线程的两种实现方案:(参照 多线程两种实现方案的比较和几个小问题.bmp)
    A:继承Thread类
    B:实现Runnable接口
(3)面试题
    A:start()和run()的区别。
    B:线程随机性原理。
    C:线程的生命周期图。

    D:同步的方式有几种。
    E:sleep()和wait()的区别?
(4)卖票案例:
    A:通过继承Thread类实现
    B:通过实现Runnable接口实现
(5)卖票案例:
    加入模拟等待版本。

    这个时候就出问题了。
    A:同一张票被卖了多次。
    B:出现了负数票。
(6)线程安全问题:
    如何分析线程安全问题呢?
    A:是否是多线程环境
    B:是否有共享数据
    C:对共享数据是否有多条语句操作
(7)解决办法:同步
    同步代码块:
        synchronized(锁对象) {
            需要被同步的代码。
        }
    A:锁对象可以是哪些呢?
        Object的对象。这个锁对象可以是任意对象。
        但是一定要注意,多个线程必须使用的是同一个锁对象。
    B:需要被同步的代码是哪些呢?
        共享数据
        共享数据是否有多条语句操作

day17

多线程:(理解上非常重要,EE开发用的较少,android稍微多一点点)
A:多线程概念
进程:正在运行的应用程序。
线程:应用程序的执行路径,执行单元。

    多线程:一个应用程序有多条执行路径。
B:实现方案
    A:继承Thread类
    B:实现Runnable接口
C:线程的随机性原理
    CPU在多个程序间做着高效的切换来执行程序的。
D:线程的生命周期
    新建 -- 就绪 -- 运行 -- 死亡

    运行 -- 阻塞 -- 就绪
E:线程安全问题的产生及解决
    a:多线程环境
    b:是否有共享数据
    c:共享数据是否被多条语句操作

    解决方案:
        a:同步代码块
        b:同步方法
        c:JDK5以后的Lock锁。
F:同步的锁对象
    代码块:任意对象
    方法:this
    静态方法:类名.class
G:线程间的通信
    不同种类的线程针对同一个资源的操作。

面试题:
A:多线程有几种实现方案?分别怎么实现的?
B:如何启动一个线程?
C:start()和run()方法的区别?
D:sleep()和wait()方法的区别?
sleep():必须指定时间。不释放锁对象。
wait():可以指定时间,也可以不指定时间。释放锁对象。
E:线程的生命周期。
F:同步有几种方案?分别怎么实现?
G:生产者和消费者多线程案例。
单生产单消费
多生产多消费
H:请自己写4个线程,操作一个数据,
其中两个线程对这个数据做加法操作,另外两个线程对这个数据做减法操作。

    张孝祥java就业面试宝典.chm 中的第一个J

以上是关于JAVASE总结笔记的主要内容,如果未能解决你的问题,请参考以下文章

JavaSE学习笔记

黑马Java笔记+踩坑汇总JavaSE+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud/SpringCloudAlibaba+黑马旅游+谷粒商城

JAVASE知识点总结

[javase学习笔记]-8.7 静态代码块

[javase学习笔记]-8.8 构造代码块

JavaSE笔记之注解和反射(含案例代码)