java传递参数
Java进行复制操作或方法调用中传递参数时，遵循值传递的原则。
1.基本类型数据传递的是该类型数据的值本身，当一个基本类型的变量传递给一个方法时，在方法内部可以改变变量的值，但是方法调用结束后，该变量会恢复原来的值。
2.引用类型数据传递的对象的引用，当一个引用变量作为参数传递给一个方法时，在方法内改变了引用指向对象的属性。
响应状态码
-1xx：信息，表示请求收到，继续处理
-2xx：成功，表示请求成功
-3xx：重定向，为完成请求客户需进一步细化请求
-4xx：由客户端引发的错误
-5xx：由服务器发的错误
异常
Runtime Exception 不用逐级抛，直接到顶层
{
错误的类型转换
数组越界异常
空指针访问
}
IOException 逐级上抛
｛
从一个不存在的文件中读取数据
越过文件结尾继续读取
链接一个不存在的URL
｝
JDBC：Java数据库链接
环境搭建
1.把Oracle数据库驱动文件放在工程里
2.把ojdbc14.jar加入到工程的build path里
开发步骤
1.获取数据库连接（找到数据库，输入用户名，密码）
2.创建一个stataement对象，用来写SQL语句
3.运行SQL语句
4.增删改，提交回滚（JDBC默认提交）
5.关闭
步骤
1.导入JDBC类或包括JDBC类的包
2.加载JDBC驱动程序
3.建立与数据库的连接
4.执行SQL语句，与数据库交互
5.关闭连接
prepared statement 防止SQL注入
public static void main(string[] args){
Scanner scanner = new Scanner(System.in);
String eanme = Scanner.nextLine();
getEmpBynamenew(ename);
}
public static void getEmpBynamenew(String ename){
try{
Class.forName("oracle.jdbc.driver.OracleDriver");
}
catch(ClassNotFoundException e){
e.printStackTrace();
}
Connection conn = null;
PreparedStatement statement =null;
ResultSet rs = null;
try{
conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:neuedu","scott","tiger");
statement = conn.preparestatement("select*from emp where ename =? ");
statement.setString(1.ename);
rs = statement.executeQuery();
if(rs.next()){
int empno = rs.getInt("empno");
String uname = rs.GetString("ename");
Date hiredate = rs.getDate("hiredate");
System.out.println(empno+"\t"+uanme+"\t"+hiredate);
}
else
{
System.out.println("Not find");
}
}
catch(SQLException e){
e.printStackTrace();
}
finally{
try{
rs.close();
statement.conn();
conn.close();
}catch(SQLException e)
{
e.printStackTrace();
}
}
}
多线程
进程：就是操作系统中并发执行的任务
一个电脑只有一个CPU，那么它是如何实现并发的呢？
其实计算机内部所谓的“并发”不是真正意义上的并发，它给每一个运行的程序分配时间片，每个程序都在自己的时间片上争夺CPU资源，这个时间片用完切换成下一个时间片，由于切换的频率比较频繁，速度又非常的快，所以，感觉上是在并发执行
进程有些缺点，就是切换的效率比较低。
线程：进程中的小进程
假如我们运行JVM程序，它就是一个进程，那在JVM中用JAVA程序实现的并发操作，就是JVM这个进程中的小进程，这就是线程
那么堆和方法区中的数据，是多线程共享的。栈不是，每一个线程都有一个自己的栈。
线程也是JAVA执行程序的最小单位，main方法本身就是一个线程，其他线程都是直接或间接从main方法线程中生成出来的。
在Java中，线程就是一个普通的类，如果这个类想成为一个线程，就必须：
1.继承java.lang.Thead类,并重写其中的run()方法；
如何启动一个线程—>再写一个Test类
启动线程一定调用的是start()方法，如果直接调用run()方法，就不是以线程的方式启动了
按正常逻辑，应该先输出1—10，然后再显示“main方法结束”，出现这种现象的原因是什么？
线程之间相互平等，线程一旦启动，那么它和启动它的线程就是两个完全独立的运行单元，它们之间开始竞争CPU资源，谁先运行完全取决于谁先竞争到CPU资源
2.实现Runnable接口（实现所有抽象方法，其实就是run()）
如何启动一个线程
注意：Runnable接口没有start()方法
ThreadDemo2 td2 = new ThreadDemo2();
Thread t = new Thread(td2);
t.start();
【同步问题】
多个线程同时操作一个共享资源时，若不加以控制，就会出现同步问题
例子：火车站代售点卖票（同步问题）
先分析这个场景需要哪些类？
1.代售点负责卖票
2.火车站负责出票
那我们假设这个火车站就一趟火车，10个座，所有代售点都去卖这10个座。有浑南代售点、沈河代售点、和平代售点并发卖票，座位号用票号来代替。
线程我们也需要用锁机制来解决同步问题—-锁什么？
卖票这个场景给什么加锁才能保证隔离性？
我们可以在saleTicket这个方法前加关键字synchronized,加在需要同步的方法前
1>互斥 使用锁机制，锁一定是加在共享资源对象上的，synchronized
a)加在需要同步的方法前（并非是在方法上加锁，而是加在方法所在的对象上）
public synchronized void f() {加锁
同步执行，互斥
}解锁（方法执行完毕）
优点:简单
缺点：不管是否需要，同步方法中的代码都是互斥，效率低
b)同步块
在你需要同步的代码上加一个
Synchronized(对象){加锁
同步的代码
}解锁
优点：可以选择需要同步的代码进行同步，效率有所提升
缺点：需要确定加锁的对象，需要找到同步执行的代码，对初学者较难
2>协作（免费赠送）
线程不一定都是互斥的，有些情况下，需要多个线程共同协作
========================================================
生产者–消费者模型
生产者—-生产产品
消费者—-消费产品
两者的共享资源—-产品
规则：消费者在产品生产之前，不能消费产品
生产者在产品被消费之前也不能再生产产品
所以需要两个线程协作，就不能是单纯的互斥了
=======================================================
例子：张萌、李英伟、吕洪研去麦当劳喝咖啡，三人买一杯，谁抢到谁喝，孙铭序是麦当劳服务员，负责续杯
服务员—生产者
三位顾客—消费者
共享资源（产品）— 咖啡杯
根据咖啡杯的状态来判断到低是续杯还是喝咖啡
1.咖啡杯 2.消费者 3.生产
问题:wait()与sleep()有什么区别?
1>wait()是Object类提供的，而sleep()是Thread类提供的静态方法
2>它们都能让线程进入阻塞状态，wait()线程只有被notify才能被唤醒，sleep()的线程到时间自动被唤醒
3>wait()方法的调用需要锁的支撑，调用完会解锁
sleep()的调用不需要锁
网络编程
java.net.Socket
java.net.ServerSocket
服务器、客户端
服务器：被动的接受连接的一方是服务器
客户端：主动的发送连接请求的是客户端
一旦连接建立，双方完全平等。
例子：服务器回显的例子
作业:网络之间二进制文件的传输（把服务器D盘根目录下的exe文件拷贝到客户端E盘根目录下）
文件与流
流
方向：输入流、输出流
字节流：以字节为单位读写数据，用以二进制信息的传输
字符流：以字符为单位读写数据，用以纯文本信息的传输，不能用以二进制信息的传输
节点流（基础流、低级流）
处理流（缓冲流、高级流）
java.util.Scanner 也是个输入流
作用：从控制台接收用户输入的信息
对象序列化
将对象转成字节序列—-对象序列化
将字节序列恢复成对象—-反序列化
对象是纯文本的么？不是纯文本，所以使用字节流
ObjectInputStream 输入流
ObjectOutputStream 输出流
一个类若想序列化，必须得实现2个接口之一
Serializable 或者 Externalizable
Serializable这个接口没有定义任何方法和属性，我们把这种接口称之为标识接口。
标识接口的作用：标识一个类是否具有某种能力