目录

面向对象

类和对象

封装

封装的概述

封装的好处

封装的原则

private关键字概述和特点

特点

this关键字

特点

简单讲解

封装表现

方法组成

构造方法（构造器）

作用：为属性赋初始值；

特征：

static静态关键字

特点

成员变量和静态变量的区别

1、所属不同

2、存储位置不同

3、内存出现的时间不同

4、调用不同

mian方法和格式

2、格式解释

get/set方法

面向对象之构造方法概述与格式

概述和作用

特点

全局变量和局部变量的区别

全局变量

局部变量：

面向对象--匿名对象概述和使用

1、什么是匿名对象

2、匿名对象的应用场景

创建对象的步骤逻辑

b/s 和c/s

b /s:浏览器服务器

c/s :客户端服务器

第一章

Java简介

查看JDK是否配置成功

在cmd下运行Java源文件

第二章

8种数据类型

数据类型之间的优先级

变量名规则

&& 与 &的区别

|| 与 |的区别

！

第三章

while循环

do-while循环

for循环

break

continue

if 和switch的区别：

if-else if

第四章

数组的遍历

一维数组的增强for循环遍历方式

二维数组的增强for循环遍历方式

获取二维数组的长度的方法

栈、堆和方法区

堆区:

栈区:

方法区:

继承

1、继承的格式

2、继承的好处和弊端

3、java中继承的特点

4、Java中继承注意事项

this和super的区别

super

区别

1、调用成员变量

2、调用构造方法

3、调用成员方法

4、继承中构造方法的关系

5、静态代码块和构造代码块

方法重写

概念：

应用：

方法重写注意事项

Overload和Override的区别

final关键词

final修饰变量的初始化时机

多态

1、概述

2、前提

3、多态中成员访问特点

成员变量

成员方法

静态方法

4、动态的好处和弊端

好处

弊端

抽象类

格式

抽象类如何实例化

特征

接口

什么是接口

特点

异常

1、异常的简介

2、异常类的继承关系

3、异常的处理机制

关键字finally

4、自定义异常

集合

1、集合的由来

2、迭代器

3、List里面的迭代器（ListIterator）

4、Vector

5、Set集合

1、HashSet

2、linkedHashSet

3、TreeSet原理

6、Map

Map的遍历

基本类型包装类

1、为什么会有基本数据类型包装类

2、常用的操作

3、 基本数据类型对应的包装类

泛型

1、好处

2、泛型的基本使用

3、泛型通配符

设计模式

装饰设计模式

线程

1、什么是线程？

2、多线程并行和并发

3、Java运行程序的原理和JVM的启动是多线程吗？

4、线程应用实现方式

thread类

Runnable接口

5、匿名内部类实现线程的方式

6、获取名字和设置名字

获取名字

设置名字

7、获取当前线程的对象

8、休眠线程

9、守护线程

10、加入线程

11、设置线程的优先级

12、同步代码块

13、线程安全问题

14、死锁

反射

创建对象

javabean

Inspector（内省机制）

数据库链接步骤

---

面向对象

类和对象

java实现跨平台是因为它编译为字节码之后，可以在Java虚拟机上运行，通过Java虚拟机可以编译为其他想要的编程语言，非常方便。

类：抽象出来的行为(方法) 和 特征(属性)的模板；

对象是什么：该类的具体实现，对象，看得见摸得着

类名的首字母大写，见文知意 属性名首字母小写 人： 名字 年龄 身高 性别

封装

封装的概述

• 是指隐藏对象的属性和方法的细节，仅对外提供公共的访问方式

封装的好处

• 隐藏实现细节，提供对外的公共的访问方式

• 提高了代码的复用性

• 提高了安全性

封装的原则

• 将不需要对外提供的内容都隐藏起来

• 把属性隐藏，提供公共方法对其访问

private关键字概述和特点

特点

• 一个权限修饰符，本类中可用

• 修饰成员变量和成员方法（可以）

• 针对整个类，在方法中使用没有意义

this关键字 特点

• 代表当前对象的引用

简单讲解

• this应用场景：目前而言代表当前类，用来区分成员变量和局部变量

封装表现

属性私有化，公开get、set方法

方法组成

访问权限 返回值类型 方法名（参数列表）

构造方法（构造器）

作用：为属性赋初始值；

特征：

