java知识点

保持对代码的热爱并保持怀疑态度
前几个月略微学习了一下java，以下为知识点，全的不敢说，大部分肯定有了
有一些英文旁边有些奇怪的中文拼接，没错因为记不住，特地中文化了一下。

MVC
模型，视图，控制…
模型：业务逻辑层由JavaBean或EJB构建，数据访问层（数据持久层）应用JDBC或Hibernate聊构建
视图：视图部分一般由JSP和HTML构建。
控制：当用户提交HTML表单时，控制器接收并调用相应的模型组件去处理，之后调用相应的视图来显示模型返回的数据

Shift+Alt+L 补全 Eclipse
String className=“com.microsoft.sqlserver.jdbc.SQLServerDriver”;
String url=“jdbc:sqlserver://localhost:1433;databaseName=“xssfw”;
String user=“撒”;
String password=“123456”;

Class.forName(className);
Connection connection=DriverManager.getConnection(url, user, password);

1.类描述的是公共特征，类必须通过对象使用
2.对象可以通过new进行堆内存的开辟
3.堆内存保存的是对象中所有属性的内容，而栈内存保存的是堆内存的地址数值（对象名称）

类型装换
语法强制转换 例 ： int f =（int）d
int 转char 隐式转换
char 转int 隐式转换
int x=a
char y=char(x)

private（封装）
需要定义相对的setter，getter 方法
set 主要设置内容
get主要取得属性内容

static静态命名
静态只能被静态调用

继承最好不要超过三层

接口：interface
属性全部是final类型
全部是public abstract

抽象方法:相当于一种约定
接口比抽象类 更进一步的“抽象”

继承
接口：代表了一种能力、一种约定

• has a 接口

父类eat（）：->子类
接口eat（）：->实现类
继承；类
实现：接口
A extends b{}
A implements C {}

继承关系 is,
接口关系has,
类：单继承多接口

接口多继承，多态，不存在构造方法

Object类

to string
equals

sys0
System.out.println
main

parseInt() 函数可解析一个字符串，并返回一个整数

equals()和==的区别：

一、对象类型不同

1、equals()：是超类Object中的方法。

2、==：是操作符。

二、比较的对象不同

1、equals()：用来检测两个对象是否相等，即两个对象的内容是否相等。 堆内存

2、==：用于比较引用和比较基本数据类型时具有不同的功能。 栈内存

三、运行速度不同

1、equals()：没有==运行速度快。

2、"== " 运行速度比equals()快，因为==只是比较引用。

单例设计模式、
懒汉式只有调用获取实例的方法时才进行实例化
饿汉式：类加载时才能实例化。

//懒汉式单例类.在第一次调用的时候实例化自己
public class Singleton {
private Singleton() {}
private static Singleton single=null;
//静态工厂方法
public static Singleton getInstance() {
if (single == null) {
single = new Singleton();
}
return single;
}

静态内部类

public class Singleton {
private static class LazyHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return LazyHolder.INSTANCE;
}
}
这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。
————————————————

//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
private Singleton1() {}
private static final Singleton1 single = new Singleton1();
//静态工厂方法
public static Singleton1 getInstance() {
return single;
}

————————————————

处理异常
try,catch ,fianlly

异常输出
printStackTrace

所有的异常类都是throwable 的子类 在throwable 有两个子类（Error ）,(Exception)

Error:指的是JVM的错误，即：此时的程序没有执行，如果没有执行，用户不可以处理。
Exception：指的是程序运行中产生的异常，用 户可以处理
所谓的异常处理指的是所有的Exception以及他的子类异常。
异常 直接catch exception

