Java自学笔记

一、jre是java的运行环境，jdk是java开发工具包，其中包括jre

二、转义字符：

\n:回车  \t:制表符   \b:退格   \r:按下回车键
windows操作系统中回车符为\r\n
linux操作系统中回车符为\n

三、封装就是在类中把变量用private定义，然后用public封装赋值

四、构造函数指构建创造对象时调用的函数，

class person{ person(){
    
} }

五、重载是在有多个构造函数，参数个数或类型不同

六、this关键字指当前对象的方法或变量

七、static指当前对象共享值：

只能访问静态成员，不能访问变量

八、继承:extends

 当类与类之间存在着所属关系的时候，就定义继承 
	 
    由一个类继承另一个类中的属性或变量，
    eg:student（子类） extends person（父类） person中与name和age变量
    
	java支持单继承不直接支持多继承，支持多层继承
	
	单继承：一个子类只能有一个直接父类

	个人理解，父类在子类前面

 	在子类构建对象时，子类运行构造函数zi(),时父类也运行了fu()，相当于在zi类中有个super();

九、super关键字指父类的变量:

super.xx，代表父类空间

十、final关键字

final可以修饰类，方法，变量，
final修饰的类不可以被继承

 final class xxx

修饰的方法不可以被覆盖，修饰的变量是一个常量，而且只能被赋值一次，
内部类只能访问被final修饰的局部变量
写法规范，常量所有字幕都大写，多个单词，中间用_连接

十一、abstract抽象类 一定是父类

1、抽象方法必须定义在抽象类中，该类也必须被abstract修饰；
2、抽象类不可以被实例化
3、抽象类必须有其子类覆盖了所有的抽象方法后，该类才可以实例化，否则这个子类还是抽象类
为了不让这个类创建对象，可以使用这个方法

十二、接口：interface

• 当一个抽象类中的方法都是抽象的时候可以使用，接口不可以实例化，
  只能由实现了接口的子类覆盖了接口中所有的抽象方法后，该子类才可以实例化
  定义接口使用的关键字不是class 而是interface，直接interface

  xxx{
  abstract void xxx();

  };

  对于接口当中常见的成员，而且这些成员都有固定的修饰符。
  1、全局变量 public static final（可省略）
  2、抽象方法 public abstract（可省略）
  结论：接口中的成员都是公共的,

十三、implements 实现

• 类与类之间是继承关系，类与接口之间是实现关系

    class xxx implements xxx
  

十四、对象的多态性

• 就是一个对象对应着不同类型
  在代码中的体现：
  父类或者接口的引用指向其子类的对象
  父类创建的对象指向了子类

  父类xx x=new 子类xx()

  多态的转型
  Animal a=new Cat(); cat c=(cat)a

十五、类型判断 instanceof

	a instanceof cat 传过来的a是cat猫类型

十六、多态时成员特点：

fu f=new zi()	
1、成员变量:int i=1；编译和运行看左面
2、成员函数:void xxx();编译看左面，运行看右面；
3、静态函数:stact void xxx();都看左面

十七、内部类

class xxx{ 
    class xx1 {
        void show(){
            
        }
        
    }
    public void xxx(){
    
        xx1 i=new xx1()
        
    }
    
}

1、内部类可以直接访问外部类中的成员
2、外部类要访问内部类、必须建立内部类的对象
访问内部类 wai.nei xx=new wai().new.nei();

十八、匿名内部类

new fu(){void xxx(){}};

使用场景：
当函数参数是接口类型是，而且接口中的方法不超过三个，可用匿名内部类作为实际参数传递

十九、Throwable:父类，可抛型

1、Error错误：不可处理，由jvm抛出的严重性问题
2、Exception异常：可处理

二十、异常处理

try{
//需要被检验异常的代码
}catch(异常类 变量)//该变量用于接受发生的异常对象
{
//处理异常的代码
}finally{
//一定被执行的代码
}

二十一、protected 保护权限 只有继承在可以访问其他包的

| Tables    | public  | protected | default | private|
| 同一类中  | ok      |   ok      |    ok   |
| 同一包中  | ok      |   ok      |
| 子类中    | ok      |           |
| 不同包中  | ok      |           |

二十二、package 创建包

二十三、import xxx.xxx 导入指定包中的指定类

import xxx.* 导入xxx包中所有类
导入之后直接new 类就可以使用

二十四、多线程

进程：正在进行中的程序；

线程：就是进程中一个负责程序执行的控制单元（执行路径）

