1.如何执行Java程序？
javac 文件名.后缀 （编译）
java 编译出来的.class 文件 ，不需要后缀 （运行）
2.java环境
jre 是java的运行环境
jdk 是java的编译工具包(jdk包含jre）
jvm 是java的虚拟机
3.运算符
算术运算符：/ % ++ --
赋值运算符：+= -= *= /= %= =
比较运算符： < > <= >= == !=
逻辑运算符：&& || !
三元运算符：a>b ? 结果1:结果2 (为true执行结果1，为false执行结果2)
注意：
^ 异或，同为false(0)，异为true(1)
&& 短路与，就是遇到一个false就不往下执行了，
& 非短路与, 遇到false还会往下执行。
4.循环结构
for{}普通for循环 ， foreach增强for循环，do...while(){}, while(){}
5.构造方法
分为：有参构造、无参构造
作用：构造方法用于实例化对象，并且为类中的属性初始化赋值
注意：每一个类默认有一个无参构造，并且自动执行，构造方法必须和类名一致，并且不需要static修饰，也不需要返回值。
语法：
public class Gouzao{
private String name;
public GouZao(){
//无参构造
}
public GouZao(String name){
this.name = name ;
}
}6.继承
子类继承父类的公有属性和公有方法，子类可以自己拓展自己的属性和方法
父类叫做原生类，子类叫做派生类。
关键字：extends 、implements
注意：接口可以多继承，类不能多继承，
7.权限修饰符
public 、 protected、 private、 default
public：公有的，他修饰的方法和属性能被外部调用和访问，访问范围是项目内
protected：受保护的，他的修饰范围只限于同一个包的类和其子类可见
private：私有的，该修饰的属性范围只能在本来才能访问，外部访问需要特定的公有方法
default 默认的，同一个包内的类和子类引用和使用
8.方法
方法就是用来描述某一行为的代码块，可重复调用。
声明：
修饰符 返回值类型 方法名(参数列表){
//方法体
}
9.final关键字
final：最终的，该修饰符修饰的属性和方法还有类，不能被重写和继承，修改
finally：是异常处理语句，最终执行的代码，就是一定会执行的代码块，一般会把关闭资源的代码放在那边。
13.List集合
List特点：有序的，元素可是任意元素，并且可重复。
主要分类：ArrayList、LinkedList
分别解释：
ArrayList：
数组集合，底层是数组实现的，可存放任意类型的数据，并且是有序的，
特点是：增删快，查询慢
原因：因为底层是数组，所以增删慢，是因为每次增删都需要要移动其他元素的下标，
查询快因为是直接通过下标索引值。
定义：
List arrlist = new ArratList();
LinkedList:
底层是链表，也是可以存放任意类型，但是是无序的，
特点：增删快，查询慢
原因：因为底层是双向链表，增删只需要该表节点的指针指向就好了；查询慢是因为需要逐个遍历
定义：
List linkedlist = new LinkedList();
List常用方法：
add() 添加 、get() 下标获取值、set(0,"lin") 设置值 、remove() 删除、clear() 清空集合、
subList() 截取集合、toArray() 转换为数组、toString() 字符串类型打印输出、size() 集合大小
遍历List集合：
for (int i= 0；i<arrList.size();i++){
System.out.println(arrList.get[i]);
}
迭代器遍历List集合
Iterator it = arrList.iterator() ;
while(it.hasNext()){
System.out.println(it.next() + " ")
}
10.Set集合
Set特点：无序的，并且元素不重复，
分类：HashSet TreeSet LinkedHashSet
分别解释：
HashSet:
底层是hash表，存储速度快，无序的，元素不可重复，
原因：hashCode 和 equals 方法实现元素的不重复，插入的元素都会有一个hashCode和equals方法
注意：如果插入的元素是一个对象的话，需要重写hashCode和equals方法，不然就会出现两个元素值是一样的情 况。这样就违背了set的特点。
定义：
Set hashset = new HashSet();
TreeSet:
底层是二叉树，可以实现排序，和自定义排序规则，主要分为自然排序(默认)和自定义排序.他自己的默认排序规则 是升序，元素不可重复。
自然排序：
必须实现Comparable接口，然后重写ComparTo() 方法
自定义排序:
必须实现Comparator接口，然后重写Compare() 方法
定义：
Set treeSet = new TreeSet();
Set集合常用方法：
get() 获取、set() 设置、remove() 删除等等。。和List差不多
11.Map集合
Map特点：键值对，键key不可重复，因为底层是一个set集合，值可以是任意
Map分类：HashMap、 TreeMap、LinkedHashMap
分别解释：
HashMap：
无序的，底层是hash表，key的底层是set集合，所以不可重复，如果key要插入一个对象的话，建议重写 hashCode和equals方法。
key实现机制：hashCode比较里面的hashId，然后equals比较元素是否一致
value实现机制：equals比较，返回true不做任何操作，返回false，就覆盖掉原来的值
定义：
HashMap hashMap = new HashMap();
TreeMap :
无序的，可以指定排序，默认是自然排序，可定制排序
LinkedHashMap:
底层是双向链表，插入和遍历的顺序一致。
Map常用方法：
put() 添加、get(key) 通过key获取到值、remove() 删除、replace() 替换、contain() 是否包含、
getEntry() 获取所有的键值对、KeySet() 获取所有的key、 values() 获取所有的value、size() 获取集合的大小。
遍历Map：
//1、先拿到所有的key
Set keySets = hashMap.keySet();
//2、创建迭代器，
Iterator it = keys.iterator();
//3、遍历key，然后通过get(key)获取值
while(it.hasNext()){
String key = iterator.next();
System.out.println(key + ":" + hashMap.get(key));
}
12.抽象
抽象类的方法是没有方法体的，该类的方法由该类的子类根据实际的需求去实现
关键字：abstract
抽象方法必须写在抽象类，子类继承抽象类必须重写抽象类里面的抽象方法。
抽像类不能被实例化，想实现他就用子类继承他，然后实例化子类，从而实现抽象类里面的抽象方法，
抽象类和接口的区别：
当注重事物本身的时候，使用抽象类，
注重事物功能的时候，使用接口
定义方法：
public abstract class Abst01 {
public abstract void eat();//抽象方法
}
14.System类
System系统类：
System.in 输入
System.out 输出
System.gc 手动调用gc垃圾回收机制
System.exit(0) 终止当前java虚拟机运行，（0代表正常退出，非0代表异常退出）
System.currentTimeMillis() 获取1970年到当前系统时间毫秒值
15.String类
string类是对字符串处理的类，
string类的主要方法有：
charAt() 返回指定的下标字符串
contains() 是否包含
equalsIgnoreCase() 不区分大小写比较值
format() 格式化成字符串输出
concat() 字符串拼合
indexOf() 返回指定字符串第一次出现的下标
lastindexOf() 最后一次出现的下标
isEmpty() 返回字符串是否为空（严格）
isBlank() 是否为空，（非严格，空格和空值也算是空）
length() 字符串长度
replace() 替换字符串
split() 分割字符串
subString() 截取字符串
endWith() 是否以什么结尾
startWith()是否以什么开始
toCharArray() 字符串转换为字符数组
toLowerCase() 大写转小写
toUpperCase() 小写转大写
trim() 去首尾空格
valueOf() 将int类型转换为string类型
拓展1：
先把字符串 str.toCharArray() 转为字符数组
然后foreach() 迭代字符数组，从而达到迭代字符串。
拓展2：
使用endWith() 通过后缀判断文件的类型，
拓展3：
去掉字符串中间空格：
1.str.trim()
2.str.replace(" ","")
16.字节流
字节流：可以用来操作图片文件或者媒体数据
InputStream：FileInputStream、BufferInputStream
OutPutStream：FileOutputStream、BufferOutputStream、
常用方法：read() 读取、write() 写入
常用方法实现文本复制：
String path = "D://abc.txt";
String path1 = "D://def.txt";
//文件输入流、输出流
FileInputStream file1 = null;
FileOutputStream file2 =null;
//文件缓冲输入输出流
BufferedInputStream buf1 = null;
BufferedOutputStreaam buf2 = null;
try{
file1 = new FileInputStream(path);
file2 = new FileOutputStream(path1);
buf1 = new BufferedInputStream(file1);
buf2 = new BufferedOutputStream(file2);
int content = -1;
while((content = buf1.read()) != -1){ //读取
buf2.write(content);//写入
}
}catch(FileNnotFoundException e){
e.printStackTrace()
}catch(IoException e){
e.printStackTrace()
}finally{
try{
buf1.close()
buf2.close()
file1.close();
file2.close();
}catch(IoException e){
e.printStackTrace();
}
}
17.异常类
Exception
try{
//可能出现的异常
}catch(){
//处理异常，
}finally{
//最终执行的代码
}
throw 和 throws的区别：
Throw：
throw在方法体中抛出，只能抛出一个异常
抛出的异常必须是异常实例，
执行throw必须是抛出了某种异常
抛出的是创建了一个异常对象。
throws：
throws跟在方法的声明后面，
可抛出多个异常，逗号分割抛出的异常
声明得的只是可能会出现的异常，并不一定会发生
异常的处理由方法的调用者处理，该类并不处理
18.线程
线程：
线程是进程的操作单元，一个进程里面可以有多个线程，至少有一个主线程
创建线程：
线程创建方式1：extends Thread ---> 重写run方法 --> start启动线程
实现：
public class DemoThread01 {
public static void main(String[] args){
TestSub1 testSub1 = new TestSub1();
Thread th1 = new Thread(testSub1);
th1.start();
}
}
class TestSub1 extends Thread{
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+"执行了")
}
}
线程创建方式2：implement Runnable --> 重写run()方法 --> start启动线程
实现：
public class DemoThread02 {
public static void main(String[] args){
TestSub2 testSub2 = new TestSub2();
new Thread(testSub2,"窗口1").start();
new Thread(testSub2,"窗口2").start();
}
}
class TestSub2 implements Runnable{
@Override
public void run(){//重写run方法，里面写执行体
System.out.println(Thread.currentThread().getName()+"执行了");
}
}
线程创建方式3：implement Callable --> 重写call方法 ---> 实例化类 --> 使用FutureTask类包装 callable对象，封装callable的返回值 ---> 使用这个对象作为Thread的采纳数，创建线程 --> start启动线程
实现：
public class DemoThread3{
public static void main(String[] args){
Callable testSub2 = new TestSub3();
FutureTask futrueTask = new FutrueTask(testSub3);
new Thread(futrueTask,"窗口1").start();
FutrueTask testSub3 = new TestSub3();
new Thread(testSub3,"窗口2").start();
}
}
calss TestSub3 implements Callable{
@Override
public Object call(){
System.out.println(Thread.currentThread().getName()+"启动了");
}
}
19.*****线程安全***** ！！！！！！
1、加锁 Lock，也就是需要我们自己去获取锁，释放锁，操作锁 lock.Lock 加锁；lock.Unlock
2、同步 synchronized
3、把线程当作参数传递给thread，创建新的线程
3实现：
//同步代码块：解决线程安全问题
public class ThreadSafe{
public static void main (String[] args){
TestSub testSub = new TestSub();
new Thread(testSub,"美团").start();
new Thread(testSub,"猫眼").start();
}
}
class TestSub implements Runnable{
private int ticket = 10;
@Override
public void run(){
while(true){
synchronized(this){
if(ticket > 0 ){
System.out.println(Thread.currentThread().getName()+"售出第" + ticket +"张票" + "还剩" + --ticket + "张票");
try{
Thread.sleep(300);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
}
}
20.JDBC使用步骤
1、导入connector 的jar包
importr "java.sql.connection.jar"
2、加载驱动
Class.forName("com.mysql.jdbc.drivce")
3、准备连接参数，获取数据库连接
String url = "jdbc:mysql://localhost:3306/user?characterEncoding=utf8&userUnicode=true";
Connection conn = DriverManager.getConnection(url,"root","ROOT");
4、获取发送sql语句的操作对象statement
//普通流
String sql = "select * form user";
Statement stm = conn.createStatement();
5、写sql语句，填充参数
//预处理对象填充
String sql = "select * form user where name = ?";
PreparedStatement pstm = conn.preparedStatement(sql);
pstm.setString = (1,"feifei");
6、操作对象发送sql语句，接收结果集
ResultSet resultSet = stm.execteQuery(sql);
//预处理对象发送
ResultSet resultSet = pstm.executeQuery();
7、处理结果集，
while(resultSet.next()){
String name = resultSet.getString("username");
}
8、关闭资源
resultSet.close()
stm.close()
pstm.close()
conn.close()
21.转发和重定向
请求转发：
req.setAttribute("feifei","12345"); //设置域数据
req.getRequestDispatcher("/demo1").forward();
请求重定向：
resp.sendRerirect("demo01?username=feifei"); //可以接参数，但是不安全，因为会显示在 url上面
转发和重定向区别：
转发：是服务器行为，转发是同一个服务器当前域，只有一次请求，转发服务器地址不会变，域数据不会丢失。
重定向：是客户端行为，是不同的服务器跨域，做了至少两次请求，地址会改变，域数据会丢失。
22.servlet生命周期
constructor构造方法 ---> init初始化 ---> service()服务 ---> destroy()销毁
Servlet分类：
HtppServlet、
Servlet
GenericServlet
23.面向对象的特征
* 面向对象主要有四大特征
1、抽象
忽略一个主题中与当前目标无关的东西，专注的注意与当前目标有关的方面。(就是把现实世界中的某一类东西，提取出来，用程序代码表示，抽象出来的一般叫做类或者接口)。抽象并不打算了解全部问题，而是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一个数据抽象，而是过程抽象。
数据抽象 -->表示世界中一类事物的特征，就是对象的属性。比如鸟有翅膀，羽毛等(类的属性)
过程抽象 -->表示世界中一类事物的行为，就是对象的行为。比如鸟会飞，会叫(类的方法)
2、封装
封装是面向对象的特征之一，是对象和类概念的主要特性。封装就是把过程和数据包围起来，对数据的访问只能通过已定义的界面。如私有变量，用set，get方法获取。
封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。
3、继承
一种联结类的层次模型，并且允许和鼓励类的重用，提供一种明确表达共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类(子类)，原始类称为新类的基类(父类)。派生类可以从它的父类哪里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。因此可以说，继承为了重用父类代码，同时为实现多态性作准备。
4、多态
多态是指允许不同类的对象对同一消息做出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活/抽象/行为共享/代码共享的优势，很好的解决了应用程序函数同名问题。总的来说，方法的重写，重载与动态链接构成多态性。java引入多态的概念原因之一就是弥补类的单继承带来的功能不足。
动态链接 -->对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将调用子类中的这个方法，这就是动态链接。
24.接口
关键字：interface
接口定义：
public interface TestInterface(){
//接口里面定义的是抽象方法，实现接口的类必须重写那些抽象方法，
}
接口理解：
接口可以理解为一种行为规范，准则，接口里面定义具体的功能列表，然后实际开发中就根据不同的需求，重写里面 的功能，处理不同的逻辑。
接口拓展：
可以通过接口实现多态，同一种方式，展现不同的形态
继承了接口，必须实现里面的抽象方法，或者该类是个抽象类。
接口和抽像类的区别：
类只能单继承，接口能够实现多继承。
接口是用extends继承，接口是用implements继承
接口注重的是事务的功能，抽象类注重事物的本身
25.分别按顺序打印线程
//直接使用线程插队join的方法实现顺序打印线程
public class Demo_orderPrint1 {
public static void main(String[] args) {
Order3 order3 = new Order3();
Order4 order4 = new Order4();
Thread th3 = new Thread(order3, "数字选手：");
Thread th4 = new Thread(order4, "字母选手：");
try {
th3.start();
//直接使用线程插队，让th3执行完了，再执行th4
th3.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
th4.start();
}
}
class Order3 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 6; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
class Order4 implements Runnable {
@Override
public void run() {
for (char a = 'a'; a < 'f'; a++) {
System.out.println(Thread.currentThread().getName() + ": " + a);
}
}
}
26.数组
int[] arr = new int[5];
注意：数组的存取都是按照下标进行的，
复制数组：
System.Arraycopy(srcArr,0,newArr,0,src.length());
//要复制的数组，从哪里开始复制，复制到哪里去，复制成功放的开始下标，复制多长，
数组长度：arr.Length();
27.this和super
this指代当前类，super指代父类
5785
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