• 1方法名与类名一致

• 2没有返回类型

• 3当一个类没有任何构造方法时，则系统默认给一个无参的构造方法

• 4当一个类中有带参的构造方法，则系统默认的无参构造方法失效，想再使用，需要显式声明

static静态关键字 特点

• 随着类的加载而加载

• 静态优先于对象

• 被类的所有对象共享

• 可以用类名直接调用，也可以用对象调用

• 静态修饰的内容我们一般称之为与类相关的，类成员

 

成员变量和静态变量的区别

1、所属不同

• 静态变量属于类，称为类变量

• 成员变量属于对象，可以称为对象变量

2、存储位置不同

• 静态变量存储于方法区的静态区

• 成员变量存储在堆内存中

3、内存出现的时间不同

• 静态随着类的加载而加载

• 成员变量随着对象的对象的创建而存在

4、调用不同

• 静态可以可以被类名和对象调用

• 成员变量只能通过对象调用

mian方法和格式

1、格式

public static void main(String[] args){
    
}

2、格式解释

• public 被jvm调用，访问权限足够大

• static 被jvm调用，不用创建对象，直接类名访问比较快

• void 被jvm调用，不需要给jvm返回值

• mian 一个通用名称，虽然不是关键字，但是被jvm识别

• String[] args

get/set方法

• set没有返回值

• get有返回值

• 要有测试类

面向对象之构造方法概述与格式

概述和作用

• 给对象的属性值进行初始化赋值、

特点

• 1方法名与类名一致

• 2没有返回类型

• 3当一个类没有任何构造方法时，则系统默认给一个无参的构造方法

• 4当一个类中有带参的构造方法，则系统默认的无参构造方法失效，想再使用，需要重新声明

全局变量和局部变量的区别

全局变量

成员变量：全局变量==》在这个类中谁都可以用

位置：类中 方法外

生命周期：随着类的加载而加载，随着类的消失而消失·

存储位置：在堆中

初始值：可以不赋值 因为本身就有初始值

局部变量：

位置：在方法中 在方法上

生命周期：随着方法的加载而加载，随着方法的消失而消失

存储位置：在栈中

初始值：没有初始值，如果要使用必须给初始值

局部变量需要使用必须赋值才能使用。

当全局变量和局部变量相同的时候（全局和局部变量可以相同），有一个优先级关系：就近原则。

面向对象--匿名对象概述和使用

1、什么是匿名对象

大白话说：就是没有名字的对象

2、匿名对象的应用场景

• 调用方法的时候，仅仅只能调用一次，好处：节省代码调用多次的时候，千万别用调用完就变成垃圾了，可以被垃圾回收

//例如
new Student.run();

匿名对象可以作为参数对象

//例如
public void a1(Student s){
}

创建对象的步骤逻辑

 

b/s 和c/s

b /s:浏览器服务器

c/s :客户端服务器

第一章

Java简介

查看JDK是否配置成功

cmd ->javac：出现一堆东西即配置成功 1.首先查看系统是否安装有jdk，打开cmd在DOS窗口输入 java -version查看jdk版本信息 2.你也可以输入 java -verbose查看jdk安装路径： 3.查看是否配置JAVA_HOME环境变量，输入 set JAVA_HOME，若已经配置，会出现配置路径 4.配置JAVA_HOME环境变量，输入set JAVA_HOME=C:Program FilesJavajdk1.8.0_102,回车，然后，输入set JAVA_HOME查看

在cmd下运行Java源文件

• 首先进入相应的盘

• 然后相应的源文件路径

• 编译源文件：javac 源文件名

• 运行编译后的字符码文件：java 编译后字节码的源文件名,此处不用写后缀

• 提取文档：javadoc 源文件名

第二章

8种数据类型

数据类型	所占的字节(byte) {1 byte = 8 bit}
整型 byte	1 范围: {-2的7次方~2的7次方}
整型 short	2 范围: {-2的15次方~2的15次方}
整型 int	4
整型 long	8 特殊符号： 整型默认是int型所以要在数后加"L"
浮点型 float	4 特殊符号： 浮点型默认是double型所以要在数后加"F"
浮点型 double	8
字符型 char	2
布尔型 boolean	1,4,1/8

数据类型之间的优先级

