java笔记

XUN~MLF

已于 2022-06-20 23:13:31 修改

阅读量255

点赞数

分类专栏：后端文章标签： java 开发语言后端

于 2022-01-19 15:55:10 首次发布

本文链接：https://blog.csdn.net/XUN__MLF/article/details/122581890

版权

后端专栏收录该内容

13 篇文章 0 订阅

订阅专栏

面向对象基础

封装

1. 一般使用private访问权限。

2. 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(注意：boolean变量的get方法是is开头!)。

3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

继承

extend关键字

继承子类继承父类

在我们编程中，如果新定义一个Student类，发现已经有Person类包含了我们需要的属性和方法，那么Student类只需要继承Person类即可拥有Person类的属性和方法。

如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。默认继承object类

多态

多态的要点：

1. 多态是方法的多态，不是属性的多态(多态与属性无关)。

2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

抽象类与抽象方法

抽象方法：使用abstract修饰的方法，没有方法体，只有声明。

定义的是一种“规范”，

就是告诉子类必须要给抽象方法提供具体的实现。

包含抽象方法的类就是抽象类。

通过abstract方法定义规范，然后要求子类必须定义具体实现。

通过抽象类，我们就可以做到严格限制子类的设计，

使子类之间更加通用。

抽象类的使用要点:

1. 有抽象方法的类只能定义成抽象类

2. 抽象类不能实例化，即不能用new来实例化抽象类。

3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

4. 抽象类只能用来被继承。

5. 抽象方法必须被子类实现。

接口

声明格式：

[访问修饰符] interface 接口名 [extends 父接口1，父接口2…] {

常量定义；

方法定义；

}

定义接口的详细说明：

1. 访问修饰符：只能是public或默认。

2. 接口名：和类名采用相同命名机制。

3. extends：接口可以多继承。

4. 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。

5. 方法：接口中的方法只能是：public abstract。省略的话，也是public abstract。

要点

1. 子类通过implements来实现接口中的规范。

2. 接口不能创建实例，但是可用于声明引用变量类型。

3. 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

4. JDK1.7之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。

5. JDK1.8后，接口中包含普通的静态方法。

public class TestInterface {//源代码
    public static void main(String[] args) {
        Volant volant = new Angel();
        volant.fly();
        System.out.println(Volant.FLY_HIGHT);
         
        Honest honest = new GoodMan();
        honest.helpOther();
    }
}
/**飞行接口*/
interface Volant { 
    int FLY_HIGHT = 100;  // 总是：public static final类型的；
    void fly();   //总是：public abstract void fly();
}
/**善良接口*/
interface Honest { 
    void helpOther();
}
/**Angle类实现飞行接口和善良接口*/
class Angel implements Volant, Honest{
    public void fly() {
        System.out.println("我是天使，飞起来啦！");
    }
    public void helpOther() {
        System.out.println("扶老奶奶过马路！");
    }
}
class GoodMan implements Honest {
   public void helpOther() {
        System.out.println("扶老奶奶过马路！");
    }  
}
class BirdMan implements Volant {
    public void fly() {
        System.out.println("我是鸟人，正在飞！");
    }
}

内部类

在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。

.成员内部类(可以使用private、default、protected、public任意进行修饰。类文件：外部类$内部类.class)

a) 非静态内部类(外部类里使用非静态内部类和平时使用其他类没什么不同)

i. 非静态内部类必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。

ii. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。

iii. 非静态内部类不能有静态方法、静态属性和静态初始化块。

iv. 外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

v. 成员变量访问要点：

1. 内部类里方法的局部变量：变量名。

2. 内部类属性：this.变量名。

3. 外部类属性：外部类名.this.变量名。

关键字

this关键字

public class User {
    int id;        //id
    String name;   //账户名
    String pwd;   //密码
 
    public User() {
    }
    public User(int id, String name) {
        System.out.println("正在初始化已经创建好的对象："+this);
        this.id = id;   //不写this，无法区分局部变量id和成员变量id
        this.name = name;
    }

 User  u3 = new User(101,"高小七");

static关键字

1. 为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。

2. 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享!!

3. 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)

4. 在static方法中不可直接访问非static的成员。

static修饰的成员变量和方法，从属于类。

普通变量和方法从属于对象的。

instanceof运算符

instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。

方法的重写

1.“==”：方法名、形参列表相同。

2.“≤”：返回值类型和声明异常类型，子类小于等于父类。

3.“≥”：访问权限，子类大于等于父类。

super关键字

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。

常用类

String类

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

String s1 = "core Java";
        String s2 = "Core Java";
        System.out.println(s1.charAt(3));//提取下标为3的字符
        System.out.println(s2.length());//字符串的长度
        System.out.println(s1.equals(s2));//比较两个字符串是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//比较两个字符串（忽略大小写）
        System.out.println(s1.indexOf("Java"));//字符串s1中是否包含Java
        System.out.println(s1.indexOf("apple"));//字符串s1中是否包含apple
        String s = s1.replace(' ', '&');//将s1中的空格替换成&