一个进程中可以有多个线程，称为多线程
一个进程中至少要有一个线程
开启多个线程是为了同时运行多部分代码，
每个线程都有自己运行的内容，这个内容可以称为线程要执行的任务

二十五、创建线程方式一：继承Thread类

步骤
1、定义一个类继承Thread类
2、覆盖Thread类中的run方法
3、直接创建Thread类的子对象
class Demo extends Thread{
	public void run() {
	show();
}
}

Deno d=new Demo()
d.start()//使改线程开始执行，java虚拟机调用该线程run方法
getName（）//获取当前线程名称
Thread.currentThread().getName()//获取当前正在执行的线程名称
d.sleep(time) 睡眠//时间到
d.wait()等待
d.notify()唤醒，和wait对应

二十六、创建线程方式二：实现Runnable接口

定义类实现Runnable接口

1、覆盖接口中的run方法，将香橙的任务代码封装到run方法中
2、通过Thread类创建线程对象，并将Runnable接口的子类对象作为构造函数的参数进行传递
因为咸亨的任务都封装在RUnnable接口子类对象的run方法中
3、调用线程对象的start方法开启线程
//区别
实现Runnable接口的好处
	1、将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面对对象的思想将任务分装成对象。
	2避免了java单继承的局限性

二十七、线程安全问题

解决思路：
	将多条操作共享数据的线程代码封装起来，
	当有线程在执行这些代码的时候，其他线程时不可以参与运算
	必须要当前线程把这些代码执行完毕之后，其他线程才可以参与运算

二十八、synchrond(对象){}

同步代码块，为了解决线程安全问题
Object
好处：解决了线程的安全问题
弊端：相对降低效率
同步的前提：
	1、必须有多个线程并使用同一个锁
	
private Object  obj=new Object（）
synchrond（obj）

给函数设置同步性：
   public synchrcnized void name()//相当于synchrond（this）

静态函数锁为:this.getClass()//当前类对象

二十九、死锁

情形1、：嵌套
class Test{
	 private boolean flag
	
}

三十、线程间通讯：

多个线程在处理同一资源，但是任务不同

等待/唤醒机制
方法：
	1、wait()：让线程处于冻结状态，被wait的线程会被储存到线程池中
	2、notify（）：唤醒线程池中一个线程（任意）
	3、notifyAll（）：唤醒线程池中的所有线程
这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法，必须要明确到底操作的是哪个锁上的线程

三十一、Lock

//jdk1.5将同步和封装为对象，并将操作锁的隐式方式定义到了该对象中，将饮食动作变成了显示动作。
Lock lock=new ReentrantLock()
lock。lock()//锁
try{code... 
	}
finally{
	lock.unlock()
	}

通过已有的锁获取该锁上的监视器对象
Condition con =lock.newCondition()
//在外部定义
con.await//线程等待
con.singalAll//启动全部线程

三十二、wait和sleep的区别

1、wait可以指定时间也可以不指定，sleep必须指定时间
2、在同步中时，对于CPU的执行权和锁的处理不同
	wait：释放执行权，释放锁
	sleep：释放执行权，不释放锁

三十三、停止线程：

1、run方法结束
任务中都会有循环结构，只要控制住循环，就可以结束任务。 
控制循环通常用定义标记来完成
2、interrupt：中断线程//将可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格，但是强制动作会发生InterruptedException记得要处理

三十四、setDaemon：守护线程

该方法必须在启动线程前调用
当所有前台线程结束，守护线程结束，即：当正在运行的线程都是守护贤臣时，Java虚拟机退出

三十五、new Thread.join

线程要申请加入进来，运行
临时加入一个线程运算时，可以使用join方法

三十六、线程总结：

new Thread()
	{
		public void run()
		{
			for(int x=0; x<50; x++)
			{
				System.out.println(Thread.currentThread().getName()+"....x="+x);
			}

		}
	}.start();


	Runnable r = new Runnable()
	{
		public void run()
		{
			for(int x=0; x<50; x++)
			{
				System.out.println(Thread.currentThread().getName()+"....z="+x);
			}
		}
	};
	new Thread(r).start();

三十七、按照面向对象的想对字符串进行功能分类

	int xx=xxx.length()
1、获取：
	1.1、获取字符串中字符的个数（长度）
		int length();
	1.2、根据位置获取字符：
		char charAt(int index)
	1.3、根据字符获取在字符串中的第一次出现的位置
		int indexOf(int ch)
		int indexOf(int ch,int formIndex)//从指定位置进行ch的查找
		int indexOf(String str)
		int indexOf(String str,int formInde)
	      根据字符串获取在字符串中的最后出现的位置
		int lastIndexOf(int ch)
		int lastIndexOf(int ch,int formIndex)//从指定位置进行ch的查找
		int lastIndexOf(String str)
		int lastIndexOf(String str,int formInde)

	1.4、获取字符串中一部分字符串，也叫子串。
		String substring(int beginINdex,int endIndex)
		String substring(int beginIndex)