很清楚啦，byte、short、char是一个级别的，它们之间的运算都会转换为int类型，注意，自己跟自己运算也会转为int类型。int之后从小到大依次为：long、float、double。至于boolean，他是个比较特殊的类型。

String不是基本数据类型，是引用类型；变量是存储数据的基本单元

变量名规则

• 变量名前面不能是数字

• 变量名前面可以是字母、下划线、$，其他符号不行

• 变量明前面单词字母要小写后面单词首字母大写（标准写法）

• 变量名后面数字也可以添加了，除了￥后面不能跟其他符号

• 中间不可以有空格

• 变量名不能是关键字

• 变量得先赋值才能用

• 避免第二个字母大写（细节）

&& 与 &的区别

• && 条件1 && 条件2：条件1为假，条件2就不执行了（比&效率高）

• & 不管有几个条件都走一遍（效率低）

|| 与 |的区别

• || 条件1 || 条件2：条件1为真，条件2就不执行了（比|效率高）

• | 不管有几个条件都走一遍（效率低）

！

• 条件为真，结果为假

• 条件为假，结果为真

第三章

while循环

//先判断后执行
while(循环的条件){
    循环体
}

do-while循环

//先执行后判断 循环一次
do{
    循环体
}while(循环的条件);//不能忘了分号

for循环

for(循环的条件){
    循环体
}

break

直接跳出整个循环体。

continue

结束本次循环过程，接着进行下一次循环过程。

if 和switch的区别：

• if 主要针对于不确定的值

• switch主要针对于确定的值

if-else if

区间越小的放在越上前。

第四章

数组的遍历

一维数组的增强for循环遍历方式

for(int i:array){
    System.out.println(i);
}

二维数组的增强for循环遍历方式

for(int[] i:array){//返回数据类型多加了一个中括号，遍历二位数组中一维数组
    //获得二维数组中的一维数组的地址
    for(int j:i ){//把数组里面的数遍历出来
         System.out.println(j);
    }
   
}

//如下可以输出二维表
public class Test02 {
	public static void main(String[] args) {
		int[][] arr = new int[10][10];
		arr[1][2]=11;
		arr[0][0]=11;
		for(int[] i:arr){
			for(int j:i){
				System.out.print(j+"t");
				
			}
			System.out.println();
			
		}
	}
}

//结果
11	0	0	0	0	0	0	0	0	0	
0	0	11	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0

获取二维数组的长度的方法

• 获取第一维数组的长度

int a = array.length;

获取第二维数组的长度的方法

int b = array[i].length;

栈、堆和方法区

详解：java存储机制（栈、堆、方法区详解）_王小的博客-CSDN博客_java堆栈方法区

堆区:

1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令) 2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身 。

栈区:

1.每个线程包含一个栈区，栈中只保存基础数据类型的值和对象以及基础数据的引用 2.每个栈中的数据(基础数据类型和对象引用)都是私有的，其他栈不能访问。 3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。

方法区:

1.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。 2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。

继承

1、继承的格式

public class 子类 extends 父类{
    
}

2、继承的好处和弊端

• 好处：提高了代码的复用性，提高了代码的维护性，让类与类之间产生了关系，是多态的前提

• 弊端：类的耦合性增强了，Java的核心思想是高内聚低耦合

• 耦合：就是类与类的关系

• 内聚：就是自己完成某件事的能力要高

3、java中继承的特点

• 只支持单继承，不支持多继承

• 支持多层继承

4、Java中继承注意事项

• 子类只能继承父类非私有成员方法及成员变量

• 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法

• 不要为了部分功能去继承

• 什么时候使用继承：类A是类B的一种，或者类B是类A的一种

• 子类中的方法的权限必须高于父类中的方法（方法名相同的时候）

• 有同名时采用就近原则

this和super的区别

super

是子类局部范围访问父类成员变量的关键字

区别

1、调用成员变量

• this.成员变量：可以调用本类和父类的成员变量（有同名时采用就近原则）

• super.成员变量：调用父类的成员变量

2、调用构造方法

• this(...) 调用本类中的构造方法

• super(...) 调用父类中的构造方法

3、调用成员方法

• this 可调用父类和本类中的成员方法（有同名时采用就近原则）

• super 调用父类中的成员方法

• super要写到方法中才能调用父类成员方法

4、继承中构造方法的关系

• 实例化子类对象（假如是无参构造），须先执行父类构造，其次子类构造（因为子类无参构造中首行隐藏 super();）