String s = "";
        String s1 = "How are you?";
        System.out.println(s1.startsWith("How"));//是否以How开头
        System.out.println(s1.endsWith("you"));//是否以you结尾
        s = s1.substring(4);//提取子字符串：从下标为4的开始到字符串结尾为止
        System.out.println(s);
        s = s1.substring(4, 7);//提取子字符串：下标[4, 7) 不包括7
        System.out.println(s);
        s = s1.toLowerCase();//转小写
        System.out.println(s);
        s = s1.toUpperCase();//转大写
        System.out.println(s);
        String s2 = "  How old are you!! ";
        s = s2.trim();//去除字符串首尾的空格。注意：中间的空格不能去除
        System.out.println(s);
        System.out.println(s2);//因为String是不可变字符串，所以s2不变

时间类

需要导入 import java.util.Date;

创建时间类对象 Date 变量名=new Date();/*返回的是当前的时间

可以传入数字，返回的是该数字后的时间

Date类的常用方法

变量名.getxxx（）;

DateFormat类抽象类用子类实现

需要导入 import java.text.DateFormat;

创建DateFormat类对象 DateFormat d=new SimpleDateFormat

按照指定的格式将输入的毫秒进行字符串转化

Calendar日历类

创建一个Calendar类对象

Calendar d=new GregorianCalendar();

什么都不传默认返回的是今天的日期

常用方法

get方法

变量名.get（Calendar.YEAR(or month week);get方法得到你所要的东西

set方法	变量名.set(Calendar.YEAR,8012)
add方法	变量名.add（Calendar.YEAR,100)

Math类

Math类的常用方法：

1. abs 绝对值

2. acos,asin,atan,cos,sin,tan 三角函数

3. sqrt 平方根

4. pow(double a, double b) a的b次幂

5. max(double a, double b) 取大值

6. min(double a, double b) 取小值

7. ceil(double a) 大于a的最小整数

8. floor(double a) 小于a的最大整数

9. random() 返回 0.0 到 1.0 的随机数

10. long round(double a) double型的数据a转换为long型(四舍五入)

11. toDegrees(double angrad) 弧度->角度

12. toRadians(double angdeg) 角度->弧度

Random类

 Random rand = new Random();
        //随机生成[0,1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(rand.nextInt());
        //随机生成[0,1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.print(rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据
        System.out.print(20 + rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据（此种方法计算较为复杂）
        System.out.print(20 + (int) (rand.nextDouble() * 10));

File类

需要导入包

import java.io.File;

File f=new File("D:/xiaoqiu233.txt");//创建一个File类对象

System.out.println(f);//直接打印路径

f.renameTo(new File("d:/xiaoqiu233.txt"));//文件改名

System.out.println("File是否存在："+f.exists());

System.out.println("File是否是目录："+f.isDirectory());

System.out.println("File是否是文件："+f.isFile());

System.out.println("File最后修改时间："+new Date(f.lastModified()));//需要导入时间类

System.out.println("File的大小："+f.length());

System.out.println("File的文件名："+f.getName());

System.out.println("File的目录路径："+f.getPath());

File F=new File("d:/xiaoqiu/xiaoqiuzzz/xiaoqiu2333");

boolean flag=F.mkdirs();//创建整个目录，mkdir如果一个内容没有则为false

System.out.println(flag)；

// 递归调用文件夹遍历
public static void main(String[] args) {
		File f=new File("
		");
		printfile(f,0);
	}

	static void printfile(File file,int level){
		
		for(int i=0;i<level;i++){
			System.out.print("-");
		}
		System.out.println(file.getName());//获得文件名
		
		if(file.isDirectory()){//是否含有子目录
			File files[]=file.listFiles();//子目录
			for(File temp:files){
				printfile(temp,level+1);
				
			}
		}
		
		
		
	}

枚举类

public class test枚举 {

public static void main(String[] args) {

week a=week.星期一;

System.out.println(a);

}

enum week{

星期日,星期一,星期二,星期三,星期四,星期五,星期六

}//新建一个枚举

}

容器

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

IO流

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

流的种类

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

16种流

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

FileInputStream

New byte数组的时候可以用一个啊available();返回未读的长度,直接用这个长度来new数组

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class inputScream {//读文件
	public static void main(String[] args) {
		
		
			FileInputStream abc=null;
			try {
				abc=new FileInputStream("D:\\a.txt");
				byte[] bytes=new byte[4];
				try {
					int filecount=0;
					while(filecount!=-1) {		
						filecount= abc.read(bytes);
						System.out.print(new String(bytes,0,filecount));
						//System.out.println(filecount);
					}
					
					
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}finally {
				if(abc!=null) {	
					try {
						abc.close();
					}
					catch (IOException e) {
						e.printStackTrace();
					}
				}
			}		
			
		
		}
	
}

FileOutputStream

package IO;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class xqFOS {
	public static void main(String[] args) {
		FileOutputStream fos=null;
		try {
			//fos=new FileOutputStream("D:\\a.txt");这种方法会将原文件先清空
			fos=new FileOutputStream("D:\\a.txt",true);//文件不存在会自动新建
			byte [] bytes = {97,98,99,100};
			try {
				fos.write(bytes);
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			try {
				fos.flush();
			} catch (IOException e) {
				
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally {
			if(fos!=null) {
				try {
					fos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
}

package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class copy {
	public static void main(String[] args) {
		FileInputStream fis=null;
		FileOutputStream fos=null;
		try {
			fis=new FileInputStream("D:\\a.txt");//复制的文件
			fos=new FileOutputStream("D:\\Temp\\a.txt");//拷贝的位置
			byte [] bytes=new byte[1024*1024];
			int readcount=0;
			try {
				while((readcount=fis.read(bytes)) != -1) {//读
					fos.write(bytes, 0, readcount 	);//写
				}
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			try {
				fos.flush();//写的时候需要刷新
			} catch (IOException e) {			
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}finally{
			try {
				fis.close();//关闭两个流需要分开try不然其中一个出异常另一个流没有关闭
			} catch (IOException e) {
			
				e.printStackTrace();
			}
			try {
				fos.close();
			} catch (IOException e) {
				
				e.printStackTrace();
			}
		}
	}
}

FileReader

与FileInoutStream类似,只不过是char数组,那个是byte数组

package IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/*
 * 只能读取文本文档
 */
