面向对象

java的编程思想：

​ 面向对象编程。

java面向对象的特点

​ 封装、继承、多态

class

类：定义一个java源文件，就是定义一个类，类：模拟现实生活中的一个类，类名通常首字母大写。

类：拥有相同属性和行为(方法)的泛指(不是具体的一个)。
对象：一定是从某一个类实例化出来(创建)，拥有该类的属性和行为，具体的一个指向


注意：今后将main函数单独写在一个测试类中，只负责调用。

类属性：

类属性：在类中定义的变量，也称之为全局变量，也称之为类属性
	注意：
		1：类属性可以通过  对象.属性   的语法使用。
		2：有默认值：0或者null

方法

方法：将一部分代码块定义在一个大括号里

定义方法：public  返回值类型  方法名(参数){}
	返回值类型:可以写void关键字，也可以写任何数据类型：作用：将方法中的局部变量返回出去，给调用者使用
        void：无返回值
            public void a1(){方法代码块}   //该方法称之为无返回值的方法
        任意数据类型：要求该方法必须有一个具体该类型的返回值，在调用该方法的时候，可以接收到该返回值
        return：结束方法
        
        
	参数：	会让方法更加灵活
		形参：在定义方法时小括号里定义变量，不能给值
		实参：在调用方法时小括号里的实际数值，实参会自动给形参赋值
			注意：实参与形参必须个数、顺序、数据类型一一对应
			
	注意：方法体中使用变量：就近原则	

对象：

创建对象：
	类名　　对象名　＝　new  类名();
	注意：
		1：必须理解熟记内存配分，见图解
    	2：可以通过	对象.属性 和  对象.方法()	的语法调用类属性和方法。
		3：需要导包，使用其他包中的类就需要导包，eclipse默认导入Java.lang.*
	

Java内存分配图：

内存分配

访问权限修饰符

可以修饰类、属性、方法
	类只能使用public或者默认权限来修饰，属性和方法4个修饰符都可以修饰

			public(公共的) 	protected(受保护的)	 默认的(什么都不写)		private(私有的)  
当前类中			√				√				√						√
同包不同类			√				√				√						×
不同包子类			√				√				×						×
不同包非子类			√				×				×						×

习惯性：
	所有的类属性：全是私有的
	所有的方法：全是公共的

实体类

​ 以固定的方式来定义一个类，代表项目中要操作的数据类。

周末作业操作：一个员工信息：是一个字符串，在代码中操作时比较麻烦：要数组拆开
定义一个员工类：

//员工类：以固定的形式来定义一个项目要操作的数据类：员工类,
//通过公共的方法来给属性赋值和获取属性值，这样的类称之为实体类
public class Emp {
	
	private  int eid;
	private String ename;
	private String esex;
	private int eage;
	private String eadd;
	
	//给eid赋值
	public void a1(int eid1) {
		eid = eid1;
	}
	//获取eid的属性值
	public int a2() {
		return eid;
	}
	
	//给ename赋值
	public void b1(String ename1) {
		ename = ename1;
	}
	//获取ename的属性值
	public String b2() {
		return ename;
	}
}

注意：
	Emp emp = new Emp();//相当于新创建一个员工，属性值全是默认是，通过调用方法来设置获取属性通知

作业：
	1：完成word文档练习；
	2：完成员工实体类定义，创建2个对象，分别给两个对象的属性赋值和取值
	3：思维导图软件或者手抄笔记：截图贴到项目中，附件上交官网作业。

this:

this只能出现在自定义方法中：
	代表当前对象：哪个对象调用当前方法，this就代表哪个对象
	
	实例见实体类
this.属性
this.方法名()

构造器

是一个特殊的方法

声明：public   不能写返回类型    类名(){方法体}

注意：
	1：创建对象时自动调用构造器
	2：每个类都默认有一个无参构造器：给普通类属性赋初值:	0,null
	3：可以自定义一个有参的构造器，无参构造器会被覆盖。
	4：自定义构造器后，创建对象时，注意形参实参匹配。

方法重载(Overload)

一个类中，可以有多个方法同名，但是方法的参数列表不同：参数的个数、顺序、类型
目的：让方法更加灵活，传入多种类型的参数都可以执行，调用方法时依然形参实参一一匹配。
	public Emp() {}
	//自定义一个有参构造器
	public Emp(int eid,String ename,int eage,String esex,String eadd) {
		this.eid = eid;
		this.ename = ename;
		this.eadd = eadd;
		this.eage = eage;
		this.esex = esex;
	}
	
	//将b添加到数组a中，返回出去
	public int[] x1(int[] a,int b) {
		a = Arrays.copyOf(a,a.length+1);
		a[a.length - 1] =b;
		return a;
	}
	public String[] x1(String[] a,String b) {
		a = Arrays.copyOf(a,a.length+1);
		a[a.length - 1] =b;
		return a;
	}

toString

默认输出一个对象时，默认就是输出内存地址，
在实体类中定义一个toString方法，可以不输出对象的内存地址，返回什么就输出什么

public String toString() {
//return "呵呵";
return this.eid + "-" + this.ename + "-" + this.eage + "-" + this.esex + "-" + this.eadd;
}

static

静态的：通常静态属性和静态方法都使用类名调用

可以修饰属性：静态属性：
	特点：
		1：所有对象共享该属性，一个对象改值，所有对象的该属性都被修改了。
		2：可以使用对象调用该属性，也可以使用类名调用该属性；
可以修饰方法：静态犯法
		1：静态方法只能使用静态类属性；
		2：静态可以使用对象调用，也可以使用类名调用。
		3：不能使用this关键字
		
可以修饰代码块：给静态属性赋初值
		特殊的一个代码块，
			1：在加载该类的时候，执行静态代码块,在创建对象之前执行静态代码块
			2：静态代码块永远只执行一次。
		内存加载一个类：
				情况1：创建对象之前，先将该类的静态、属性方法都加载到静态内存块中
				情况2：通过类加载器对象加载一个类时，
				........

继承(extends)