• 子类中super(参数）;中的参数必须和父类的参数数据类型对应，其中的参数数据类型和参数名和子类本构造方法中的参数相同；

• 有参构造中没有隐藏的super(参数)，但是首行要有super(参数);

• 如果父类没有的构造样式，子类不能有

5、静态代码块和构造代码块

• static代码块-->构造代码块-->构造方法

• static：父类-->子类

• 构造代码块和构造方法（在一块），父类-->子类

方法重写

概念：

子类中出现了和父类的方法名相同，返回值必须一致

应用：

当子类需要父类的功能的时候，而功能主题特有自己的功能的时候，可以重写

方法重写注意事项

• 父类中私有方法不能重写

• 子类重写的方法权限要高于或等于父类中的方法

• 父类中是静态方法必须用静态方法重写

• 参数列表中个数相同，顺序一致，参数类型一致，返回值必须一致

Overload和Override的区别

• Override：参数相同（范围），返回值相同，静态多态，调用的函数在编译时被选中

• Overload: 参数不同（范围），返回不同 ，运行时是多态性的

final关键词

final修饰变量的初始化时机

• 在对象构造完成之前完成

• 定义变量时，修饰的变量是不可变的，变量必须给

• 定义对象时

final Person p = new Person("张三",22);
			p = new Person("李四",21);//错误，不可改变里面的属性值
//如果要强行改变,调用set方法
			p.setName = "李四";
			p.setAge = 21;

• 一般不定义方法，不对里面的参数起到作用

多态

1、概述

• 事物存在的多种形态

2、前提

• 要有继承关系

• 要有方法重写

• 要有父类引用指向子类对象

3、多态中成员访问特点

成员变量

• 编译看左边，运行看左边

成员方法

• 编译看左边，运行看右边，因为子类对该成员方法进行了重写

静态方法

• 编译看左边，运行看左边

4、动态的好处和弊端

好处

• 提高了代码的维护性（继承保证）

• 提高了代码的扩展性（多态保证）

弊端

• 不能使用子类特有的属性和行为

抽象类

格式

abstract class 类名{//抽象类
public abstract void aaa();//抽象方法
}

• 抽象类中不一定有抽象方法

• 在一个类中出现了抽象方法必定是一个抽象方法或者是一个接口

• 抽象类不能实例化

• 抽象类的子类要吗是抽象类

• 要吗是重写抽象类中所有的抽象方法

抽象类如何实例化

• 按照多态的方法，父类引用指向子类对象

特征

• 抽象方法：是强制要求子类完成的

• 非抽象方法：子类继承的事情，提高代码的复用性

接口

什么是接口

• 侠义角度：接口就是interface

• 广义角度：对外提供规则的都是接口

特点

• 用关键字interface表示

• 格式：interface + 接口名{}

• 类实现接口 implements

• 格式：class 类名 implements 接口名称1,接口名称2...{}

• 接口不能实例化，要实例化就得按照多态的思想

• 接口的子类可以是抽象类，意义不大

• 可以是具体的实现类，重写接口中所有的抽象方法

• 接口可以继承接口，继承的接口的所有需要被实现类实现的方法都被继承过来了

• 接口中的成员变量永远是 public、static、final 的

• 接口不会有构造方法

• 默认修饰符 public、abstract

异常

1、异常的简介

• 运行期间发生错误，而不是编译期间发生错误

2、异常类的继承关系

• 异常的根类：Throwable

• 两个子类为Error、IOError（两重大错误、底层、低级的、不可恢复的严重错误）和Exception（普通异常）

• 异常的分类

  • 检查性异

    必须写出相应的处理，否则无法运行

  • 非检查性异常

    没必要写出相应的处理，可编译运行

3、异常的处理机制

• try{}catch(){}，catch来捕获try抛出的异常

• 有try的情况下，可以有多个catch，捕获不同类型的异常

• Throws 异常名称，抛给下一个调用者处理

关键字finally

1. 放在try{}catch(){}的后面

2. finally所封装的语句，不管是否捕获成功，都是要执行的

3. 通常是作为进行资源的清除工作

4. 对应finally代码中的语句块，即使try{}catch(){}中使用了return、break、continue，它还是会执行，只要代码没运行到它前面退出虚拟机（System.exit(0);）它都执行。

4、自定义异常

集合

1、集合的由来

• 数组长度的固定，当数组增加或者减少元素的时候，太麻烦了，所以Java给我们提供了集合。

• 数组在内存中开辟等量空间，效率高，数组可以理解为无夹心的，集合可以理解为有夹心的

Collection collection = new ArrayList<>();//只可以存储String类型的东西
Collection collection2 = new ArrayList();//可以存储任何类型的东西

2、迭代器

• 迭代器的概念：查看集合元素的就叫迭代器

InteraIterator inte = collection2.iterator();
while(inte.hasNext){
    System.out.println(inte.next);
}

3、List里面的迭代器（ListIterator）

List list = new ArrayList();
		ListIterator iListIterator = list.listIterator();
		while(!iListIterator.hasNext()){
			list.add("word");
		}

• hasNext()和hasPrevious()是一对，想要用hasPrevious()，必须先用hasNext(),涉及到指针问题，刚开始指针都指向下标0；

4、Vector

Vector v =new Vector();
v.addElement("a");
v.addElement("b");
v.addElement("c");
//迭代
Enumeration enumeration = v.elements();//Enumeration是Vector的迭代器
while (enumeration.hasMoreElements()) {
    System.out.println(enumeration.nextElement());
}

5、Set集合

1、HashSet

• 当HashSet调用add方法存储对象的时候，先调用对象的hashcode方法得到一个哈希值，然后在集合中查找是否有和哈希值相同的对象

• （1）如果得到一个相同的哈希值，就逐个比较，相同的抛出，不同的存入

• （2）如果没有相同的就直接存入

2、linkedHashSet

• 怎么存怎么取

• 用底层链表实现

• 保证元素的唯一性

3、TreeSet原理

• 特点：treeset是用来排序的，可以指定一个顺序，对象存入之后会按照顺序排序

• 自然排序 comparable

  TreeaSet类的add方法中把存入的对象提升为comparable类型调用对象的compareTo()方法和集合中的对象进行比较，根据compareTo()方法返回的结果进行存储

• 比较器顺序 comparator

  创建treeSet 的时候可以制定一个comparator,如果传入了comparator子类对象，那么treeSet就会按照比较器的顺序排序，add()会自定调用comparator中的compare()方法排序，调用的对象是compare方法的第一个参数，集合中的对象是第二个参数。

• 区别

  TreeSet构造函数什么都不传，按照默认类中的comparable的顺序

  TreeSet如果传入comparator,就会先安装comparator

6、Map

package Demo_Map;

import java.util.HashMap;
import java.util.Map;

public class MyMap {
    public static void main(String[] args) {
        Map myMap = new HashMap();
        System.out.println(myMap.put(1,"hello"));
        myMap.put(2,"hi~");
        System.out.println(myMap.put(1,"world"));
        System.out.println(myMap.containsKey(1));
        System.out.println(myMap.containsKey("hello"));
        System.out.println(myMap.isEmpty());
        System.out.println(myMap.entrySet());
        System.out.println(myMap.values());
        System.out.println(myMap.keySet());
        System.out.println(myMap.get(2));
    }
}

//运行结果
null
hello
true
false
false
[1=world, 2=hi~]
[world, hi~]
[1, 2]
hi~

Map的遍历

package Demo_Map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MyMap {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("张三",12);
        map.put("李三",12);
        map.put("王三",12);
        map.put("奥三",12);
        map.put("常三",12);
        Set keyset = map.keySet();
        Iterator it = keyset.iterator();
        while (it.hasNext()){
            String key = it.next();
            Integer value = map.get(key);	
            System.out.println("key："+key+"-->value："+value);
        }
        Set> entrySet = map.entrySet();
        Iterator> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry en = iterator.next();
            String str = en.getKey();
            Integer num = en.getValue();
            System.out.println("str："+str+"num："+num);
        }

    }
}
//结果
key：王三-->value：12
key：张三-->value：12
key：李三-->value：12
key：常三-->value：12
key：奥三-->value：12
str：王三num：12
str：张三num：12
str：李三num：12
str：常三num：12
str：奥三num：12

