全栈工程师开发手册 （作者：栾鹏）

快捷链接：
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必须在同步控制方法(块)中调用 
            }
        }

    }

}