​ 子承父业，子类拥有父类的属性和方法(注意访问权限)

public class A {
	public int a;
	private String b;
	public void a1() {
		System.out.println("a111111");
	}
}

public class  B  extends A{			B类继承A类

}		
		B b = new B();
		b.a = 1;
		//b.b = "abc";   注意访问权限
		b.a1();

方法重写(覆盖,Override)

一定是在子类中，子类拥有与父类相同的方法头，叫做方法重写，注意重写的方法的访问权限只要大于等于父类方法即可。目的：子类拥有对父类功能方法发扬光大的责任。
	注意方法重写与方法重载的区别

特点

1：类之间有is-a的关系才能继承，不能随便继承，有is-a的关系时可以继承，目的：代码复用
2：java是单一继承，一个子类只能继承一个父类，一个父类可以有多个子类。但是接口可以多继承。
3：创建子类对象时，注意执行过程：先执行父类静态代码块，再执行子类静态代码块，再执行父类构造器，最后执行子类构造器
		B b = new B();//创建子类对象
		理应先执行B的构造器，在子类构造器中第一句话默认有super()这条命令，可以通过super(实参)的			语法调用父类有参构造器
4：可以使用向上转型的语法：创建子类对象赋值给父类对象，该对象称之为向上转型的对象，可以调用父类的属性和方法，也能调用子类重写后的方法，目的：多态，根据不同的语法，可是实现调用不同的方法。
		

super

代表父类对象：只能出现在自定义方法中：
super():	调用父类的构造器，只能写在子类构造器第一句。
super.属性:
super.方法名():
	注意this和super的区别

多态

方法重写、方法重载、向上转型称之为多态的体现。

抽象类

用abstract关键字修饰的方法称之为抽象方法，抽象方法不能有方法体{}。

用abstract关键字修饰的类称之为抽象类。
	特点：
		1:可以有普通方法，也可以有抽象方法
		2：抽象类不能创建对象，必须被子类继承，子类必须重写父类所有的抽象方法，如果没有重写所有的抽象方法，那么子类也必须定义为抽象类。
		3：抽象类不能创建对象，可以创建子类对象或者向上转型的对象，调用子父类的属性或者方法。
		4：抽象类可以有构造器，可以给类属性赋值；

接口

​ 理解为特殊的类，与继承的理解也一样，只不过要求使用专业属于实现

目的：来定义项目的功能规范：定义统一的方法名、参数、返回值。

接口的定义：
	public interface A {}
	特点：
		1：接口中全是抽象方法，默认都是用public abstract修饰
		2：接口不能创建对象，必须由子类来实现(implements,与继承的理解完全一样)该接口，实现类必须重写父接口的所有抽象方法，如果没有重写所有的抽象方法，那么实现类也必须定义为抽象类。
		3：接口不能创建对象，可以创建实现类的对象或者向上转型的对象，调用子父类的属性或者方法。
		4：接口不能有构造器，所有的属性默认全是用public static final修饰

final

可以修饰类、属性、方法

	修饰类：最终类：不能被继承		public final class A{}
	修饰属性：最终属性、常量：必须有初值，还不能被改值，通常变量名全大写。  public final int a = 1;
	修饰方法：最终方法，不能被方法重写。	public final int a1(){}

类之间的关系

子类					父类
普通类		extends		普通类
普通类		extends		抽象类
普通类		implements	接口

抽象类		extends		普通类
抽象类		extends		抽象类
抽象类		implements	接口

接口		extends		普通类
接口		extends		抽象类
接口		extends		接口

面向对象总结

面向对象编程：学习的编码的语法与思想
	想要实现功能:
	语法：
		1：先定义类，定义方法，该方法实现一个具体功能，咋实现：用到了jre(核心类库)当中的方法，实现自			己的功能
		2：需要调用自己的方法。
		3：以上定义与调用都需要用到面向对象的语法。
	后面学习jre中提供了哪些类，哪些方法？知道的越多，代码越方便。

异常处理

异常：java把咱们口头上说的错误归类：
Throwable
	Exception
		运行时异常
			java.lang.ArithmeticException：								数学异常
			java.lang.ArrayIndexOutOfBoundsException					 数组下标越界
			java.lang.StringIndexOutOfBoundsException					 字符串下标越界
			java.lang.NullPointerException								 空指针异常
		非运行时异常
	Error：
			java.lang.StackOverflowError								 内存溢出错误
	
目的：程序发生异常后，如果不处理，则立刻终止。程序添加异常处理后，发生异常，可以正常运行。

异常处理代码块

try  catch  finally		throw  	throws  

try{
	你觉得可能发生异常的代码
}catch(异常类  参数名){		捕获该异常类
	代码块
}finally{
	始终执行的代码块
}
当try中的代码发生异常，且发生的是catch中的异常时，执行catch代码块。如果try中没有发生catch捕获的异常，则不执行catch代码块。try中不管发生不发生异常，finally始终执行。该代码块可以只有try、finally或者try、catch代码开快

		try {
			System.out.println(111);
			System.out.println(4 / 0);
			System.out.println(222);
		} catch (Exception e) {  //当try中发生了NullPointerException时执行catch代码块，try中发生异常的种类很多，所以我们catch中可以捕获Exception
			System.out.println(3333);
			//通常先打印异常信息，再进行补救措施
			e.printStackTrace();  //打印发生的异常信息
			//补救措施：根据具体的需求来补救，暂时先不补救
		}finally {
			System.out.println(44444);
		}
		System.out.println(5555);

throw：为了代码的健壮性，需要自己判断什么情况会发生异常，并抛出异常对象：那么要么自己通过trycatch代码块处理异常，要么通过throws关键字向上代码抛出异常信息：那么上层代码必须处理异常或者继续向上抛出

throws:向上层抛出异常信息

jre

jre：核心类库，定义了java中源码，语法：面向对象对象语法规则，咱们按照语法规则去调用jre中方法。

Object