基本类型包装类

1、为什么会有基本数据类型包装类

• 将基本数据类型包装成对象的好处可以在对象中定义更多的功能，这些功能或者是方法可以操作数据

2、常用的操作

• 用于基本数据类型与字符串之间的转换

3、 基本数据类型对应的包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
double	Double
long	Long
float	Float
char	Character
boolean	Boolean

• Integer构造器可以放String类型的数据，但是得是数字型的数字

泛型

1、好处

• 提高安全性

• 省去了强转

2、泛型的基本使用

• <>里面的类型必须是引用数据类型

• 前后反省必须一致，后面的泛型可以不写内容，自动跟前面一致

3、泛型通配符

• ? extends E，向下限定，E 及其子类

• ? super E，向上限定，E 及其父类

设计模式

装饰设计模式

• 接口

package Demo_shejimoshi;

public interface Coder {
    public void code();
}

• Student类

package Demo_shejimoshi;

public class Student implements Coder{
    @Override
    public void code() {
        System.out.println("发现能力不足以找工作");
    }
}

• TengtaiStudent类

package Demo_shejimoshi;

public class TengTaiStudent implements Coder{
    
    private Student s;
    public TengTaiStudent(Student s){
        this.s = s;
    }
    @Override
    public void code() {
        s.code();
        System.out.println("来滕泰学习来咯");
    }
}
/