捕获范围大的要放到前面
要求严格项目里，异常要*******exception分开处理
try{
//有可能出现的异常得到语句
}[catch (异常类型 对象）]{
异常处理
}

异常处理
无try直接默认JVM默认输出错误类型
有try去判断后面每个catch有无匹配 true ，false都向下找finally，无finally直接默认JVM输出异常类型
存在finally判断，true执行finally代码，false交给jvm默认输出

throws关键字主要用于方法声明，表示此方法只能不进行异常的处理，而是交于被调用处处理
方法上如果加thorws，不管出不出异常都需要处理 try，，，catch
主方法不要加throws，如果程序出错，也希望可以正常结束
用了throws

throw
可以在程序中手工抛出一个异常类
必须try —catch

throws 和thorw

throw:在方法中 人为抛出一个异常对象（这个异常对象可能是自己实例化或者是抛出已存在的）
throws：在方法的声明上使用，表示此方法在调用时必须处理异常。

代码模型：异常的使用格式

RuntimeException（运行时异常）
不会强制用户处理，用户可以选择性处理，也可以不处理，如果出现异常交给JVM处理

Exception 和 RuntimeException 的区别。
RuntimeException是Exception的子类，Exception必须处理异常，而RuntimeException定义的异常可以选择性处理。

常见的RuntimeException的子类
p313

assert（关键字）
主要功能是进行断言，指程序执行到某行代码之后，其结果一定是预期结果。

自定义异常
如果要想实现自定义异常，只需要继承Exception或RuntimeException父类即可。

新特征

可变参数
1.在设计一个类的时候可变参数绝对不是优先的选择
2.可变参数属于数组的变形应用。

foreach
循环

静态导入
import static 包.类.*；

泛型
Type（简写标记T）

线程与进程
进程是程序的一次动态执行过程。
所有的线程一定要依附于进程才能存在，进程一旦消失，线程一定消失。

java中实现多线程有两种途径：
继承Thread类；
实现Runnable接口（callable接口）

继承Thread类
Thread类支持多线程的功能类，只要有一个子类就可以实现多线程的支持。

extends Thread
public void run()
线程启动必须调用start（）而不是run

实现Runnable接口
public interface Runnable{
public void run
}
接口所以的方法定义开头为public
implements实现接口
启动多线程一一定要依靠Tread类完成

多线程两种实现的区别
Runnable接口与Thread，最好用Runnable，解决了单继承的局限性；

callable接口
略

线程命名
Runnable接口命名
public voidrun（）
System.out.println(Thread.currentThread().getName());

JVM启动的时候至少启动两个线程，gc线程（垃圾收集），main线程

线程的休眠
指让程序的执行速度变慢一点，在Thread类中线程休眠操作方法是：
public static sleep(long millis) throws InterruptedException

还是利用 异常来调用
try{
Thread.sleep()
}catch(InterruptedException){
e.printStackTrace()
}

线程的优先级
设置优先级
取得优先级
p389

线程的同步
实现线程的同步有两个方式
1.同步代码块；synchronized（圣坤奶死的）（锁定对象）{代码}
2.同步方法 ；public synchronized 返回值（void，无返回值） 方法名称（）{}，for后面跟this。自定方法名；
一个线程必须等另一个线程结束才能进，有一个等待的过程。
Java中交互方式分为同步和异步两种：

同步交互：指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等待过程；
异步交互：指发送一个请求,不需要等待返回,随时可以再发送下一个请求，即不需要等待。
区别：一个需要等待，一个不需要等待，在部分情况下，我们的项目开发中都会优先选择不需要等待的异步交互方式。

死锁
由于某种逻辑上的错误所造成的问题，并且不是简单的就会出现。

数据错位，不再是一个所需要的完整数据；
数据重复取出，数据重复设置

解决数据错乱问题
数据的错位是因为非同步的操作所造成的，所以应该用同步处理。

解决数据重复的问题
加入等待和唤醒机制，obiect类中提供
public fianl void wait() throws InterruptedException 线程的等待
public fianl void notify（no踢翻）() 唤醒第一个等待线程
public fianl void notify All () 唤醒全部等待线程（优先级）
布尔值 true，false

sleep和wait
slepp是Thread类定义的static的方法；表示线程的休眠多久
wait是object类定义的方法，表示线程等待，一直执行到notify或notify All()后才结束

线程的停止
用stop

java Io
javaIo里面有五个核心类，一个核心接口
五个核心类：File，INputStream,OutputStream,Reader,Wirter
一个接口：Serializable
File类施唯一一个与文件本身操作有关的类，但是不涉及到文件的具体内容
FIle的构造方法
public File (String Pathname) 传递完整文件操作路径 （大部分用这个）
public File (File parent,String child 设置父路径与子文件路径（安卓中用的多）

public booleam createNewFile()throws IOException 创建文件
public booleam delete（ ） 删除指定路径文件
public booleam exists（） 判断给定路径是否存在
Windows和Linux的路径符号不一样，用File.separator解决加到创建路径里
//file创造和删除
public class Fliechuangjie {

public static void main(String[] args)  throws  Exception{
File file =new File("e:\\test.doc");
if (file.exists()) {
	file.delete();
}else {
	System.out.println(file.createNewFile());
	 
}
}

}

创建带路径的文件（设置多级目录，目录路径下 例：“主磁盘”+file.separator+“想创建的路径”+file.separator，格式）
前提都是要if来先判断路径是不是存在，最后syo输出想要的东西
getParentFile（）取得当前路径的父路径
mkdirs() 创建多级目录
length（）取得文件大小，以字节为单位返回
isFile（）给定路径是否是文件
isDirectory（）给定路径是否为目录
lastModified() 取得文件的最后一次修改日期时间
list（）列出指定目录中的全部内容
listfiles（）列出所有的路径以file类对象包装

字节流和字符流
第一步：通过File类定义一个要操作文件路径；
第二部：通过字节流或者字符流的子类对象为父类对象实例化；
第三步:进行数据的读（输入），写（输出）操作
第四步：数据流属于资源操作，资源操作必须关闭。必须要关闭连接（几乎每种类都会提供close（）方法）
一共有四个操作流的类
OutputStream.InputStream,Writer,Reader
都是抽象类，一定要通过子类对象的向上转型来进行抽象类对象的实例化操作。

输入往里面写东西，输出 ，输出文件的内容
字节输出流（OutputStream）
close()关闭字节输出流
flush强制刷新
wirte(int b)输出单个字节
write(byte[]b)输出全部字节数组数据
weite(byte[]b,int off)输出部门字节数组数据

FileOutputStream类的常用方法
public FileOutputSteam(File File) throws FileNotFoundException 将内容输出到指定路径。如果文件存在则使用新文件覆盖
Public FileOutputSteam(File File,boolean append) throws FileNotFoundException 如果将布尔值设置为ture，则表示追加内容到文件中

InputStream字节输入流
public void close()throws IOException 关闭字节输入流
public abstact int read()thorws IOException 读取单个字节

字节流与字符流的区别
字节流直接与终端文件进行数据交互，字符流需要将数据经过缓冲区处理才能与终端文件数据交互
在OutputStream输出数据即使没有关闭输出流，内容也可以正常输出，但是反过来如果使用Wirter，如果不关闭输出流，就表示在缓冲区处理的内容不会被强制清空，所以就不会输出数据。
如果有特殊情况不能关闭字符流出流，可以使用frush()方法强制清空缓冲区。

在实际的开发中，对于字节数据的处理是比较多的，例如：图片，音乐，电影，文字。而字符流最大的好处是它可以进行中文的有效处理。
如果有中文选字符流，没有中文选字节流。

乱码
就是指编码与解码字符集不统一造成的

字节入出（读）
FileOutputStream是OutputStream的子类
InputStream如果要进行读取就需要用到FileOutputStream的子类
例：InputStream inp = new FileOutputStream（file）；//实例化
byte date[] =new byte[1024]; //准备一个1024数组；
int len=input.read(date); //进行数据读取，将内容保存到字节数组中
input.close; //关闭输入流
system.out.printIn("["+new String(date,0,len)+"]") //sh

字节输出流（写）
FileOutputStream是OutputStream的子类
outputstream=new fileoutputstream; 实例化
String str=“xxxxxxxxxxxxx”; 输出内容
byte data[] =str.getBytes(); 字节输出流需要使用byte类型，需要将string转为字节数组
out.put.write(date); 输出内容
out.put.close(); 关闭资源操作

字符输出流（写）
filmwriter是writer的子类
要用writer类实现输出
write out =new filmwrite（file）；//实例化
String.str=“xxxxxxx”; //定义输出内容
out.write(str); //输出字符串数据
out.close; //关闭输出流

字符输入流（读）
filmreader是reader的子类
要用reader类实现输出必须利用filmreader
例
Reader in=new FileReader //为reader类实例化；
char date[]=new char[1024]; //开辟字符数组，接收读取数据
int len =in.read(date); //进行数据读取
in.close(); //关闭数据读取
system.out.printIn(new String(date,0,len)); 输出

单对象保存父接口Collection（康奈可训）
Collection和Map区别
Collection接口数据为了输出，Map接口数据为了查询

list子接口
ArrayList是list的子类
List<数据类型>all =new ArrayList<数据类型>() 实例化List集合
用get取得索引

ArrayList和LinkedList区别
ArrayList采用顺序式的结果进行数据保存，并可以自动生成索引信息。
LinkedList保存的 是前后元素
例如
1,2
3,4
输出2,3

set接口
HashSet接口（散列分布式存放数据）
Set<数据类型>all =new HashSet<数据类型>()
TreeSet接口（有序存放数据）
Set<数据类型>all =new TreeSet<数据类型>()

迭代输出Iterator（接口）
List<数据类型>all =new ArratList<数据类型>()
Iterator<数据类型>iter =all.iterator<数据类型>() 实例化iterator接口

双向迭代输出：Listterator

偶对象保存：Map接口
HashMap,Hashtabel两个子类接口（HashMap能保存null，而Hashtable不可以）
Map<数据类型,数据类型>map =new HashMap<数据类型，数据类型>()
Map<数据类型,数据类型>map =new Hashtable<数据类型，数据类型>()

利用Iterator输出Map集合
Map<数据类型,数据类型>map =new HashMap<数据类型，数据类型>() 定义map集合
Set<Map.Entry<数据类型，数据类型>>set =map.entrySet() 将map变为set集合目的使用iterator（）方法
Inteator<Map.Entry<数据类型，数据类型>>inter=set.iterator() ;
while(iter.hasNext()){
Map.Entry<数据类型，数据类型>me=iter.next()
system.out.printin(me.getkey()+me.getValue();
}

Stack
Properties子类
*properties 属性文件

Collections工具类

Collection是集合操作接口
Collections是集合操作的工具类，可以直接利用类中提供的方法，进行List，Map等集合的数据操作。
消费型的函数接口（引用forEach 输出）
首先实例化list接口

使用scanner（斯堪呢）获取用户输入
import java.util.Scanner;;
public class Shi {
public static void main(String[] args) {
//创建一个Scanner的对象，名称为 input

-***********************************************************************************
Scanner input=new Scanner(System.in);
System.out.print(“请输入数据”);//提示
String id=input.next();//使用next（）获取数据，将数据放到变量中
System.out.println(“我的”+id);
}
}

交换2个变量的值
通过第三个变量
或者加减

进制转换
二进制
int a =Ob10
八进制
int b =o10
十六进制
int c =ox 10

十进制转其他进制：除基取余（余数从下往上取），如23——>ob10111
其他进制转十进制：按权相加 （从右往左数，再乘以基数的次方最后相加）ob10111————>23
一个字节8位，int4位
二进制
1、无符号二进制：只能存储正整数
2.有符号二进制：可以存储正数和负数，最高位为符号 位，0表示正数，1表示负数
正数5表示00000000 0000000000000000 00000101
负数5表示10000000 0000000000000000 00000101（即最高位表示正负）

二进制中的源（原）码，补码，反码
源码
原始二进制
反码
正数：反码跟原码相同 正数5表示00000000 0000000000000000 00000101
负数：符号位不变（第一位不变），其余各位取反，如-5的反码负数5表示11111111 1111111111111111 11111010（即其他个位取反0变1,1变0）
补码
正数：跟原码相同 正数5表示00000000 0000000000000000 00000101
负数：反码+1，如-5的反码负数5表示11111111 1111111111111111 11111011（最后一位加1）

计算机内部用补码来存储和表示0

位运算符
针对二进制的位进行运算，需要将值转换为二进制后进行按位运算
运算符 含义
& 按位与（两位都是1，则为1，否则为0）
1(竖线) 按位或（只要有一个1，则为1，否则为0）
~ 按位非（如果为1改0,0改1）
^ 异或（两位相同为0，否则为1 ）
“>> 右移（将二进制的所有位往右移指定位数，末尾补0）
<< 左移（将二进制的所有位往左移指定位数，符号位补0）”

快速复制单行
ctrl alt +下
ctrl +d 删除当前行
ctrl+shirf+f
ctrl加+/
ctrl+shirf+/ 多行

if语句结构
if（）{
}else{
}

switch (key) {
case value:

if和switch 的区别

switch结构
只能进行等值判断，只能为整型，字符型，字符串

if
没有限制，适合某个连续间断的判断

	break;

default:
	break;
}

冒泡排序
N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次

break:跳出整个循坏，执行循坏后的代码
continue：跳出本次循坏，执行下一个循坏，本次循坏未执行的代码不再执行
其中while循环是先判断条件是否满足，后执行循环体，

而do…while是先执行一遍循环体后判断条件，do…while至少执行一遍循环体

不定长参数（…）只能写在最后一个参数，一个方法只能有一个不定长参数，本质就是数组
调用参数个数任意

多态性
将父类的引用指向子类的对象
父类引用子类重写后的方法 叫向上转型（无法访问到子类特有的方法）

将一个指向子类对象的父类方法引用赋给一个子类的引用叫向下转型（访问到子类特有的方法，强制转换）
必须转换为父类指向的真实子类类型
instanceof（判断一个对象是否属于某个类）

List方法
set 根据索引修改
remove 根据元素值删除，返回boole
get 获取根据索引
size 直接输出元素个数
isempty 判断是否为空
toarray()
转数组
Object[] asd = list.toArray();
System.out.println(Arrays.toString(asd));
用toArray方法
输出用tostring

数组转
String[] asdf = {“ssdd”,“sdsd”,“sdhd”};
List asList = Arrays.asList(asdf);
System.out.println(asList);
用aslist；

for循环遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i)+"\t");
迭代器遍历
Iterator（it瑞特） it = list.iterator();
while (it.hasNext()) { //判断是否有下一个元素
Integer num = it.next();//获取下一个元素
System.out.print(num);

vector （瓦科特）
/*
*
* 使用enumeration枚举
*
*/
Enumeration ele = num.elements();
while (ele.hasMoreElements()) {
Integer integer = (Integer) ele.nextElement();
System.out.print(integer);

LinkedList方法
先进先出
独有的加，取 ，删除(都可以加first，last）
list.addFisrt 最前
list.addlast

list.getfirst
list.getlast