所有类的直接或者间接父类Object，Object类提供的方法，大概率不会直接只用，他提供的方法是给后面子类提供基础帮助的方法。

	public boolean equals(Object obj){}
		注意：
			1:源码就是调用了==判断两个对象是否是同一个对象，==：判断的是内存地址
			2；String类重写了equals方法，先比较两个对象的内存地址，相同返回真，否则判断内容是否相等
	public int hashCode(){}
			根据当前对象的内存地址编号，将对象转换成int类型。给jre中集合类中判断两个对象是否为同一个
			对象。通常用来比较两个对象是否是同一个对象。
			使用了native关键字修饰该方法：当前方法调用了java虚拟机底层中C++的源码：虚拟机底层C++的该方法不是一个稳定的方法：
				两个对象的哈希码不同，则说明这两个对象为不同的对象；
				但是两个对象的哈希码相同，不能说明这两个对象是相同的内存地址，有可能是两个不同的对象
				String a1 = "Ea";
                String a2 = "FB";
                int x1 = a1.hashCode();
                int x2 = a2.hashCode();
                System.out.println(x1);
                System.out.println(x2);
              后面jre类中的其他对象，会默认先调用对象的hashCode方法来判断两个对象的哈希码是否相同，如果不同，则说明这两个对象为不同的对象，如果哈希码相同，则再调用equals方法来判断，这两个对象是否为同一个对象。
     public String toString(){}      
     	1：将对象转成字符串：类名拼接哈希码，
     	2：System.out.println()控制台打印对象时，默认会调用参数的toSring方法

Math

数学类：所有的方法都用static修饰
	double a1 = Math.pow(2,4);
	int a = Math.abs(-4);  //取绝对值
	double b1 = Math.random();  //获得随机小数[0,1)
	double b2 = Math.ceil(-2.9);  //向上取整
	double b3 = Math.floor(-2.9); //向下取整

字符串

String：最终字符串：String在操作字符串时，每次操作都会产生一个新的内存空间，比较吃内存
String s1 = "abc"
String s2 = new String("abc");
String s3 = "";    //空字符串
String s4 = null;	关键字null

//		String s1 = "张三";
//		int x = s1.length();  //获取字符串的长度

//		String s1 = "abcdadfsa";
		//int x = s1.indexOf(65);  //在字符串s1中找括号里的字符对应的下标，找不到返回-1
		//int x1 = s1.indexOf('x');	//在字符串s1中找括号里的字符对应的下标，找不到返回-1
		//int x1 = s1.indexOf("bd");	//在字符串s1中找括号里的字符串对应的下标，把字符串当成一个整体，找不到返回-1
		//int x1 = s1.indexOf(97,6);  //在字符串s1中从下标6开始往后找a的下标，找不到返回-1
		//int x1 = s1.indexOf('a',6);  //在字符串s1中从下标6开始往后找a的下标，找不到返回-1
		//int x1 = s1.indexOf("fs",6);  //在字符串s1中从下标6开始往后找fs的下标，找不到返回-1
		//System.out.println(x1);
		
		
		String s1 = "13576";
		char c1 = s1.charAt(100);  //根据下标找字符，下标不能越界   
		System.out.println(c1);
		
		String s1 = "abcdeab12";
		boolean b = s1.startsWith("ab");  //判断s1是否以ab开头
		boolean b1 = s1.endsWith("ba");	//判断s1是否以ba结束
		System.out.println(b);
		System.out.println(b1);
		
		String s1 = "abcdea";
		String s2 = s1.substring(3);  //将字符串s1从下标3开始截取到最后
		String s2 = s1.substring(2, 4);  //将字符串s1从下标2截取到下标4之前
		System.out.println(s2);
		
		String s1 = "abcdeabc";
		//String s2 = s1.replace('a', 'x'); //将字符窜s1中的字符a替换成字符x
		//String s2 = s1.replace("ab", "xxx");//将字符窜s1中的字符ab替换成字符xxx
		System.out.println(s2);
		
		
		String s1 = "abc";
		String s2 = "abc";
		String s3 = new String("abc");
		String s4 = new String("abc");
		
//		boolean b1 = s1 == s2;
//		boolean b2 = s3 == s4;
//		boolean b3 = s1 == s4;   //字符串使用==比较时，牵涉内存的比较，暂时不要使用
//		System.out.println(b1);
//		System.out.println(b2);
//		System.out.println(b3);
		
		boolean b1 = s1.equals(s2);  //比较两个字符串的内容是否一致
		boolean b2 = s3.equals(s4);
		boolean b3 = s1.equals(s4);
		boolean b4 = s1.equals("abc");
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b3);
		System.out.println(b4);
		
		String s1 = "abC";
		String s2 = new String("aBc");
		boolean b1 = s1.equals(s2);
		boolean b2 = s1.equalsIgnoreCase(s2);  //忽略大小写判断字符串内容是否一致
		System.out.println(b1);
		System.out.println(b2);
		
		
		String s1 = "123-张三-男-23-陕西";
		String[] s2 = s1.split("-"); //根据特殊字符-，将s1内容分割成数组  => String[] s2 = {"1","张三","男","23","陕西"}
		System.out.println("该学生的学号："+s2[0]);
		System.out.println("该学生的姓名："+s2[1]);
		System.out.println("该学生的性别："+s2[2]);
		System.out.println("该学生的年龄："+s2[3]);
		System.out.println("该学生的籍贯："+s2[4]);

StringBufffer：缓冲字符串：每次操作字符串都会在原始堆内存中操作，节省内存
		拥有与String同名的方法，还有额外的方法
		
		Scanner s1 = new Scanner(System.in);
		String str1 = s1.nextLine();
		StringBuffer s2 = new StringBuffer(str1);
		StringBuffer s3 =s2.reverse();		//字符串反转
		String s4 = s3.toString();
		System.out.println(s4);
		s1.setCharAt(1, 'x');  //根据下标，修改字符
		s1.append("abc");   //拼接
		s1.append(123);
		s1.delete(1, 3);   //删除
	
	
	
StringBuilder：可变字符串，方法与StringBufffer完全一样，区别：StringBufffer线程安全，		
				StringBuilder线程不安全