线程

1、什么是线程？

• 线程是程序的一个执行的路径，一个进程包含多个线程，多线程并发执行，提高程序的效率，可以同时完成多项工作，

2、多线程并行和并发

• 并行：两个任务同时进行，就是甲任务运行时，乙任务也在运行

• 并发：两个任务都请求运行，处理器只能接受一个任务，就把两个任务安排轮流执行，cpu效率高间隔断，使人感觉不到切换，以为两个任务都在运行。

3、Java运行程序的原理和JVM的启动是多线程吗？

• 原理：Java命令会启动虚拟机，等于说启动了一个应用程序，也就是启动了一个进程，该进程会自动启动一个主线程，然后主线程去调用某个类的main方法。

• jvm启动是的多线程吗：启动至少启动了垃圾回收的一个线程、主线程，所以是多线程。

4、线程应用实现方式

thread类

• 定义类继承Thread

• 重写run方法

• 在里面写要实现的东西

• 创建线程对象

• 开启新线程.start();内部会自动执行run方法

• 好处：可以直接使用里面的方法，代码简单

• 弊端：如果有父类就不能用

//主线程和myTread的线程回会互抢着运行
package Demo_Throw;
public class Demo1 {
    public static void main(String[] args) {
        myTread myTread = new myTread();
        myTread.start();
        for (int i = 0;i<3000;i++){
            System.out.println("bbb");
        }
    }
}
class myTread extends Thread{
    @Override
    public void run() {
        for (int i = 0;i<3000;i++){
            System.out.println("aaa");
        }
    }
}

Runnable接口

• 定义实现类实现接口

• 实现run方法

• 把新线程要做的是写在run方法中

• 创建自定义的runnable的子类对象

• 创建一个Thread对象传入Runnable

• 开启线程.start();会自动执行run方法

• 好处：有父类也能用

• 弊端：不能直接使用Thread类中的方法，比较复杂

package Demo_Throw;
public class MyRunnable implements Runnable{
    public static void main(String[] args) {
        MyRunnable myRunnable  = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        for (int i = 0;i<10000;i++){
            System.out.println("aaaaaaaaa");
        }
    }
    @Override
    public void run() {
        for (int i = 0;i<10000;i++){
            System.out.println("bbbbbbbb");
        }
    }
}

5、匿名内部类实现线程的方式

package Demo_Throw;

public class Demo2 {
    public static void main(String[] args) {
        //1、继承Thread类
        new Thread(){
            @Override
            public void run() {
              for (int i = 0;i<10000;i++){
                  System.out.println("aaaaa");
              }
            }
        }.start();
        //2、实现Runnable接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0;i<10000;i++){
                    System.out.println("bbbbb");
                }
            }
        }).start();
    }
}

6、获取名字和设置名字

获取名字

• 通过getName()方法获取线程的名字，默认从0到1命名

设置名字

• 通过构造函数传入String类型的名字

• 通过setName()方法设置名字

7、获取当前线程的对象

currentThread();//获取当前正在所执行的线程对象的引用

8、休眠线程