public class IOFileReader {
	public static void main(String[] args) {
		FileReader reader=null;
		try {
			reader=new FileReader("D:\\\\a.txt");
			char chars[]=new char[4];
			int readercount;
			try {
				while((readercount=reader.read(chars))!=-1) {
					System.out.print(new String(chars,0,readercount));
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				If(reader!=null){
				reader.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

FileWriter

与FileOutputStream类似使用时需要刷新,并且能直接写入字符串

package IO;

import java.io.FileWriter;
import java.io.IOException;

public class IOFlieWrite {
	public static void main(String[] args) {
		FileWriter write=null;
		try {
			write=new FileWriter("D:\\\\\\\\a.txt",true);
			char[] chars= {'我','是','小','球'};
			write.write(chars);
			write.write("2333");
			write.flush();
		} catch (IOException e) {
			
			e.printStackTrace();
		}finally {
			if(write!=null) {
				try {
					write.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		
	}

}

package IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class copy02 {
	public static void main(String[] args) {
		FileReader in= null;
		FileWriter out = null;
		try {
			in = new FileReader("D:\\\\a.txt");
			out = new FileWriter("D:\\\\Temp\\\\a.txt");
			char chars[] =new char[1024*1024];
			int readcount;
			while((readcount=in.read(chars))!=-1){
				out.write(chars,0,readcount);
			}
			out.flush();
		} catch (IOException e) {		
			e.printStackTrace();
		}finally {
			try {
				in.close();
			} catch (IOException e) {		
				e.printStackTrace();
			}
			try {
				out.close();
			} catch (IOException e) {	
				e.printStackTrace();
			}
		}
	}
}

BufferedReader

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

使用BufferedReader的readline方法可以读取一行,当是最后一行时再读返回的时null

可以只关处理流,节点流不用关,方法里自动关了

package IO;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class IOBufferReader {
	public static void main(String[] args) {
		FileReader reader;
		BufferedReader in=null;
		try {
			reader = new FileReader("D:\\a.txt");
			in = new BufferedReader(reader);
			String str;
			try {
				while((str=in.readLine())!=null) {
					System.out.println(str);
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				in.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
			
	}
}

转换流--转换

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

BufferedReader in=null;

in = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\a.txt")));

package IO;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class taowa {
	public static void main(String[] args) {
		BufferedReader in=null;
		try {
			 in = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\a.txt")));
			 String str=null;
			 try {
				while((str=in.readLine())!=null) {
					 System.out.println(str);
				 }
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				in.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

数据流

数据流new的时候需要传InputStream类型,但由于是抽象的传它的子类 FileInputStream;

读的时候只能按写的顺序读,属于一种加密

package IO;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
public class IODataOutputStream {
	public static void main(String[] args) {
		DataOutputStream dos=null;
		try {
			dos =new DataOutputStream(new FileOutputStream("d:/a.txt"));
			dos.writeBoolean();
			dos.flush();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				dos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

日志工具

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

整个文件夹拷贝

package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class copy3 {
	public static void main(String[] args) {
		File srcFile=new File("d://abc");
		File deskFile=new File("d://cba");
		copyFile(srcFile,deskFile);
		
	}

	private static void copyFile(File srcFile, File deskFile) {
		if(srcFile.isFile()) {
			FileInputStream in=null;
			FileOutputStream out =null;
			try {
				in=new FileInputStream(srcFile);
				String deskpath=deskFile.getAbsolutePath().endsWith("\\") ? deskFile.getAbsolutePath() :deskFile.getAbsolutePath()+"\\"+srcFile.getAbsolutePath().substring(3);
				//String deskpath=deskFile.getAbsolutePath()+srcFile.getAbsolutePath().substring(3);
				out=new FileOutputStream(deskpath);
				byte bytes[]=new byte[1024*1024];
				int readcount=0;
				try {
					while((readcount=in.read(bytes))!=-1){
						try {
							out.write(bytes,0,readcount);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						
					}
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				try {
					out.flush();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}finally {
				if(in!=null) {					
					try {
						in.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				if(out!=null) {
					
					try {
						out.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			return ;
		}
		File files[]=srcFile.listFiles();
		System.out.println(files.length);
		for(File file:files) {
			if(file.isDirectory()) {
				 String srcpath = file.getAbsolutePath(); 
				 String deskpath=deskFile.getAbsolutePath().endsWith("\\") ? deskFile.getAbsolutePath() :deskFile.getAbsolutePath()+"\\"+srcpath.substring(3);
				//String deskpath=deskFile.getAbsolutePath()+"//"+srcpath.substring(3);
				 File newFile=new File(deskpath);
				if(!newFile.exists()) {
					newFile.mkdirs();
				}
			}
			copyFile(file,deskFile);
		}
	}
		
	}

序列化与反序列化

序列化。

将java对象从内存中放到硬盘上，不会因为关机就没有了

反序列化。

将读取序列化了的java对象

主要是通过ObjectOutputSteam，ObjectInputStream来进行序列化和反序列化

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

当一个类实现serializable接口需要手动写序列号

private static final long serialVersionUID=1L;

package IO;

import java.io.Serializable;

public class user implements Serializable {
//需要实现这个接口
	private int id;
	private String name;
	private int age;
	public user(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	Public  user() {
		
	}
	public String toString() {//重写toString方法
		return "id:"+id+","+"name:"+name+","+ "age:"+age+",";
				 	
				
	}
	
}

package com.xiaoqiu.IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class TestObjectInputStream{
	public static void main(String[] args) throws Exception{
		User user1=new User("xiaoqiu","123");
		User user2=new User("xiaoqiu1","123456");
		List<User> userList=new ArrayList();
		userList.add(user1);
		userList.add(user2);
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("a"));
		//oos.writeObject(user1);序列号一个对象
		oos.writeObject(userList);//序列化多个对象
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("a"));
		Object obj1=ois.readObject();
		System.out.println(obj1);
	}	
	}
class User implements Serializable{
	String usename;
	String password;
	public User(String usename, String password) {
		super();
		this.usename = usename;
		this.password = password;
	}
	public User() {
		
	}
	public String getUsename() {
		return usename;
	}
	public void setUsename(String usename) {
		this.usename = usename;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String toString() {
		// TODO Auto-generated method stub
		return "usename"+"="+usename+"\t"+"password"+"="+password;
	}
	
}

关于序列号版本号

java是通过什么机制来区分类？

1.首先是通过类名，类名不一样的类一定不是同一个类

2.序列号版本号

自动生成的序列号版本号在序列化后更改了代码，序列号版本号也跟着改变了，反序列化的时候就找不到之前那个类

如果一个类实现了serializable接口，必须手动的写出来，防止以后更改了代码反序列化时找不到类

private static final long serialVersionUID = 1L;

IO与集合联系

package IO;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.Properties;

public class IOproperties {

public static void main(String[] args) {

FileInputStream in=null;

try {

in=new FileInputStream("d://c.txt");

Properties pro=new Properties();

try {

pro.load(in);//load方法可以放入这个in 流

System.out.println(pro.getProperty("name"));

System.out.println(pro.getProperty("password"));

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

} catch (FileNotFoundException e) {

e.printStackTrace();

}finally {

try {

in.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

多线程

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

栈，堆，方法区

每一个线程都有一个栈空间而堆和方法区只有一个，被所有线程共享。

栈的特点如下：

1. 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)

2. JVM为每个线程创建一个栈，用于存放该线程执行方法的信息(实际参数、局部变量等)

3. 栈属于线程私有，不能实现线程间的共享!

4. 栈的存储特性是“先进后出，后进先出”

5. 栈是由系统自动分配，速度快!栈是一个连续的内存空间!

堆的特点如下：

1. 堆用于存储创建好的对象和数组(数组也是对象)

2. JVM只有一个堆，被所有线程共享

3. 堆是一个不连续的内存空间，分配灵活，速度慢!

方法区(又叫静态区)特点如下：

1. JVM只有一个方法区，被所有线程共享!

2. 方法区实际也是堆，只是用于存储类、常量相关的信息!

3. 用来存放程序中永远是不变或唯一的内容。(类信息【Class对象】、静态变量、字符串常量等)

线程的实现

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

package javaThread;

public class testThread {

public static void main(String[] args) {

test run=new test();

run.start();

for(int i=0;i<100;i++) {

System.out.println("主线程"+i);

}

class test extends Thread{

public void run(){

for(int i=0;i<100;i++) {

System.out.println("分支线程"+i);

}

package javaThread;

public class testrunnable {
	public static void main(String[] args) {
		Thread thread=new Thread(new myrunnable());
		thread.start();
		
			 for(int i=0;i<100;i++) {
				 System.out.println("主线程"+i);
			 }
	}
}
class myrunnable implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
	
			 for(int i=0;i<100;i++) {
				 System.out.println("分支线程"+i);
			 }
	}
}

线程的生命周期

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

Thread常用方法

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

package javaThread;

public class testrunnable {
	public static void main(String[] args) {
		Thread thread=new Thread(new myrunnable());
		System.out.println(thread.getName());
		thread.start();
		for(int i=0;i<10;i++) {
			System.out.println("主线程"+i);
		}
		
	}
}
class myrunnable implements Runnable{//如果是继承的Thread,用this或者super都可以获取名字

	@Override
	public void run() {
		// TODO Auto-generated method stub
			Thread currentThread=Thread.currentThread();
			 for(int i=0;i<10;i++) {
				 System.out.println("分支名字"+currentThread.getName()+"分支线程"+i);
			 }
	}
}

package javaThread;

public class testrunnable {
	public static void main(String[] args) {
		Thread thread=new Thread(new myrunnable());
		System.out.println(thread.getName());
		thread.start();
		for(int i=0;i<10;i++) {
			try {
				Thread.sleep(1000);//这段代码出现在哪哪sleep,跟对象没有关系
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("主线程"+i);
		}
		
	}
}
class myrunnable implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
			Thread currentThread=Thread.currentThread();
			 for(int i=0;i<10;i++) {
				 System.out.println("分支名字"+currentThread.getName()+"分支线程"+i);
			 }
	}
}

子类不能比父类抛出更多的异常

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

终止睡眠

可以用过interruput方法可以让sleep方法进入异常,然后就通过这个机制结束睡眠执行下面的代码

stop方法可以结束线程,

package javaThread;

public class testinterruputed {

public static void main(String[] args) {

thread td=new thread();

td.start();

try {

td.sleep(1000*5);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("helloworld");

td.interrupt();

}

class thread extends Thread{

@Override

public void run() {

// TODO Auto-generated method stub

try {

Thread.sleep(365*10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

}

System.out.println("-------->"+"end");

}

控制分支进程进行的时间

package javaThread;

public class testinterruputed {
	public static void main(String[] args) {
		myThread r=new myThread();
		Thread td=new Thread(r);
		td.start();
		try {
			Thread.sleep(5000);//当过了5s后,分支线程就不在执行了
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
		r.run=false;
	}
}
class myThread implements Runnable{

	boolean run=true;
	@Override
	public void run() {
		
		for(int i=0;i<10;i++) {
			if(run) {
				System.out.println(Thread.currentThread().getName()+"-------"+i);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			else {
				return;
			}
		}
		
	}
	
}

让一个线程停止(阻塞)

package javaThread;

public class testjoin {
	public static void main(String[] args) {
		Thread td=new Thread(new myrunnable());
		td.start();
		System.out.println("main begin");
		try {
			td.join();
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}System.out.println("main over");
	}
}
class myrunnable implements Runnable{
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+"i");
		}
	}
}

让td线程加入在main线程,main线程阻塞.当td线程结束后进行main线程

main begin

分支名字Thread-0分支线程0

分支名字Thread-0分支线程1

分支名字Thread-0分支线程2

分支名字Thread-0分支线程3

分支名字Thread-0分支线程4

分支名字Thread-0分支线程5

分支名字Thread-0分支线程6

分支名字Thread-0分支线程7

分支名字Thread-0分支线程8

分支名字Thread-0分支线程9

main over

线程安全

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

守护线程

用户线程结束,守护线程自动结束

守护线程里面是死循环

定时器

首先创建定时器对象,timer有个方法schedule,里面第一个参数放继承timerTask的类的对象,然后是程序第一次执行的时间,然后是间隔

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16


import java.sql.Date;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Timer;
import java.util.TimerTask;

public class testtimer {
	public static void main(String[] args) {
		Timer timer =new Timer();
		Date date=new Date(0);
		timer.schedule(new logTimeTask(),date,1000*10);
	}
}
class logTimeTask extends TimerTask{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("小球2333zzz");
	}
	
}

线程实现的第三种方式

去实现callable接口

优点,可以返回参数

缺点,会阻塞主线程的进行,调用get方法主线程需要等该线程结束后,get后面的代码才会执行

package javaThread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


public class testcallable {
	public static void main(String[] args) {
		FutureTask task =new FutureTask(new Callable() {
			public Object call() throws Exception {
				System.out.println("callable begin");
				Thread.sleep(1000*5);
				System.out.println("callable over");
				return new Object();
			}
			
		});
		Thread t =new Thread(task);
		t.start();
		try {
			task.get();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("over");
	}
}

生产者和消费者模式

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

package javaThread;

import java.util.ArrayList;
import java.util.List;
/*	
 * 测试wait 和notify  生产者和消费者
 */
public class testwaitandnotify {
	public static void main(String[] args) {
		List list=new ArrayList();
		Thread t1=new Thread(new poducer(list));
		Thread t2=new Thread(new consumer(list));
		t1.setName("生产者线程");
		t2.setName("消费者线程");
		t1.start();
		t2.start();		
		
	}
}

//生产
class poducer implements Runnable{

	
	private List list;
	public poducer(List list) {
		this.list=list;
	}
	public void run() {
		while (true) {
			synchronized (list) {
				if(list.size()>0) {
					try {
						list.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();		
					}
				}
				Object object=new Object();
				list.add(object);
				System.out.println(Thread.currentThread().getName()+"->>>"+object);
				list.notify();
			}
		}
		
	}
	
}
//消费
class consumer implements Runnable{
	private List list;
	public consumer(List list) {
		this.list=list;
	}
	@Override
	public void run() {
		while(true) {
			synchronized (list) {
				
				if(list.size()==0) {
					try {
						list.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				Object object=list.remove(0);
				System.out.println(Thread.currentThread().getName()+"->>>"+object);
				list.notify();
			}
		}


		
	}
	
}

反射

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

获取类的三种方法

第一种方式

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

第二种方式

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

第三种方式

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

通过class实例化对象

先获取类，然后用newInstance()方法创建这个类的实例对象

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

反射的灵活性

通过改配置文件,导致创建的对象不同

package reflect;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class test02 {
	public static void main(String[] args) {
		try {
			FileInputStream fis = new FileInputStream("d://c.txt");
			Properties pro = new Properties();
			try {
				pro.load(fis);
				String str = pro.getProperty("name");
				System.out.println(str);
				try {
					Class c1= Class.forName(str);
					Object obj;
					try {
						obj = c1.newInstance();
						System.out.println(obj);
					} catch (InstantiationException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IllegalAccessException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				} catch (ClassNotFoundException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				fis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

forName的执行过程

Class.forName 方法可以执行类中的 static 代码块,如果一个类只需执行代码块里的内容可以采用这种方法

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

通用方法或者文件的绝对路径

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

package reflect;

public class aboutpath {
	public static void main(String[] args) {
			String str = Thread.currentThread().getContextClassLoader().getResource("javaThread\testjoin.java").getPath();
			System.out.println(str);
	}
}

package reflect;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

/*
 * 运用反射,联合IO
 */
public class test03 {
	public static void main(String[] args) {
		
		String str = Thread.currentThread().getContextClassLoader().getResource("reflect/abc.properties").getPath();//得到地址
		FileInputStream fis=null;
		try {
			fis = new FileInputStream(str);
			Properties pro = new Properties();
			try {
				pro.load(fis);
				System.out.println(pro.getProperty("admin"));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				fis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

package reflect;

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/*
 * 以流的形式返回
 */
public class test04 {
	public static void main(String[] args) {
	InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("reflect/abc.properties");
	Properties pro = new Properties();
	try {
		pro.load(reader);
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	}
}

直接读取配置文件

资源绑定器

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

package reflect;

import java.util.ResourceBundle;

/*
 * test ResourceBundle
 */
public class test05 {
	public static void main(String[] args) {
		ResourceBundle bundle = ResourceBundle.getBundle("reflect/abc");
		String admin = bundle.getString("admin");
		System.out.println(admin);
	
		
	}
}

类加载器

NoClassDefFoundError异常主要是类加载不到

双亲委派机制,当这两个没有加载到,才会去应用类加载器去加载,为了安全

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_20,color_FFFFFF,t_70,g_se,x_16

拿类中的方法

package reflect;

import java.lang.reflect.*;
/*
 * test 获取类中的filed
 *
 */
public class test06 {
	public static void main(String[] args) throws ClassNotFoundException {
		//Class c1 = Class.forName("/xiaoqiuzzz/src/reflect/student.java");
		Class c2 = new student().getClass();
		Field [] fields = c2.getFields();//只能获取类中公共的属性
		Field [] fields1 = c2.getDeclaredFields();//这个可以获取所有的属性
		
		System.out.println(fields.length);
		System.out.println(fields1.length);
		for(Field fs:fields1) {
			System.out.println(Modifier.toString(fs.getModifiers())+"  "+fs.getType().getSimpleName()+"  "+fs.getName());
		}
	}
}

反编译类

public final  String{
	private final  value;
	private final  coder;
	private  hash;
	private  hashIsZero;
	private static final  serialVersionUID;
	static final  COMPACT_STRINGS;
	private static final  serialPersistentFields;
	public static final  CASE_INSENSITIVE_ORDER;
	static final  LATIN1;
	static final  UTF16;
}

package reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/*
 * 反编译类
 */
public class test07 {
	public static void main(String[] args) {
		try {
			StringBuilder sb = new StringBuilder();
			sb.append("[");
			Class c1 = Class.forName("java.lang.String");
			Field[] fields=c1.getDeclaredFields();//获得该class的所有属性 返回的是一个属性数组
			sb.append(Modifier.toString(c1.getModifiers())+"  "+c1.getSimpleName()+"\n");//getModifiers() 得到访问权限符,返回的是int 再调用modifier的toString方法可以把int转为String
			for(Field fs:fields) {
				sb.append("\t"+Modifier.toString(fs.getModifiers())+"  "+fs.getName()+"\n");
				
			}
			System.out.println(sb);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

通过反射设置变量属性值

package reflect;

import java.lang.reflect.Field;

/*
 * 给某个类中的属性赋值
 */
public class test08 {
	public static void main(String[] args) {
		/*
		 * student stu = new student(); stu.num=2233;
		 */

		Class c1 = (new student()).getClass();
		// Class c1 = Class.forName("java.lang.String");
		Object obj;
		try {
			obj = c1.newInstance();
			Field field;
			try {
				field = c1.getDeclaredField("num");// 得到属性名为num的属性
				field.set(obj, 2233);// 给该对象的属性赋
				System.out.println();
			} catch (NoSuchFieldException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

可变长度参数

只能放在最后有且只有一个

package reflect;

* 可变长度

public class test09 {

public static void main(String[] args) {

m("m1","m2");

}

static void m(String ... arg) {

System.out.println("m");

}

反编译类中method

package reflect;
/*
 * 反编译类中method
 */
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;


public class test10 {
	public static void main(String[] args)  throws Exception{
		Class c1 = (new String()).getClass();
		Method  [] methods =c1.getMethods();
		StringBuilder sb = new StringBuilder();
		sb.append(Modifier.toString(c1.getModifiers())+"  class  "+c1.getSimpleName()); 获得类名
		sb.append("{");
		sb.append("\n");
		
		for(Method ms:methods) {//遍历方法数组
			sb.append("\t"+Modifier.toString(ms.getModifiers())+"  "+ms.getReturnType().getSimpleName()+"  "+ms.getName());
			Class [] cs = ms.getParameterTypes();
			sb.append("(");	
			for(Class css:cs) {		
				sb.append(css.getSimpleName()+"  a"+",");													
			}	
			if(cs.length>0) {
				
				sb.deleteCharAt(sb.length()-1);				
			}
			sb.append(")");
			sb.append(";"+"\n");
		}
		sb.append("}");
		System.out.println(sb);
	}
}

public final  class  String{
	public  boolean  equals(Object  a);
	public  int  length();
	public  String  toString();
	public  int  hashCode();
	public  void  getChars(int  a,int  a,char[]  a,int  a);
	public volatile  int  compareTo(Object  a);
	public  int  compareTo(String  a);
	public  int  indexOf(int  a,int  a);
	public  int  indexOf(String  a);
	public  int  indexOf(String  a,int  a);
	public  int  indexOf(int  a);
	public static  String  valueOf(char[]  a);
	public static  String  valueOf(Object  a);
	public static  String  valueOf(long  a);
	public static  String  valueOf(char[]  a,int  a,int  a);
	public static  String  valueOf(int  a);
	public static  String  valueOf(char  a);
	public static  String  valueOf(double  a);
	public static  String  valueOf(float  a);
	public static  String  valueOf(boolean  a);
	public  char  charAt(int  a);
	public  int  codePointAt(int  a);
	public  int  codePointBefore(int  a);
	public  int  codePointCount(int  a,int  a);
	public  int  offsetByCodePoints(int  a,int  a);
	public  byte[]  getBytes(String  a);
	public  byte[]  getBytes();
	public  void  getBytes(int  a,int  a,byte[]  a,int  a);
	public  byte[]  getBytes(Charset  a);
	public  boolean  contentEquals(StringBuffer  a);
	public  boolean  contentEquals(CharSequence  a);
	public  boolean  regionMatches(int  a,String  a,int  a,int  a);
	public  boolean  regionMatches(boolean  a,int  a,String  a,int  a,int  a);
	public  boolean  startsWith(String  a,int  a);
	public  boolean  startsWith(String  a);
	public  int  lastIndexOf(String  a);
	public  int  lastIndexOf(int  a);
	public  int  lastIndexOf(int  a,int  a);
	public  int  lastIndexOf(String  a,int  a);
	public  String  substring(int  a,int  a);
	public  String  substring(int  a);
	public  boolean  isEmpty();
	public  String  replace(char  a,char  a);
	public  String  replace(CharSequence  a,CharSequence  a);
	public  boolean  matches(String  a);
	public  String  replaceFirst(String  a,String  a);
	public  String  replaceAll(String  a,String  a);
	public  String[]  split(String  a,int  a);
	public  String[]  split(String  a);
	public  String  toLowerCase();
	public  String  toLowerCase(Locale  a);
	public  String  toUpperCase();
	public  String  toUpperCase(Locale  a);
	public  String  trim();
	public  String  strip();
	public  String  stripLeading();
	public  String  stripTrailing();
	public  Stream  lines();
	public  String  repeat(int  a);
	public  boolean  isBlank();
	public  char[]  toCharArray();
	public static transient  String  format(Locale  a,String  a,Object[]  a);
	public static transient  String  format(String  a,Object[]  a);
	public  String  resolveConstantDesc(Lookup  a);
	public volatile  Object  resolveConstantDesc(Lookup  a);
	public  IntStream  codePoints();
	public  boolean  equalsIgnoreCase(String  a);
	public  int  compareToIgnoreCase(String  a);
	public  boolean  endsWith(String  a);
	public  CharSequence  subSequence(int  a,int  a);
	public  String  concat(String  a);
	public  boolean  contains(CharSequence  a);
	public static transient  String  join(CharSequence  a,CharSequence[]  a);
	public static  String  join(CharSequence  a,Iterable  a);
	public  String  indent(int  a);
	public  String  stripIndent();
	public  String  translateEscapes();
	public  IntStream  chars();
	public  Object  transform(Function  a);
	public transient  String  formatted(Object[]  a);
	public static  String  copyValueOf(char[]  a,int  a,int  a);
	public static  String  copyValueOf(char[]  a);
	public native  String  intern();
	public  Optional  describeConstable();
	public final native  void  wait(long  a);
	public final  void  wait(long  a,int  a);
	public final  void  wait();
	public final native  Class  getClass();
	public final native  void  notify();
	public final native  void  notifyAll();
}

通过反射调用方法

package reflect;

import java.lang.reflect.Method;

/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 * test 通过反射拿方法
 */
public class test11 {
	public static void main(String[] args) throws Exception {
		Class c1 = (new student()).getClass();
		Object obj = c1.newInstance();
		Method m1 = c1.getDeclaredMethod("student", int.class);//拿到方法
		m1.invoke(obj, 1);//方法传对象,后面是实参列表,返回值
	}
}

、

利用反射,反编译类的构造方法

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/*
 * 利用反射,反编译类的构造方法
 * public class student {
 */
public class test12 {
	public static void main(String[] args) throws Exception {
		Class c1 = Class.forName("reflect.student");
		StringBuilder sb = new StringBuilder();
		sb.append(Modifier.toString(c1.getModifiers()));
		sb.append(" ");
		sb.append("class");
		sb.append(" ");
		sb.append(c1.getSimpleName());
		sb.append("{");
		sb.append("\n");
		Constructor [] constructors =c1.getDeclaredConstructors();
		for(Constructor cs:constructors) {
			sb.append("\t");
			sb.append(Modifier.toString(cs.getModifiers()));
			sb.append(" ");
			sb.append(" ");
			sb.append(c1.getSimpleName());
			sb.append("(");
			Class [] css = cs.getParameterTypes();
			for(Class csss:css) {
				sb.append(csss.getSimpleName()+" a"+",");
			}
			if(css.length>0) {
				sb.deleteCharAt(sb.length()-1);
			}				
			sb.append(")");
			sb.append("{");
			sb.append("\n");
			sb.append("\t}");
			sb.append("\n");
		}
		System.out.println(sb);
	}
}

通过反射 new有参数的构造方法

package reflect;

import java.lang.reflect.Constructor;

/*
 * 通过反射 new有参数的构造方法
 */
public class test13 {
	public static void main(String[] args)  throws Exception{
		Class c1 = Class.forName("reflect.student");
		Object obj = c1.newInstance();//调用无参的构造方法
		/*
		 * 调用有参的构造方法
		 */
		Constructor constructor = c1.getDeclaredConstructor(int.class);
		constructor.newInstance(1);
		
	}
}

垃圾回收机制

我们将对象分为三种状态：年轻代、年老代、持久代。JVM将堆内存划分为 Eden、Survivor 和 Tenured/Old 空间。

1. 年轻代

所有新生成的对象首先都是放在Eden区。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象，对应的是Minor GC，每次 Minor GC 会清理年轻代的内存，算法采用效率较高的复制算法，频繁的操作，但是会浪费内存空间。当“年轻代”区域存放满对象后，就将对象存放到年老代区域。

2. 年老代

在年轻代中经历了N(默认15)次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。年老代对象越来越多，我们就需要启动Major GC和Full GC(全量回收)，来一次大扫除，全面清理年轻代区域和年老代区域。

3. 持久代

用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响。

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWFVOfk1MRg==,size_19,color_FFFFFF,t_70,g_se,x_16

1、新创建的对象，绝大多数都会存储在Eden中，

2、当Eden满了（达到一定比例）不能创建新对象，则触发垃圾回收（GC），将无用对象清理掉，

然后剩余对象复制到某个Survivor中，如S1，同时清空Eden区

3、当Eden区再次满了，会将S1中的不能清空的对象存到另外一个Survivor中，如S2，

同时将Eden区中的不能清空的对象，也复制到S1中，保证Eden和S1，均被清空。

4、重复多次(默认15次)Survivor中没有被清理的对象，则会复制到老年代Old(Tenured)区中，

5、当Old区满了，则会触发一个一次完整地垃圾回收（FullGC），之前新生代的垃圾回收称为（minorGC）

XUN~MLF

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java笔记

面向对象基础封装 1. 一般使用private访问权限。2. 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(注意：boolean变量的get方法是is开头!)。3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。继承extend关键字继承子类继承父类在我们编程中，如果新定义一个Student类，发现已经有Person类包含了我们需要的属性和方法，那么Stu......
复制链接

扫一扫