Date

java.util.Date d1 = new java.util.Date();父类：无参构造器获得系统当前时间
java.util.Date d2 = new java.util.Date(1000L*60*60*24+1000L);
有参构造器：从1970-01-01 08:00:00开始计算，经过了多少毫秒，作用：将long类型的数字，转成Date类型

java.sql.Date d2 =  new java.sql.Date(1000L*60*60*24+1000L);		子类
System.out.println(d2);

	long a = d.getTime();	//将Date类型的时间转成long类型
	boolean b1 = d1.after(d2);	判断d1是否在d2之后
	boolean b2 = d1.before(d2);	判断d1是否在d2之前
	
	
	
父类可以获得当前时间
子类只能根据某一个long类型数字，获得时间点：从1970-01-01 08:00:00开始计算，经过了多少毫秒

SimpleDateFormat

时间格式化工具类：构造器参数：字母不能变，对应具体的时间，可以只定义部分格式，格式的符号可以随意改变。
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");
String s1 = sdf1.format(d1);	将Date类型的时间转成字符串格式。

将字符串时间转成Date类型，注意字符串与工具类的格式要匹配，向上抛出异常，必须处理或者继续向上抛出
java.util.Date d5 =  sdf1.parse("1999-01-01 11:11:11.999");	


String->Date
String->long

Date->String
Date->long

long->Date
long->String

Arrays

数组工具类：
	创建一个新数组，长度为新长度，将老数组内容赋值到新数组中
数据类型[] 新数组 = Arrays.copyOf(原数组，新长度);

	将数组内容拼接成字符串
String ss = Arrays.toString(数组);

	针对数组排序，从小到大
Arrays.sort(a);

基本类型的包装类

基本类型			引用类
byte				Byte
short				Short
int					Integer
long				Long
float				Float
double				Double
char				Character
boolean				Boolean

实际应用中基本类型会自动装箱成引用类型，引用类型也会自动拆箱成基本数据类型
	int a = 1;
	Integer b = 1;
	Integer b1 = a;
	int c = b;
引用类型有属性和方法：
	String s1 = "123";
	int a = Integer.MAX_VALUE;  //获得int最大值
	int b = Integer.MIN_VALUE;	//获得int最小值
	int c = Integer.parseInt(s1);   //将纯数字类型的字符串转换成int类型


	String s1 = "123.1";
	float f1  = Float.MAX_VALUE;
	float f2  = Float.MIN_VALUE;
	float f3 = Float.parseFloat(s1);
	System.out.println(f1);
	System.out.println(f2);
	System.out.println(f3);

集合

作用：类似与数组。与数组的区别：集合的长度是可变的，集合中的数据全是Object类型
底层数据结构：


Collection(父接口)
	List(子接口)
		ArrayList(实现类)
		Vector(实现类)
		LinkedList(实现类)
	Set(子接口)
		HashSet(实现类)
		TreeSet(实现类)
Map(父接口)
	HashMap(实现类)
	TreeMap(实现类)

ArrayList

特点：内容可以重复，内容可以为null，内容有序(添加顺序)，线程不安全	
底层数据结构：数组：占用连续内存空间，添加数据很慢(扩容：数据量越大，执行越慢)，获取数据快
		ArrayList list = new ArrayList();
		list.add("abc");
		list.add(123);
		list.add(true);
		list.add(123.2);
		list.add(1,null);
		//System.out.println(list);
		//System.out.println(list);
		//System.out.println(list.size());	获得集合长度
		//Object obj = list.get(2);				根据下标获取对象
		//System.out.println(obj);
		//list.clear();						//清空集合
		//Object obj = list.clone();			//克隆
		//boolean b1 = list.contains("abc");	//判断集合是否包含对象
		//int x = list.indexOf(null);		//根据内容找下标
		//boolean  b = list.isEmpty();		判断集合是否为空
		//Object obj1 = list.remove(2);  //根据下标删除对象，返回被删除的对象
//		list.remove((Integer)2);
//		boolean b1 = list.remove("abc");	 //将集合中的对象删除
//		System.out.println(b1);
		//list.set(2, 222);					内容替换
//		List list2 = list.subList(1, 3);		//截取
		for(int i=0;i<list.size();i++) {
			Object obj = list.get(i);
			System.out.println(obj);
		}

Vector

特点：内容可以重复，内容可以为null，内容有序(添加顺序)，线程安全,所有功能与ArrayList相同
底层数据结构：与ArrayList相同
底层数据结构：数组

LinkedList

特点：内容可以重复，内容可以为null，内容有序(添加顺序)，线程不安全
底层数据结构：双向链表：数据量也大，获取越慢(指针向后移动N次),添加数据很快，默认直接在链表尾部添加数据


//		List list = new LinkedList();
//		list.add("abc");
//		list.add(123);
//		list.add(123);
//		list.add(true);
//		list.add(2);
//		list.add(1,null);
//		
//		//list.clear();						//清空集合
//		boolean b1 = list.contains("abc");	//判断集合是否包含对象
//		int x = list.indexOf(null);		//根据内容找下标
//		boolean  b = list.isEmpty();		//判断集合是否为空
//		Object obj1 = list.remove(2);  //根据下标删除对象，返回被删除的对象
//		list.remove((Integer)2);
//		boolean xxx = list.remove("abc");	 //将集合中的对象删除
//		System.out.println(xxx);
//		list.set(2, 222);					//内容替换
//		List list2 = list.subList(1, 3);		//截取
//		
//		
//		
//		for(int i=0;i<list.size();i++) {
//			Object object = list.get(i);
//			System.out.println(object);
//		}
//		System.out.println("=======================");
//		Iterator it = list.iterator();  //将集合中的数据放入迭代器
//		while(it.hasNext()) {
//			Object obj = it.next();
//			System.out.println(obj);
//		}

双向链表

HashSet

