全栈工程师开发手册 （作者：栾鹏）
快捷链接：
java开发大全
这篇demo较长，包含了java基本的内容，若不是出于校验自己java基础能力的朋友，建议按照上面的链接分章节学习。本demo包含了java的数组、对象、对象属性、接口，面向对象，重载，多态、封装、字符串、正则表达式、函数、参数、容器、算法、线程、异常等方面的知识，可以全面检验你的java学习效果。
此demo包括文件：测试文件index.java和接口interface1.java、接口interface2.java、基类Student.java、派生类Monitor.java文件
Student.java实现了一个java基类
//static int var=10; //java禁止使用全局数据
//一个包可以包含多个类，类默认访问修饰符为包访问，每个文件只能有一个public类，类只能是包访问或public
public class Student implements Comparable<Student>{ //implements继承接口关键字，Comparable<Student>类比较接口
public static void main(String[] args) {} //每个类中都可以有一个main函数，用于调试
public Student(){ //不接受任何参数的叫默认构造器，没定义构造器，编译器会自动创建
this("student",12); //通过this仅能调用一个构造器，必须将构造器调用置于起始处
getname(); //构造器会调用成员函数和数据，所有在初始化构造器前会初始化成员数据
printf("基类无参构造器");
}
public Student(String name,int age){ //有参构造器
this.age = age;this.name = name;
printf("基类有参构造器"+name);
}
public Student(String name,Character...args){ //可变参数列表args是一个参数数组，重载方法中应只有一个可变参数列表，编译器
this.name = name;
printf("基类变参构造器"); //args[0]表示变参中的第一个参数
}
public void setname(String name){this.name=name;printf("基类设置名称:"+name);} //this表示对当前对象的引用
public String getname(){printf("基类获取名称"+name);return name;} //使用public方法实现对private数据的控制，保证类内数据安全
void setage(int age){printf("基类设置名称"+age);this.age=age;}
private int getage(){return age;} //private属于final方法
static long time=10; //所有类型数据均可在定义时初始化，数据均有默认值，所有类的静态数据最先初始化
private int age=0; //private外部不可以访问
String name = "student"; //不加访问修饰符，默认为包访问
public enum allsex{man,woman} //枚举类型，等价于类内组合class allsex{man，woman}，枚举类型可以有构造函数，有几个枚举实例就调用几次构造函数
class Sextype{ //内部类，在内部类声明为static时为嵌套类，嵌套类不属于对象，而属于类名
public void setsex(allsex sextype){ //枚举类型，可作为变量，相当于const
printf("设置内部类性别");
switch (sextype) { //枚举类型用在switch中，用于限制参数的可选项
case man:sexstring="boy";break;
case woman:sexstring="girl";break;
default:break;
}
}
public Student getStudent(){
sexstring+=name; //内部类，嵌套类可以任意访问外部类数据，无论嵌套多少层
return Student.this; //返回外部类引用，当内部类是static时，内部类不存在对外部类的引用
}
private String sexstring;
}
public static <T> void printf(T str) //泛型方法，
{
System.out.println(str.toString()); //System.out.println打印输出
}
//重写equals虚函数，java中除了static和final都是虚函数，（private属于final方法）
public final boolean equals(Student another){ //final标记的函数不能被派生类重写
printf("比较了两个基类");
if(this.age==another.age && this.name==another.name)
return true;
return false;
}
//垃圾回收器准备收回对象占用内存时执行，java虚拟机并未面临内存耗尽的情形不会浪费时间执行垃圾回收，（垃圾回收：停止-复制，标记-清扫）
public void finalize(){
printf("基类对象"+name+"内存被收回");
}
void dispose(){
printf("基类对象"+name+"清理函数");
}
@Override
public int compareTo(Student arg0){ //要实现排序，必须要实现的比较接口
return age<arg0.age?-1:(age==arg0.age?0:1); //返回-1表示小于，0不表示等于，1表示大于
}
}
//一个文件可以包含多个类，但是文件名必须和public类名相同，否则只能使用默认的包访问权限
abstract class Teacher{ //abstract关键字表示为抽象类
abstract void setname(); //abstract抽象方法
public String getname(){return name;} //使用public方法实现对private数据的控制，保证类内数据安全
String name="teacher"; //不加修饰符默认为报访问
}
Interface1.java定义了一个接口
public interface Interface1{ //interface接口声明，完全抽象类
abstract void init1(); //abstract抽象方法，接口自动是public的，接口中，不能定义函数体，只能声明，abstract可以不写
class manclass implements Interface1{ //接口内部类自动是public和static的。属于嵌套类，接口内部类实现接口函数，为了创建接口所有不同实现的公共代码
@Override
public void init1() {
System.out.println("接口内部类，实现公共代码");
}
}
}Interface2.java实现了一个派生接口
public interface Interface2<A> extends Interface1{ //接口也支持继承，接口可以多继承，extends后可以有多个子接口，接口可以嵌套在类中<A>泛型接口
abstract void init2(A name); //abstract抽象方法，接口自动是public的
void init1(); //接口重写了函数
int DEFAULT_GAE =12; //接口中的任何域都是自动的static和final的，static final使用大写风格
String DEFAULT_NAME ="name";
}Monitor.java文件实现了一个继承自Student，并继承自Interface1和Interface2的派生类
import java.util.EnumSet;
final class Monitor<T> extends Student implements Interface1,Interface2<String>{ //<>泛型，extends继承类，implements继承接口，final终态类，不能再被继承
Monitor(){ //派生类无参构造器
super("monitor");printf("派生类无参构造器"); //关键字super显示调用基类构造器，printf调用基类函数
} //构造前会调用父类无参构造函数，如果父类没有构造函数，则会默认生成。如果有构造函数（无参），则会调用无参构造函数。如果只有有参构造函数，必须显示调用
Monitor(int age){printf("派生类有参构造器");} //派生类有参构造器，
static Student mysStudent = new Student("monitor",12); //静态数据初始化只在调用时刻才会进行，在第一次创建类对象或者第一次访问静态数据时最先被初始化
final static Student student1; //final用于，保持引用不变，对象可变
static Student student2;
static{ //静态块，仅执行一次，对象创建或静态数据访问时执行，仅定义对象的话不执行
student1 = new Student();
student2 = new Student();
printf("派生类静态块执行");
}
//重写函数的返回类型可以是基类型的派生类型，访问权限必须大于原访问权限，子类抛出异常小于等于父类方法抛出异常
public String getname(){ //重写虚函数不需要关键字，因为在java中除了static和final都是虚函数（private属于final方法）
printf("派生类获取名称:"+name); //
//name = super.name+"的派生"; //super代表基类
return name;
}
public int getage(){return 11;} //private不能重写，派生类重名，覆盖了基类私有方法
String name="monitor"; //同名变量和静态函数，不能动态绑定到基类引用上，和基类数据存储在不同的区域
String task ="帮助老师管理班级";
private T a; //设置泛型，也可以使用原始基类Object
public T getT(){return a;} //设置泛型函数，泛型会自动擦除传递过来的对象的类信息
public void setT(T a){this.a=a;printf("派生类设置泛型变量");}
public enum Group{ //枚举类型，函数枚举
SHUXUE{void action(){printf("数学");}},
YINGYU{void action(){printf("英语");}},
YUNWEN{void action(){printf("语文");}};
abstract void action(); //每个枚举元素要实现的函数
}
EnumSet<Group> allgroup=EnumSet.of(Group.SHUXUE,Group.YINGYU); //EnumSet枚举集合，EnumMap枚举映射
public void printfgroup(){
for(Group g:allgroup)
g.action();
}
@Override
public void init2(String name) { //泛型接口
printf("派生类实现接口2初始化函数");
}
@Override
public void init1() {
printf("派生类实现接口1初始化函数，或接口2初始化函数");
}
}
index.java文件实现了所有知识点的测试。
import java.io.ByteArrayInputStream;
import java.lang.reflect.Executable;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.SortedMap;
import java.util.Stack;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.prefs.Preferences;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.List;
import javax.naming.InitialContext;
public class index implements Runnable{ //Runnable多线程，任务接口，如果类不是抽象类，必须实现接口函数，可以创建Thread的派生类，Callable<>有返回值的线程接口
static String stringtemp; //类内共享变量
public static void main(String[] args)
{
printf("===========基类相关操作==============");
Preferences prefs=Preferences.userNodeForPackage(index.class); //Preferences只能存放基本类型和字符串的键值对
prefs.put("default_name", "student"); //Preferences用作属性配置
prefs.putInt("default_age", 12);
Student.time+=Student.time<<2+0x21^26; //静态数据，可以铜鼓类型访问，<<位左移动，低位补0，^按位异或，0X表示16进制
Student student1=new Student(); //所有的对象都必须通过new来创建，基本数据类型可以定义创建
student1.name = student1.name+1; //访问类内数据，字符串+重载
student1.setage(-2*-6); //通过类内函数访问类数据，一元减号用于转变数据的符号
Student.Sextype student1_sextype = student1.new Sextype(); //创建内部类，必须通过外部类变量new构造
student1_sextype.setsex(Student.allsex.man); //调用枚举类型
Student student2=student1; //仅是复制引用，两个变量名指向同一块内存
if(student1==student2) //==和!=只是比较对象的引用，不比较对象内容
if(student1.equals(student2)) //对象的比较实用equals，比较对象的实际内容，但是定义类的equals默认行为还是比较引用，要在自定义类中重写equals函数
//if(1) //非布尔值不能用在逻辑表达式中
printf("创建了两个相同的类引用");
Field[] fileds = student1.getClass().getDeclaredFields(); //反射获取对象类的属性
try{ //尝试运行代码
for(Field field:fileds){
if(!field.isAccessible())
field.setAccessible(true); //设置对象属性可读取
Object obj=field.get(student2); //从实例对象中获取字段属性的值，（私有的没法获取，数值或对象统一为对象，没有值返回的）
}
}
catch (Exception e) {
printf("错误内容："+e.toString()); //catch函数在try出错时调用，exception是所有异常类的基类，异常类可以捕获派生类异常
e.printStackTrace(System.out); //堆轨迹，出错原因和位置
//throw e; //抛出异常，停止运行
}
finally{ //finally函数总要执行
printf("finally函数总要执行");
}
printf("===========派生类相关操作==============");
Monitor monitor1 =new Monitor(Interface2.DEFAULT_GAE); //基类构造函数（绑定后函数），派生类成员，派生类构造函数，接口中的域相当于枚举常量
monitor1.name = "monitor1"; //基类静态-派生类静态-基类私有-基类构造-派生类私有-派生类构造。函数在构造前已经存在
printf("===========11111111111111111==============");
sprintf(monitor1,null); //可变参数，null为参数为空
sprintf(monitor1); //传递实现接口的类，向上转型为接口，实现函数回调
printf("===========2222222222222222==============");
Student student3 = new Monitor(); //基类引用，派生类对象
student3.getname(); //调用引用动态绑定的方法
((Monitor)student3).getage(); //向下转型成功，getage为派生类的公共函数
printf("===========接口相关操作==============");
Interface1 interface1=new Monitor(); //向上转型，interface1是基类，普通类，接口，无所谓，实现接口的类（包括内部类），都可以向上转型转化为接口
interface1.init1(); //调用动态绑定的函数
interface1=getInterface1(); //通过匿名内部类实现接口函数的实现
interface1.init1();
printf("===========容器相关操作==============");
//Collection接口，独立元素序列（List接口，Set接口，Queue接口）
//List接口，插入顺序保存数组，（ArrayList数组，LinkedList链表）
//Set接口，不能重复元素，（HashSet散列函数，TreeSet红黑树，LinkedHashList链表下的散列）
//Queue接口，先进先出队列，（LinkedList链表，PriorityQueue优先级队列）
//Map接口，键值对（字典，映射），HashMap（快速访问），TreeMap（键值排序），LinkedHashMap（保持元素插入顺序，通过散列提供快速访问）
//list整体赋值,Arrays.asList方法返回的ArrayList是继承自AbstractList，不可变大小数组，作为参数生成可变大小的ArrayList
List<String> allname = new ArrayList<String>(Arrays.asList("小明","小红","晓刚","小刘")); //ArrayList实现向上转型为list接口，动态连续数组，<>内的对象类型可以不写，不能是基本，<>内类型擦除，编译器无法获取，
allname.set(2,"小刚"); //list元素赋值
if(!allname.contains("小王")) //元素包含
allname.add("小王"); //添加元素
allname.remove(0); //删除元素
stringtemp=allname.get(1); //读取元素
Iterator<String> iterator = allname.iterator(); //集合的迭代器，next为首个元素的迭代器，ListIterator迭代器更厉害
iterator.next(); //指向第一个元素
iterator.remove(); //删除迭代器的对应元素，删除可以继续使用此元素的迭代器了
while(iterator.hasNext()) //迭代器是否有一下个元素
printf(iterator.next()); //获取序列的下一个元素
Stack<String> allname1 = new Stack<String>(); //stack先进后出堆栈，各种队列和栈基于LinkedList链表实现
LinkedList<String> allname2 = new LinkedList<String>(); //双端队列，队列
Set<String> allname3 = new HashSet<String>(); //不重复集合
Map<String,String> map = new HashMap<String,String>(); //或者是SortedMap
map.put("小明", "12");
Object x_name = map.get("小明");
Iterator iterator1 = map.entrySet().iterator(); //Map对象有keySet方法，返回key的Set集合，values()返回Collection集合，entrySet函数返回集合，元素类型为Map.Entry（一个<key,vlaue>的泛型接口）
Map.Entry entry = (Map.Entry)iterator1.next();
Object key=entry.getKey();
Iterator iterator2 = map.keySet().iterator();
key=iterator2.next();
x_name=map.get(key);
for(Map.Entry<String, String> entry2:map.entrySet()){
entry2.getKey();
entry2.getValue();
}
List<Map.Entry<String, String>> info_student= new ArrayList<Map.Entry<String,String>>(map.entrySet());
printf("===========字符串相关操作==============");
StringBuilder sb = new StringBuilder(); //StringBuilder包括insert，replace，substring，reverse，append，tostring，delete方法
sb.append(String.format("这里%s字符串相关操作", "shi")); //string.format()格式化函数，内部创建formatter类设置字符串格式
String outStr=sb.toString().replace("shi", "是"); //string是不可变量，取值变化是生成新的类，replace替换，repalceAll，replaceFirst
outStr=outStr.substring(3)+outStr.length(); //substring取子字符串，length字符串长度，+重载连接字符串和整型
if(outStr.indexOf("shi")<0) //indexof插叙子字符串所在位置，不存在返回-1，其他字符串相关操作较多
printf("字符串\""+outStr+"\"不存在指定子字符串");
outStr = "luanpeng luanpeng";
outStr=outStr.split(" ")[0]; //split分割字符串，返回数组，读取第一个数组赋值给outstr
Pattern pattern = Pattern.compile("lu[a-n]"); //创建正则法则，将正则字符串编译成正则表达式
Matcher matcher = pattern.matcher(outStr); //创建匹配器
while (matcher.find()) //依次查询是否存在匹配项
printf(matcher.group()+"起点"+matcher.start()+"终点"+matcher.end());//group匹配值，start起始位置，end结束位置
matcher.reset("luan"); //将正则法则重新使用到新的字符串上
Integer nn= Integer.parseInt("123"); //字符串转化为整型
String str = String.valueOf(nn); //整型转化为字符串
char[] temparr ={'a','b'}; //字符数组
str=new String(temparr); //字符数组转化为字符串
temparr = str.toCharArray(); //字符串转化为字符数组
byte[] temp1=str.getBytes(); //字符串转化为字节数组
StringBuffer buf=new StringBuffer(); //字符串的StringBuffer表示，
buf.append(str+"\r\n"); //StringBuffer可以追加
buf.deleteCharAt(buf.length()-1); //StringBuffer与StringBuilder有很多类似功能，这里不一一列举
printf("===========数组相关操作==============");
Random random =new Random(17); //随机数
int farrat[] =new int[10]; //数组创建int var[] 和int[] var等效
for(int x:farrat){ //for语句的遍历形式
x=random.nextInt(); //读取伪随机序列
}
Student[] all1 = new Student[7];
Student[] all2 = new Student[10];
Arrays.fill(all1, student1); //数组填充，填充对象时，只是填充了引用
Arrays.fill(all2, student3);
System.arraycopy(all1, 0, all2, 2, all1.length); //ii第0个开始复制到jj第2个开始，长度ii.length
Arrays.sort(all2); //调用重写的比较函数执行数组排序
int location = Arrays.binarySearch(all2, student1); //在数组中查找，不存在返回-1
if(!Arrays.equals(all1, all2)) //数组相等 个数和每个元素均相等
printf(Arrays.toString(all2));
Monitor<Student> monitor2 = new Monitor<Student>(); //包含泛型的类型调用，也可以不使用泛型创建对象
monitor2.setT(student1);
//注解
//数据流
//序列化
printf("===========线程相关操作==============");
new index().run(); //在主线程中调用线程类中的run函数，不是多线程，只是调用函数
Thread thread=new Thread(new index()); //调用子函数，执行线程类中run函数，thread构造参数为runnable接口，线程类向上转型为接口
thread.setDaemon(true); //设置线程为后台线程，否则为非后台线程
thread.start(); //线程启动,thread.join()等待线程执行完毕
thread.interrupt(); //线程中断，会在线程运行至阻塞时中断，弹出中断异常
ExecutorService exec= Executors.newCachedThreadPool(); //创建线程池管理器
exec.execute(new index()); //向线程管理器中添加一个线程实现接口，自动执行
exec.submit(new index()); //调用有返回的线程
exec.shutdown(); //关闭线程管理器，线程池继续运行
synchronized (stringtemp) { //对象锁控制同步块，需要锁才能进入
try {
printf("进入同步块，释放对象锁"); //对象释放锁，进入等待锁定池，当接收到对象notify、notifyAll后进入对象锁定池，准备重新获取对象继续执行
stringtemp.wait(); //wait，会抛出异常，synchronized 的目标与 wait() 方法的物件不相同，会有 IllegalMonitorStateException
printf("同步控制块恢复继续执行"); //java里面有专门捕获异常的try catch。异常是向上依次抛出的，如果在某一层被捕获就不会退出。如果一直没有被捕获直到抛出到系统层就是退出。
} catch (InterruptedException e) { //中断异常类，会在线程运行至阻塞时中断，弹出中断异常
e.printStackTrace();
}
}
printf("结束");
printf(Student.allsex.woman);
}
public static void sprintf(Student student,Object[] args) //基类参数允许传递派生类引用，//Object[] args用于可变参数列表，可以无参调用
{
student.setname("student1"); //调用引用动态绑定的方法-基类函数，修改的是基类属性
student.getname(); //调用引用动态绑定的方法-派生类重写的虚函数，获取的是派生类属性
}
public static void sprintf(Interface1 interface1) //接口参数允许传递接口类为参数，sprintf函数名相同实现重载
{
if(interface1 instanceof Monitor){ //判断引用的类型是否是指定类型
Student student=(Student)interface1; //先向下转型为monitor，在向上转型为student
printf("接口类型："+interface1.getClass().getName()); //获取引用指向的对象类型
student.getname(); //调用动态绑定的方法
}
interface1.init1(); //接口相当于纯抽象类，调用动态绑定的方法
}
public static Interface1 getInterface1() { //不用创建实现接口的类，而直接实现接口的方法的定义
return new Interface1(){ //匿名内部类，可以传递参数
public void init1(){
System.out.println("通过匿名内部类实现向上转型为接口");
}
};
}
public static synchronized <T> void printf(T str) //泛型方法，synchronized同步函数，检查锁，获取锁，执行代码，释放锁
{
System.out.println(str.toString());
}
int num=0;
@Override //多线程，任务接口，只有调用线程接口才会执行
public void run(){ //线程接口重载函数
Thread.currentThread().setPriority(++num); //设置线程优先级，优先级不会导致死锁，优先级低的执行频率低
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //设置日期格式
printf(df.format(new Date())+"执行了线程"+num); // new Date()为获取当前系统时间
Lock lock = new ReentrantLock(); //创建线程锁
lock.lock(); //锁定资源
try {
Thread.yield(); //线程让步，不释放锁，yield不能设置时间，只能控制同优先级
Thread.sleep(1000); //sleep可以使低优先级的线程得到执行的机会，线程睡眠，不释放锁，保持监控，自动恢复，sleep不操作锁，所以可以在非同步控制方法(块)中调用
} catch (Exception e) {
printf(df.format(new Date())+"线程错误"+e.toString());
}
finally{
lock.unlock(); //释放锁
printf(df.format(new Date())+"释放锁");
synchronized (stringtemp) { //对象锁控制同步块，需要锁才能进入
stringtemp.notifyAll(); //stringtemp调用线程恢复通知所有等待线程，wait、notify、notifyAll必须在同步控制方法(块)中调用
}
}
}
}