Thread.sleep(毫秒);//控制当前线程休眠多少毫秒

 new Thread(){
            @Override
            public void run() {
                this.setName("渣渣辉");
                for (int i = 0;i<10;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                  System.out.println("aaaaa");
              }
            }
        }.start();

9、守护线程

对象.setDaemon(true or false);//设置指定线程方法


package Demo_Throw;

import java.io.IOException;

public class Demo2 {
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                this.setName("渣渣辉");
                for (int i = 0;i<2;i++) {
                    System.out.println("aaaaa");
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                this.setName("张学友");
                for (int i = 0;i<10;i++) {
                    System.out.println("bbbbb");
                }
            }
        };
        t1.setDaemon(true);
        t1.start();
        t2.start();

    }
}

10、加入线程

• join()：当前线程暂停，等待指定线程执行后当前线程再继续

• join(int )：等待指定毫秒后再继续

package Demo_Throw;

public class Demo3 {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0;i<10;i++){
                    System.out.println("aaa");
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0;i<100;i++){
                    try {
                        if(i == 5){
                            t1.join();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("bb");
                }
            }
        };
        t1.start();
        t2.start();
    }
}

11、设置线程的优先级

 对象.setPriority(1);//设置优先级,开发时候不要用这种方法，不好使，用if-else

12、同步代码块

• 关键字：synchronzed加上一个锁对象来定义一段代码，这就叫同步代码块。

• 多个代码块如果使用相同的锁对象，那么他们就是同步的

package Demo_Throw;

public class Demo4 {
    Demo3 dd = new Demo3();
    public void print(){
       synchronized (dd) {//dd为对象锁芯，如果要用当前对象为锁芯的话，dd用this,如果当前有多个对象的话，用当前类.class
            //当前类.class表示加载一次，如果有多个对象用this的话会加载多次
            //而且当方法为静态的，不能用this因为static优先于对象
            //方法为静态时候相当于上锁了	
            System.out.println("你好");
            System.out.println("你好");
            System.out.println("你好");
            System.out.println("你好");
            System.out.println("rn");
        }
    }
    public void print1(){
        synchronized (dd) {
            System.out.println("再见");
            System.out.println("再见");
            System.out.println("再见");
            System.out.println("rn");
        }
    }
    public static void main(String[] args) {
           final Demo4 demo4 = new Demo4();
           new Thread(){
               @Override
               public void run() {
                   while(true){
                       demo4.print();
                   }
               }
           }.start();
           new Thread(){
               @Override
               public void run() {
                   while(true){
                       demo4.print1();
                   }
               }
           }.start();

    }

}
//输出的时候一个锁一个锁的来,没有锁的话会抢着来

//方法同步时
package Demo_Throw;

public class Demo4 {
    Demo3 dd = new Demo3();
    public static void print(){

            System.out.println("你好");
            System.out.println("你好");
            System.out.println("你好");
            System.out.println("你好");
            System.out.println("rn");
    }
    public static void print1(){

            System.out.println("再见");
            System.out.println("再见");
            System.out.println("再见");
            System.out.println("rn");

    }
    public static void main(String[] args) {
           final Demo4 demo4 = new Demo4();
           new Thread(){
               @Override
               public void run() {
                   while(true){
                       demo4.print();
                   }
               }
           }.start();
           new Thread(){
               @Override
               public void run() {
                   while(true){
                       demo4.print1();
                   }
               }
           }.start();

    }

}

13、线程安全问题

举例：卖火车票，4个窗口，100张票

//继承Thread类
package Demo_Throw;
public class Demo5 extends Thread{
    private static int ticket = 100;
    public void run(){
        while(true){
            synchronized (Demo5.class){//
                if(ticket == 0){
                    break;
                }
                System.out.println("这是第"+ticket--+"张票");
            }
        }
    }
    public static void main(String[] args) {
        new Demo5().start();
        new Demo5().start();
        new Demo5().start();
        new Demo5().start();

    }
}

//另一
package Demo_Throw;

public class Demo5 extends Thread{
    private static int ticket = 100;
    public void run(){
        while (true) {
            buy();
            if (ticket <= 0){
                break;
            }
        }
    }

    public static synchronized void buy(){//this-->类.class
            if (ticket >= 0) {
                System.out.println("这是第：" + ticket-- + "张票");
            }
    }
    public static void main(String[] args) {
        new Demo5().start();
        new Demo5().start();
        new Demo5().start();
        new Demo5().start();

    }
}