特点：内容不可以重复，内容可以为null，内容无序(不是添加顺序)，线程不安全	
底层数据结构：哈希表，将对象转成哈希码，哈希码有可能重复(哈希碰撞)，当添加对象时，add会先调用对象的hashCode方法，如果哈希码不同，则认为是不同的对象，如果哈希码相同了，则再调用对象的equals方法来判断对象是否相等。HashSet在添加对象时，源码就是HashMap的put方法，键为添加的对象，value全是new Object

		HashSet set1 = new HashSet();
		set1.add("aaa");
		set1.add("bbb");
		set1.add("aaa");
		set1.add(null);
		set1.remove(null);
		System.out.println(set1.size());
		Iterator it1 = set1.iterator();
		while(it1.hasNext()) {
			Object obj1 = it1.next();
			System.out.println(obj1);
		}

TreeSet

特点：内容不可以重复，不内容可以为null，内容有序(默认从小到大)，线程不安全	
	注意：TreeSet添加的对象必须实现比较器接口(Comparable)
	
底层结构：红黑树，是一种特殊的二叉树，比二叉树性能提升。

		TreeSet set = new TreeSet();
		set.add("abb");
		set.add("aaa");
		set.add("aab");
//		set.add(123);
		set.add("aba");
		
		Object obj2 = set.first();
		System.out.println(obj2);
		
		Object obj3 = set.last();
		System.out.println(obj3);

		//System.out.println(set.size());
//		Iterator it1 = set.iterator();
//		while(it1.hasNext()) {
//			Object obj1 = it1.next();
//			System.out.println(obj1);
//		}

集合排序

排序接口：都可以通过Comparable或者Comparator实现

	TreeSet通过有参或者无参构造器可以排序	
		无参构造器：添加的对象必须实现Comparable接口
		有参构造器：创建一个Comparator子类对象
	Collections工具类的sort方法，可以针对List接口排序
		Collections.sort(list1);		从小到大排序，集合中添加的对象Emp必须实现Comparable接口
		Collections.sort(list1,Comparator对象);	从小到大排序，需要创建Comparator子类对象


TreeSet排序：
		1：使用无参构造器：添加对象时，对象必须实现排序接口(Comparable)
		2：可以通过TreeSet有参构造器可以实现排序(Comparator)，需要自定义一个Comparator的实现类，
			充当排序规则方法
			
Collections：集合工具类			
		Colletions.sort(List list);		强调参数时List接口，所以所有子类对象都可以排序
		Collections.sort(list1);		从小到大排序，集合中添加的对象Emp必须实现Comparable接口
		Collections.sort(list1,Comparator对象);	从小到大排序，需要创建Comparator子类对象
		Collections.reverse(list1);		反转

红黑树

HashMap

添加对象时，必须以键值对的形式添加，每一个value都必须起一个名字叫做键
特点：键不能重复(键重复值被覆盖)，键值可以为null，内容无序(不是添加顺序)，线程不安全

底层特点：数组+链表(红黑树)
		当第一次添加数据时，HashMap的put方法会创建一个长度为16的数组，先计算键的哈希码值，根据键的哈希码值，确定数组的位置，将对象添加到数组中该位置上，该位置上创建一个单向链表对象，当再次添加对象时，对象的键的哈希值如果在数据中已经存在，则再次调用equals方法，判断键在该数组的链表上是否存在，如果存在则替换value值，如果调用equals方法判断该链表上没有相等的键，则在该链表上继续添加对象。当数据量过大时：当某一个链表的长度超过8时，数组会自动扩容；数组默认长度是16，当数组实际长度超过16*0.75时，会自动扩容;0.75称之为HashMap的扩容因子(常量),每次扩容为当前数组长度*2,数组长度每次到达当前长度*0.75时，都会自动扩容，数组每次扩容都会重新计算每个键的哈希值，将所有对象打乱重新存入数组的位置上；当某一个桶位上的链表长度=8时，且数组长度超过64时，会将该桶位上的链表改为红黑树(jdk1.8版本之后，之前老版本只是链表)

		Map map = new HashMap();
		map.put(1,"aaa");
		map.put("aaa","bbb");
		map.put(1,"ccc");
		map.put(null,"aaa");
		map.put("xxx",null);
		map.put("xxx2",null);
//		System.out.println(map.size());  //集合长度
//		Object value = map.get(1);		//根据键获得对象
//		System.out.println(value);      
		
//		map.clear();
//		boolean b1 = map.containsKey("bbb");    //判断是否包含键
//		boolean b2 = map.containsValue("bbb");	//判断是否包含值
//		System.out.println(b1);
//		System.out.println(b2);
		
//		Set set = map.keySet();  //获得map中所有的键
//		Iterator it1 = set.iterator();
//		while(it1.hasNext()) {
//			Object key = it1.next();
//			Object value = map.get(key);
//			System.out.println(key+"============"+value);
//		}
		
//		Collection c1 = map.values();  //获得map的所有value值
//		Iterator it1 = c1.iterator();
//		while(it1.hasNext()) {
//			Object value = it1.next();
//			System.out.println(value);
//		}
		
//		Object obj1 = map.remove(1);  //根据键删除对象，返回被删除的对象
//		System.out.println(obj1);
//		boolean f1 = map.remove(1, "ddd");	//根据键值对删除对象，返回boolean
//		System.out.println(f1);	
//		System.out.println(map);
		
		
//		Object obj1 = map.replace(1,"ddd");  //根据键，替换value对象
//		boolean b1 = map.replace(1,"ccc1","ddd");	//根据键值对，替换value对象
//		System.out.println(b1);
//		System.out.println(map);

HashMap结构图

TreeMap

特点：键不可以重复(键重复值被覆盖)，键不可以为null，内容有序(默认根据键从小到大)，线程不安全
	底层特点：Entry类型的红黑树，会自动根据键从小到大排序，键必须实现排序接口


		TreeMap<String, Integer> map = new TreeMap<String, Integer>();
		map.put("a3",222);
		map.put("a1",333);
		map.put("a2",111);
		map.put("a4",null);
		map.put("a1",null);
		//System.out.println(map);
		
		Set<String> set = map.keySet();
		Iterator<String> it1 = set.iterator();
		while(it1.hasNext()) {
			String key = it1.next();
			Integer value = map.get(key);
			System.out.println(key + "=====" + value);
		}