2、转换:
	2.1、将字符串变成字符串数组（字符串的切割）
		String[] split(String regex);regex为,一般
		
	2.2、将字符串变成字符数组。
		char[] toCharArray();
	2.3、将字符串变成字节数组。
		byte[] getBytes();
	2.4、将字符串中的字母转换大小写
		String toUpperCase()大写
		String toLowerCaase()小写
	2.5、将字符串中的内容进行替换
		String replace(char oldch,char newch)
		String replace(String s1,string s2);
	2.6、将字符串两端的空格去除。
		Sting trim()
	2.7、将字符串进行连接
		String concat(string)

3、判断：
	3.1、两个字符串内容是否相同
		boolean equals(Object obj)
		boolean equalsIgnoreCase(String str);//忽略大写比较字符串内容
	3.2、字符串当中是否包含指定字符串
		boolean contains(string str)
	3.3、字符串是否以指定字符串开头，是否以指定字符串结尾。
		boolean startsWith(string str)
		boolean startsWith(string str)
4、比较
	int compareTo()//返回int类型，前减后

三十八、intern() :对字符串池进行操作

eg:
String s1=new String("abc");
   String s2=s1.intern();

三十九、StrinfBuffer类 字符串缓冲区用于存储数据的容器

特点：
1、长度是可变的
2、可以储存不同类型的数据
3、最终要转成字符串进行使用
4、可以对字符串进行修改

功能:
1、添加：
	StringBuffer append(data)
	StringBuffer insert(index,data)
2、删除：
	StringBuffer delete(start,end)
	StringBuffer deleteCharAt(int index)删除指定位置元素			
3、查找：
	char charAt(index);
	int indexOf(string)
	int lastIndexOf(String);
4、修改：
	StringBuffer replace(star,end,string);
	void setCharAt(index,char)


eg:	创建缓冲区对象：StringBuffer sb=new StringBuffer();
			StringBuffer


StringBuilder线程不同步，通常用于单线程，他的出现提高效率

四十、基本数据类型对象包装类。

• 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。

• 用于描述该对象的类就称为基本数据类型对象包装类。

    * 
    * byte		Byte
    * short	Short
    * int		Integer
    * long		Long
    * float	Float
    * double	Double
    * char		Character
    * boolean	Boolean
    * 
    
    * 该包装对象主要用基本类型和字符串之间的转换。
    * 
    * 基本类型--->字符串
    * 		1,基本类型数值+""
    * 		2,用String类中的静态方法valueOf(基本类型数值);
    * 		3,用Integer的静态方法valueO(基本类型数值);
   * 
     字符串--->基本类型
    * 		1,使用包装类中的静态方法   xxx parseXxx("xxx类型的字符串");*****
    * 			int parseInt("intstring");
    * 			long parseLong("longstring");
    * 			boolean parseBoolean("booleanstring");
    * 			只有Character没有parse方法 
    * 		2,如果字符串被Integer进行对象的封装。
    * 			可使用另一个非静态的方法，intValue();
    * 			将一个Integer对象转成基本数据类型值。
    * 
  

四十一、集合类的由来：

对象用于封装特有数据，对象多了需要储存，如果对象的个数不确定，就是用集合容器进行储存

特点：

1、用于储存对象的容器；

2、集合的长度是可变的；

3、集合中不可以储存基本数据类型值；

集合容器因为内部的数据结构不同，有多重具体容器，不断的向上抽取，就形成了集合框架。
框架的顶层Collection接口：

Collection的常见方法：

	  	1、添加
			boolean add(Object obj)//添加一个对象
			boolean addAll(Collention coll)//添加多喝对象
		2、删除
			boolean remove(Objectobj)//删除一个
			boolean removeAll(Collention coll)
			void clear（）；//删除全部
		3、判断:
			boolean contains(Object obj)//判断是否包含指定的元素
			boolean containsAll(Collection coll);//判断是否包含collection中所以元素
			boolean ifEmpty();//判断集合是否为空
		4、获取：
		    int size();//获取长度
		    
            Iterator iterator()//取出元素的方式:迭代器
           // 该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
           所以该迭代器对象实在容器内部实现的。
           对于使