一个demo学会java
2024-05-11 02:33:09
全栈工程师开发手册 （作者：栾鹏）
快捷链接：
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){ //枚举类型，可作为变量，相当于constprintf("设置内部类性别");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+"清理函数");}@Overridepublic 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的。属于嵌套类，接口内部类实现接口函数，为了创建接口所有不同实现的公共代码@Overridepublic 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; //设置泛型，也可以使用原始基类Objectpublic 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();}@Overridepublic void init2(String name) { //泛型接口printf("派生类实现接口2初始化函数");}@Overridepublic 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，不可变大小数组，作为参数生成可变大小的ArrayListList<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>(); //或者是SortedMapmap.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，replaceFirstoutStr=outStr.substring(3)+outStr.length(); //substring取子字符串，length字符串长度，+重载连接字符串和整型if(outStr.indexOf("shi")<0) //indexof插叙子字符串所在位置，不存在返回-1，其他字符串相关操作较多printf("字符串\""+outStr+"\"不存在指定子字符串");outStr = "luanpeng luanpeng";outStr=outStr.split(" ")[0]; //split分割字符串，返回数组，读取第一个数组赋值给outstrPattern 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.lengthArrays.sort(all2); //调用重写的比较函数执行数组排序int location = Arrays.binarySearch(all2, student1); //在数组中查找，不存在返回-1if(!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() 方法的物件不相同，会有 IllegalMonitorStateExceptionprintf("同步控制块恢复继续执行"); //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，在向上转型为studentprintf("接口类型："+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必须在同步控制方法(块)中调用 }}}}一个demo学会java相关推荐
- 一个Demo学会用Android兼容包新控件
2019独角兽企业重金招聘Python工程师标准>>> 前言 伟大的Google为Android推出了一系列的兼容包,最新的就是Design Support Library了,这里我 ...
- 一个demo学会jquery mobile
全栈工程师开发手册 (作者:栾鹏) jQuery Mobile事件全解 jQuery Mobile 所有class选项 jQuery Mobile 所有data-*选项 一个demo学会jquery ...
- 一个demo学会css
全栈工程师开发手册 (作者:栾鹏) 一个demo学会css css选择器全解 css操作语法全解 学习了css权威指南这本书,自己喜欢边学边总结边写demo,所以写了这篇文章,包含了大部分的css编程 ...
- 一个demo学会c#
全栈工程师开发手册 (作者:栾鹏) c#教程全解 学习了c#4.5高级编程这本书,自己喜欢边学边总结边写demo,所以写了这篇文章,包含了大部分的c#编程知识.让你一个demo掌握c#编程,如果有问题 ...
- 一个demo学会js
全栈工程师开发手册 (作者:栾鹏) 快捷链接: js系列教程1-数组操作全解 js系列教程2-对象和属性全解 js系列教程3-字符串和正则全解 js系列教程4-函数与参数全解 js系列教程5-容器和算 ...
- 一个demo学会c++编程
这篇文章包含了c++的基本知识,起始并不适合0基础程序员.如果你只是对c++的相关知识了解的没有那么全面,或者你或多或少遗忘了一部分基础知识,那这篇文章再适合你不过了.如果有问题可以留言. 此demo ...
- java demo在哪里下载_[Java教程]Java学习 （一）、下载，配置环境变量，第一个demo...
[Java教程]Java学习 (一).下载,配置环境变量,第一个demo 0 2016-03-01 22:00:18 一.在 http://www.oracle.com 下载java JDK 安装到自 ...
- java struts2 demo,Struts2第一个Demo求指导
Struts2第一个Demo求指点 本人初学Struts2,按照书上的示例自己写了一个Demo.配置文件及路径如下: login.jsp: pageEncoding="UTF-8" ...
- 从一个OutOfMemoryError 学会了分析Java内存泄漏问题
从一个OutOfMemoryError 学会了分析Java内存泄漏问题 以前都是好好的,最近出现了 oom. 问题 开始是: java.lang.OutOfMemoryError: Java heap ...
最新文章
- Linux如何关机与关机命令祥解
- oracle 五种索引创建
- jstat的小伙伴:找出system.gc的调用的小工具
- Django(part45)--forms模块
- PJzhang:英国通信总部GCHQ开源产品-网络瑞士军刀CyberChef
- Android之AIDL使用详解
- for循环python爬虫_python爬虫 for循环只出来一条
- Jenkins发布PHP项目之一自动化部署
- poj2513Colored Sticks(无向图判欧拉路、回路+trie树）
- go和python组合开发_Go+Python双语言混合开发
- Visual Studio Node.js工具1.1
- C#中实现拖拽功能，补全中
- 最佳 Web 编程语言都有哪些？
- Python实现向量自回归（VAR）模型——完整步骤
- Vue删除表格中的某一行数据
- BZOJ2001 HNOI2010 城市建设
- 星际迷航7：未来之城
- zotero+PDF expert+坚果云+iPad
- Arduino servo库函数说明（舵机函数库）
- 无源RFID固定资产管理解决方案