Iterator

迭代器：容器，专门来处理集合中的数据。

	Iterator it = list.iterator();  //将集合中的数据放入迭代器
	boolean b1 = it.hasNext();		判断当前指针后面一个位置是否有对象
	Object obj = it.next();			指针向后移动过一次，并获得对象

迭代器

泛型

作用：给一个类定义一个形参，目的：让该类更加灵活。
语法：
	T就是泛型：创建Abc对象时,可以传入一个类型，那么在该Abc类中的方法中，就可以使用T代表一个数据类型。
	public class Abc<T> {
        public void a1(T a) {

        }
    }
//		Abc abc1 = new Abc();  //没有使用泛型，则泛型代表Object类型
//		abc1.a1(12);
//		Abc<String> abc2 = new Abc<String>(); //传入String类型当泛型
//		abc2.a1("abc");
//		Abc<Emp> abc3 = new Abc<Emp>(); //传入Emp类型当泛型
//		abc3.a1(new Emp());

二进制换算

File

文件类

程序中的路径：
	g:/aaa/1.txt
	g:\\aaa\\1.txt
	g:\aaa\1.txt：错误，\在java中代表转义字符：将该符号后面的一个字母改变含义，java中定义了很多固定的转义字符，不用记，后面慢慢会见到更多的内容。



//		System.out.println("aaaaa\taaaaa");
//		System.out.println("aaaaa\naaaaa");
		
		//仅仅只是在内存中开辟空间，保存该文件路径，与文件没有关系
		File f1 = new File("g:\\aaa\\1.txt");
		File f2 = new File("g:\\aaa");
		boolean b1 = f1.canRead();	//判断文件是否可读
		boolean b2 = f1.canWrite();//判断文件是否可写
		boolean b3 = f1.exists();//判断文件是否存在
		boolean b5 = f1.isFile();  //判断f1对象是否是个文件
//		try {
//			boolean b4 = f1.createNewFile();  //创建文件
//			System.out.println(b4);
//		} catch (IOException e) {
//			e.printStackTrace();
//		}
//		System.out.println(b1);
//		System.out.println(b2);
//		System.out.println(b3);
//		System.out.println(b5);
		
//		boolean b6 = f2.isFile();   //判断f2是否是个文件
//		boolean b7 = f2.isDirectory();//判断f2是否是个目录文件夹
//		System.out.println(b6);
//		System.out.println(b7);
		
		
//		File f3 = new File("g:\\aaa\\bbb\\ccc");
//		boolean f8 = f3.mkdirs();  //创建文件夹
		//boolean f9 = f3.mkdir(); //创建文件夹,父目录必须存在
//		System.out.println(f8);
		
//		String name1 = f1.getName();   //文件名
//		String path1 = f1.getPath();   //获得文件路径
//		String p1 = f1.getParent();		//获得文件对象的父路径
//		File ff2 = f1.getParentFile();	//获得文件对象的父文件对象
//		System.out.println(name1);
//		System.out.println(path1);
//		System.out.println(p1);
//		System.out.println(ff2);
		
		
//		File[] ff = f2.listFiles();  //获得f2目录下所有文件数组
//		System.out.println(ff.length);
//		for (int i=0;i<ff.length;i++) {
//			File f9 = ff[i];
//			System.out.println(f9);
//		}
		
//		String[] ff = f2.list();  //获得f2目录下所有文件名
//		System.out.println(ff.length);
//		for (int i=0;i<ff.length;i++) {
//			String f9 = ff[i];
//			System.out.println(f9);
//		}
		
		File[] ff = File.listRoots();  //获得所有盘符
		for (int i=0;i<ff.length;i++) {
			File f9 = ff[i];
			System.out.println(f9);
		}
		
		
		File f1 = new File("G:\\aaa\\1.txt");
		File f2 = new File("G:\\bbb\\2.txt");
		boolean b1 = f1.renameTo(f2);  
		注意:
			f1和f2路径相同时，文件名不同，则重命名
			f1和f2路径不相同时，则剪切粘贴，不能复制粘贴文件

递归算法

方法有条件的情况下自己调用自己。
注意：先进后出
	int i=0;
	int sum = 0;
	public int t1(){
		i++;
		sum+=i;
		if(i<=99) {
			t1(); 
		}
		return sum;
	}
	
	
作业1：自定义一个文件对象，File f1 = new File("g:\\aaa");输出该文件下所有的文件
作业2：自定义一个文件对象，File f1 = new File("g:\\aaa");将该文件下所有的文件及目复制到j:\\aaa下(文件的复制还没将，但是需要先将文件夹目录结构会创建出来)
	g:\aaa\1.txt
    g:\aaa\bbb\2.txt
    g:\aaa\bbb\ccc\3.txt
    	↓
    j:\aaa\
    j:\aaa\bbb\
    j:\aaa\bbb\ccc\
作业3："g:\\aaa\\1.png"->复制到"g:\\bbb\\1.png"
附加：将g:\\aaa中所有内容复制到"g:\\bbb"

递归调用

IO流

操作文件：类比较多，与集合的学习方法一样，归类理解
流：水流，电流，要强调方向与内容是什么？想象成管道。都在操作文件的内容。