//实现Runnable接口
package Demo_Throw;

public class Demo5 implements Runnable{
    private static int ticket = 100;
    public void run(){
        while (true) {//while写在锁外面，避免死锁
            buy();
            if (ticket <= 0){
                break;
            }
        }
    }

    public static synchronized void buy(){//this-->类.class
            if (ticket >= 0) {
                System.out.println("这是第：" + ticket-- + "张票");
            }
    }
    public static void main(String[] args) {
        Demo5 demo5 = new Demo5();
        new Thread(demo5).start();
        new Thread(demo5).start();
        new Thread(demo5).start();
        new Thread(demo5).start();

    }
}

14、死锁

• 不能用锁去嵌套锁

反射

• 通过类名获取该类的属性和方法、构造方法等

• 动态地获取类的信息

• 运行的时候，获取类的对象信息并创建对象，调用方法

• class类型：java.lang.Class

• JVM运行的时候，把类加载到内存中，同时会创建这个类的Class类型的对象

• 该类封装了所有类的信息，包括属性方法、构造方法等

• 通过getXxx获取该Class类型对象的封装信息

//Computer类
package Demo_File1;
public class Computer {
    public String name;
    private String logo;
    private String color;
    private double price;

}


//获取Computer类的属性、方法
package Demo_File1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestClass {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取class类型的对象
        //1、类名.class
        Class c1 = Computer.class;
        //Class.forName("类的路径")
        Class c2 = Class.forName("Demo_File1.Computer");
        //3、对象
        Computer computer = new Computer();
        Class c3 = computer.getClass();
        //Filed成员变量
        //获取成员变量
        Field[] arrFs = c1.getFields();//获取公有成员变量
        for(Field f:arrFs){
            System.out.println(f.getName());
        }
        //获取属性
        Field[] arrFD = c2.getDeclaredFields();//获取属性
        for(Field f1:arrFD){
            f1.setAccessible(true);
            System.out.println(f1);
            System.out.println(f1.getName());
        }
        //获取方法
        Method[] arrM = c3.getMethods();
        for (Method m:arrM){
            System.out.println(m.getName());
        }
        //获取构造方法
        Constructor[] arrC = c1.getConstructors();
        for(Constructor c:arrC){
            System.out.println(c.getName());
        }
        //获取内部类
        Class[] arrInnerClass = c2.getDeclaredClasses();
        for(Class c:arrInnerClass){
            System.out.println(c.getName());
        }
        //获取接口
        Class[] arrInnerfaces = c3.getInterfaces();
        for(Class c:arrInnerClass){
            System.out.println(c.getName());
        }
    }
}

创建对象

package Demo_File1;

public class TestNewInstance {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //newInstance 创建对象
        Class c = null;
        c = Class.forName("Demo_File1.Computer");
        Computer computer = (Computer) c.newInstance();//调用无参构造方法，创建之后就可以调用属性和方法了
        
    }
}

javabean

• 类中没有业务逻辑，类处理对象，进行封装

  1. 属性私有

  2. 有无参public修饰的构造方法

  3. 私有属性提供setter、getter方法

• getXxx首字母大写，没有返回值

• vo model pojo entity等

Inspector（内省机制）

• 内省机制就是通过getXxx、setXxx方法来判断Xxx是一个属性，内省机制会把Xxx的首字母变小写xxx

数据库链接步骤

• 1.加载驱动类

Class.forName(类的路径)

导入外部jar包

• 2.获取连接通道

DrvierManager.getConnection

url ip地址 端口号 数据库名字 3306 1521

user 用户名

password

• 3.创建载体

Statement

PreparedStatement extends Statement

预编译 效率高 防止sql注入

setInt(1,empno)

• 4.执行指令

executeUpdate

executeQuery ResultSet rs.next

getString(列名)

• 5.关闭资源

 rs.close

 pst.close

 conn.close

 //获取链接通道
    public static Connection getConnection(){
        Connection conn = null;
        String url = "jdbc:oracle:thin:@localhost:1521:orcl";
//        String url = "jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true";
        String user = "scott";
        String password = "tiger";
//          String user = "root";
//          String password = "123456";
        //1、加载驱动类
        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");
//            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(url,user,password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }catch (SQLException e1){
            e1.printStackTrace();
        }
        return conn;
    }