字节流：流的内容是字节：一个字符(char)占2字节(B),1个字节(B)占8位(b)
	输出流：从内存到硬盘，写入硬盘
	输入流：从硬盘到内存,读取文件
	OutputStream：父类抽象类：通过构造器会创建一个新文件，覆盖老文件
		FileOutputStream：文件字节输出流,
			public void write(int a);		一次写一个字节，写入文件
			public void write(byte[] a);		一次写一个字节数组，写入文件
			public void write(byte[] a,int b,int c);一次写一个字节数组,从下标b开始写c个长度
			
	InputStream：父类抽象类
		FileInputStream：文件字节输入流
			public  int  read()；			一次读取一个字节，读取不到返回-1
			一次读取b.length个字节,读取到的内容存入数组，返回实际读取到的长度，读取不到返回-1
			public  int  read(byte[] b)		 
			一次读取c个字节,读取到的内容存入数组，从下标a开始存,返回实际读取到的长度，读取不到返回-1
			public  int  read(byte[] b,int a,int c)

	对象流：
			FileOutputStream fos = new FileOutputStream(f1);
			//对象输出流：可以写对象,会创建文件对象并序列化文件
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			//对象流在写对象时，该对象必须实现序列化接口(Serializable)
			oos.writeObject(e1);
			
			
			FileInputStream fis = new FileInputStream(f1);
			ObjectInputStream ois = new ObjectInputStream(fis);
			Emp obj = (Emp)ois.readObject();
			System.out.println(obj);
			
			
	序列化：Serializable：该接口只是一个标识，空接口，
		只要将一个对象通过内存保存在硬盘上，只要经过该过程，该对象必须实现序列化接口：序列化的过程：就是将该对象所在堆内存块中的内容打碎成字节数据。
	
	反序列化：从读取硬盘上的内容，反序列化(将字节数组重组的过程)成对象
	注意：一个项目中需要序列化的对象可能不一只一个类对象，序列化与反序列化就需要一个常量充当加密与解密的密钥。通过该常量密钥保证序列化与反序列化的结果保证一致。该常量密钥可以自定义。




字符流：流的内容是字符(只能操作纯文本文档(字符串))
	输出流：从内存到硬盘
	输入流：从硬盘到内存
	Reader：父类抽象类：
		FileReader
			public  int  read()；			一次读取一个字符，读取不到返回-1
			public  int  read(char[] c)；	一次读取一个字符数组，读取不到返回-1
			一次读取length个字符，读取到的内容存在数组的index下标，返回实际读取到的长度，读取不到返回-1
			public  int  read(char[] c,int index,int length)；			
	Writer：父类抽象类：
		FileWriter：
			public void  write(int c)		一次写一个字符，写入文件
			public void  write(char[] c)	一次写一个字符数组，写入文件
			一次写一个字符数组，从下标位index开始写length个长度
			public void  write(char[] c,int index,int length)	
			public void  write(String a)	一次写一个字符串
	
		BufferedWriter：缓冲字符流：针对Writer子类进行优化，
			public void  write(String a)	一次写一个字符串
			public void newLine()			换行
		BufferedReader：缓冲字符流：针对Reader子类进行优化，
			public String  readLine()	一次读取一行，读取不到返回null
		
		
		数据转换流：重点在于将将字节流转成字符流，不在于读写内容
			OutputStreamWriter
			InputStreamReader
		
			File f1 = new File("g:\\aaa\\1.txt");
			FileOutputStream fos = new FileOutputStream(f1);
			//数据转换流：将字节流转成字符流
			OutputStreamWriter osw = new OutputStreamWriter(fos);
			BufferedWriter bw = new BufferedWriter(osw);
			
			
			FileInputStream fis = new FileInputStream(f1);
			//数据转换流：将字节流转成字符流
			InputStreamReader isr = new InputStreamReader(fis);
			BufferedReader br = new BufferedReader(isr);

多线程

进程：一个应用程序至少有一个进程

线程：一个应用程序至少有一个进程，一个进程也至少有一个线程在执行(主线程)，主线程可以通过程序，创建多个子线程(多个雇佣工人)，可以同时干一件事，也可是同时干不同的事情。

实现方式

实现方式1：继承Thread，重新run方法
		public class MyThread extends Thread{
            //来当以当前线程干什么活
            public void run() {
                for(;;) {
                    System.out.println(Thread.currentThread().getName()+"11111111111");
                }
            }
        }
	main：
		1：创建子线程对象
            //主线程创建了一个子线程对象(雇佣了一个小工)
            MyThread t1 = new MyThread();
		2：线程对象调用strat方法，来让子线程(小工)对象干活
			t1.start();//让小工开始干活
			
			
实现方式2：实现Runnable接口，重新run方法
		public class MyRunnable implements Runnable{
            //来当以当前线程干什么活
            public void run() {
                while (true) {
			System.out.println(Thread.currentThread().getName()+"1111111111111111111");
                }
            }
        }
        //子线程任务对象
		MyRunnable myRunnable = new MyRunnable();
		//创建子线程对象
		Thread t1 = new Thread(myRunnable); 
		//子线程干活
		t1.start();
        
 
实现方式3：实现Callable接口，重写call方法



 
 
注意：
	使用Thread方式实现多线程：这每个子线程都会new一个内存空间，所有每个线程对象都会独立干自己的活
	使用Runnable方式实现多线程：可以让多个子线程干同一件事，也可以干不同的事
	因为java是单一继承，如果一个类继承了Thread类，那么不能再继承其他类了，有局限性，并且Runnable使用时更加灵活，所以使用Runnable的情况更多。

线程的生命周期

1:出生状态：创建了线程对象：new Thread();
2:就绪状态：线程对象被加载到内存中，还没有执行run方法:start()
3:执行状态：当线程对象被加载到内存后，不受代码程序的控制了，多线程对象取争抢cpu资源，谁抢到资源，谁执行，没有抢到，依然处于就绪状态
4：阻塞状态：再执行状态过程中，碰到等待、睡眠.....等等特殊情况，暂停执行了，等到回复以后，该线程进入就绪状态
5：死亡状态：线程run方法执行完毕，或者抛出异常。


	睡眠：sleep()
	等待：wait()
	唤醒：notify() 

线程的优先级

线程的优先级不是绝对设置，只是建议，具体依然依靠线程对象争抢cpu资源
	t1.setPriority(Thread.MAX_PRIORITY);
	t2.setPriority(Thread.NORM_PRIORITY);
	t3.setPriority(Thread.MIN_PRIORITY);

线程锁同步锁

synchronized：可以修饰方法，可以修饰代码块：给该方法或者该代码块添加锁：一个线程执行该代码时，先加锁，其他线程强制等待，执行完后释放该锁

public synchronized void a1(){}
synchronized(对象){   //给该对象加锁并，只有一个线程进入代码块
	代码块
}

线程通信

等待：wait()
唤醒：notify()
	注意：
		1：wait()：将该对象加锁并等待
		2：notify()：唤醒该对象并释放锁
		3：使用该方法时，该方法必须再同步代码块中使用

作业 ：
	两个线程，一个线程输出a~z的字母，另一个线程输出1~26的数字，要求两个线程运行后，输出a1b2c3....

打包

将项目打成jar或者war压缩包，当成工具包，给其他项目使用。
	jar：所有文件全是java源文件
	war：包含web项目页面和java文件。
导出：	
	右键项目->export->java->jar->next->选择路径完成
导入：
	1：jar包贴到项目src根据目录
	2：jar包上右键->build path->add to build path:将jar包导入到项目的工作区，在项目中就可是使用该jar包中类方法了。

jdbc

java   database   connective
java要操作jdbc，就需要引入mysql.jar,封装java操作jdbc的方法。

jdbc流程：举例借钱的过程

	1：先确定找谁借钱?
		先确定要连接哪个数据库?
			//加载mysql数据库驱动类：确定要连接哪个数据库
			Class.forName("com.mysql.cj.jdbc.Driver");
		
	2：联系上该人？
		连接上数据库(navicat要连接数据库)
			//通过DriverManager类的静态方法getConnection获得连接对象
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1?serverTimeZone=Asia/Shanghai&characterEncoding=utf8", "root","123456");
			参数：serverTimeZone:确定时区
                characterEncoding：确定编码格式
			
			//设置jdbc事务方式，默认true：自动提交，false：不自动提交
			conn.setAutoCommit(false);
			
	3：说明来意，说明目的，
		获得操作状态对象
			//获得操作状态对象(父类)
			Statement state = conn.createStatement();
			
			//获得操作状态对象(预处理操作对象)：Statement的子类
			PreparedStatement
			String sql = "insert into emp values(null,?,?,?,?,?)";
			PreparedStatement pstmt = conn.prepareStatement(sql);
			pstmt.setString(1, "aaa"); //给问号设置属性值
			//pstmt.setString(2, "1999-01-01");
			pstmt.setDate(2, new Date(12121212122L));
			pstmt.setString(3, "女");
			pstmt.setString(4, "陕西");
			pstmt.setInt(5, 2);
		注意：	Statement和PreparedStatement的区别：
				1：Statement会产生sql注入的问题，而PreparedStatement可以避免sql注入的问题
				2：PreparedStatement可以使用？充当sql语句的占位符(参数)，而且问号不区分数据类型
			
			
			
	4：实现借钱的过程
		实现增删查改数据的过程(curd)
			//String sql = "delete from emp where eid=7";
			//只能执行增、删、改的sql语句
			//int a = state.executeUpdate(sql);
			//提交事务
			conn.commit(); 
			catch中发生异常：conn.rollback();
			
			
			//String sql = "select * from emp where eid>0";
//			//只能执行查询的sql语句，返回类型：结果集(二维表)
//			ResultSet rs = state.executeQuery(sql);
//			while(rs.next()) {  //rs.next():结果集判断是否有下一行记录，并向下移动一行
//				int eid = rs.getInt(1);   //获得结果集指针所值行的第一列
//				String ename = rs.getString(2);
//				int eage = rs.getInt("eage");
//				String esex = rs.getString("esex");
//				String eadd = rs.getString(5);
//				System.out.println(eid+"  "+ename+"  "+eage+"   "+esex+"  "+eadd);
//			}
		
	5：离开
		关闭连接
			state.close();
			conn.close();
注意：导入mysql.jar	

sql注入

sql注入：在执行sql语句时，sql语句的参数包含了sql语句的关键字，会产生sql注入，会影响sql数据。
	要执行的sql：
		String sql = "select * from card where cnum='"+cnum+"' and cpwd='"+cpwd+"'";
		键盘输入账号随便，密码：' or 1='1
		结果：select * from card where cnum='abc' and cpwd='' or 1='1'
防止sql注入：就是使用Statement对象的子类：PreparedStatement方式sql注入

事务控制

事务：将一系列的操作定义为一个整体，要么所有操作都成功，只要有一个失败，数据必须回滚。
	jdbc如何控制事务：将连接对象默认自动提交设置false，每个方法中正常执行了，通过连接对象提交，异常回滚，最终关闭。

事务特性：ACID
	1.1 原子性（Atomicity）
		原子性是指事务是一个不可分割的工作单位，事务中的操作要么全部成功，要么全部失败(回滚)
	1.2 一致性（Consistency）
		程序数据与数据库的数据保持一致
	1.3 隔离性（Isolation）
		多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
	1.4 持久性（Durability）
		持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的

持久层框架：dao包改变

设计模式

jre一共规定了23种设计模式：按照固定的套路(逻辑)，来定义类，不同的套路就是不同的设计模式，不同的设计模式，就代表该类有不同的特点。

单例模式

该类的对象，在内存中永远就一份对象，目的：就是节省内存


懒汉模式
	public class SingleA {
	int xxx;
	public void a1() {
		
	}
	//当前类在外面，不能new
	private static SingleA a;
	private SingleA() {
		
	}
	public static synchronized SingleA  createSingleA() {
		if(a == null) {
			a = new SingleA();
		}
		return a;
	}

}


饿汉模式
	public class SingleB {
        int xxx;
        public void a1() {

        }
        private static SingleB b = new SingleB();
        private SingleB() {

        }
        public static synchronized SingleB  createSingleB() {
            return b;
        }
    }


可以通过静态代码块实现：
	public class SingleC {
        int xxx;
        public void a1() {

        }
        private static SingleC c;
        private SingleC() {}

        static {
            c = new SingleC();
        }
        public static synchronized SingleC  createSingleC() {
            return c;
        }
    }
  要求单例模式必须会手写

作业

1：将EmpDaoImp和DeptDaoImp定义为单例模式
2：完成员工部门所有操作，main选择操作，完成整个项目功能。