介绍两种核心机制1.JAVA虚拟机JAVA Virtual MaachineJVM 一次编写处处运行2.垃圾回收机制Garbage CollectionGC 自动进行面向对象的三大特征:封装 (Encapsulation)继承 (Inheritance)多态 (Polymorphism)数据类型8种基本整型byte1字节-128- 127short2字节int4字节long8字节浮点型float 4字节7位有效数字 float 1.22fdouble 8字节16位有效数字 double 1.22字符char(16位)’‘布尔类型boolean在true和false中不能用0和非0表示无null引用类型String可以使用null作为值会存储在字符串常量池中String s0 “hello”String s1“hello”内存中只会存在一个hello与C区分备注byte short char之间不会相互转换只会先转换成int类型再进行计算对象的产生Person m new Person();soutm soutm.toString//地址需要override当一个对象被创建时会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型.成员变量类型初始值byte0short0int0long0Lfloat0.0Fdouble0.0Dchar‘\u0000’(表示为空)booleanfalse引用类型nullInstanceo操作符x instanceof A检验x是否为类A的对象返回值为boolean型。要求x所属的类与类A必须是子类和父类的关系否则编译错误。如果x属于类A的子类Bx instanceof A值也为true。Object 类Object类是所有Java类的根父类如果在类的声明中未使用extends关键字指明其父类则默认父类为Object类public class Person { … }等价于public class Person extends Object {…}例method(Object obj){…} //可以接收任何类作为其参数Person onew Person();method(o);Object类中的主要方法NO.方法名称类型描述1public Object()构造构造方法2public boolean equals(Object obj)普通对象比较3public int hashCode()普通取得Hash码4public String toString()普通对象打印时调用打印对象地址对Java对象的强制类型转换称为造型对Java对象的强制类型转换称为造型从子类到父类的类型转换可以自动进行从父类到子类的类型转换必须通过造型(强制类型转换)实现Person p new Person Student s Studentp无继承关系的引用类型间的转换是非法的操作符与equals方法equals()所有类都继承了Object也就获得了equals()方法。还可以重写。只能比较引用类型其作用与“”相同,比较是否指向同一个对象。格式:obj1.equals(obj2)特例当用equals()方法进行比较时对类File、String、Date及包装类Wrapper Class来说是比较类型及内容而不考虑引用的是否是同一个对象原因在这些类中重写了Object类的equals()方法。包装类(Wrapper)基本数据类型包装类booleanBooleanbyteByteshortShortintIntegerlongLongcharCharacterfloatFloatdoubleDouble字符串转换成基本数据类型通过包装类的构造器实现主要为了基本数据类型与字符串直接的转化int i Integer.parseInt(123); //字符串转整型 String intstr String.valueof(i); //整型转字符串 int i new Integer(“12”);通过包装类的parseXxx(String s)静态方法Float f Float.parseFloat(“12.1”); //字符串转换成float类型基本数据类型转换成字符串调用字符串重载的valueOf()方法String fstr String.valueOf(2.34f);更直接的方式String intStr 5 “”匿名对象我们也可以不定义对象的句柄而直接调用这个对象的方法。这样的对象叫做匿名对象。如new Person().shout();使用情况如果对一个对象只需要进行一次方法调用那么就可以使用匿名对象。 我们经常将匿名对象作为实参传递给一个方法调用。说明1.可变参数方法参数部分指定类型的参数个数是可变多个2.声明方式方法名参数的类型名…参数名3.可变参数方法的使用与方法参数部分使用数组是一致的4.方法的参数部分有可变形参需要放在形参声明的最后内存模型Java里方法的参数传递方式只有一种值传递。 即将实际参数值的副本复制品传入方法内而参数本身不受影响。可变个数的形参//下面采用数组形参来定义方法public static void test(int a ,String[] books); //如果没有参数就要定义空数组null//以可变个数形参来定义方法public static void test(int a ,String…books); //可以不写test();Static注意情况:1.类的访问机制在一个类中的访问机制类中的方法可以直接访问类中的成员变量。例外static方法访问非static的成员变量编译不通过。在不同类中的访问机制先创建要访问类的对象再用对象访问类中定义的成员。2.重写和被重写的方法须同时为static的或同时为非static的3.因为不需要实例就可以访问static方法因此static方法内部不能有this。(也不能有super ? YES!)重载的方法需要同时为static的或者非static的。虚拟方法调用正常的方法调用Person p new Person(); p.getInfo(); Student s new Student(); s.getInfo(); 虚拟方法调用(多态情况下) Person e new Student(); e.getInfo();​​调用Student类的getInfo()方法 编译时类型和运行时类型编译时e为Person类型而方法的调用是在运行时确定的所以调用的是Student类的getInfo()方法。——动态绑定接口接口的特点用interface来定义。接口中的所有成员变量都默认是由public static final修饰的。接口中的所有方法都默认是由public abstract修饰的。接口没有构造器。接口采用多层继承机制匿名内部类匿名内部类不能定义任何静态成员、方法和类只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面用其隐含实现一个接口或实现一个类。new 父类构造器实参列表|实现接口(){ //匿名内部类的类体部分}捕获/抛出异常捕获异常捕获异常的有关信息与其它对象一样可以访问一个异常对象的成员变量或调用它的方法。try{}catch(Exception e){e.printStackTrace();orsout(“e.getMessage()”);}finally //可写可不写{}getMessage( ) 方法用来得到有关异常事件的信息printStackTrace( )用来跟踪异常事件发生时执行堆栈的内容。抛出异常方法中抛出调用时捕获class B{ int i; public void test() throws Exception{ B b null; System.out.println(b.i); } } public class JavaBean { public static void main(String[] args) { B b new B(); try { b.test(); }catch (Exception e){ e.printStackTrace(); } ​ } }Java集合Java集合类存放于 java.util 包中是一个用来存放对象的容器。①、集合只能存放对象。比如你存一个 int 型数据 1放入集合中其实它是自动转换成 Integer 类后存入的Java中每一种基本类型都有对应的引用类型。②、集合存放的是多个对象的引用对象本身还是放在堆内存中。③、集合可以存放不同类型不限数量的数据类型。Java 集合可分为Set、List 和 Map三种大体系Set无序、不可重复的集合 (TreeSet进行自然排序)List有序可重复的集合Map具有映射关系的集合在 JDK5 之后增加了泛型Java 集合可以记住容器中对象的数据类型HashSetHashSet 是 Set 接口的典型实现大多数时候使用 Set 集合时都使用这个实现类。我们大多数时候说的set集合指的都是HashSetHashSet按 Hash 算法来存储集合中的元素因此具有很好的存取和查找性能。HashSet 具有以下特点1.不能保证元素的排列顺序2.不可重复3.HashSet 不是线程安全的集合元素可以使 null当向 HashSet 集合中存入一个元素时HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。如果两个元素的 equals() 方法返回 true但它们的 hashCode() 返回值不相等hashSet 将会把它们存储在不同的位置但依然可以添加成功。Set s new HashSet(); SetObject s new HashSetObject(); s.add(1); s.remove(1); s.contains(1); //true //是否包含1 s.clear(); s.size()元素的遍历Iterator It s.iterator(); while(It.hashNext()){ ​ sout(It.next()); }for (Object obj:set){ /把set的每一个值取出来赋值给obj直到循环set的所有值 System.out.println(obj); }泛型和TreeSet集合Java中的泛型只在编译阶段有效。在编译过程中正确检验泛型结果后会将泛型的相关信息擦出并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说泛型信息不会进入到运行时阶段。让集合存同样类型的对象SetString set new HashSetset();//不能存string类型之外的数据了 SetInteger set new TreeSetInteger(); ------------------------------------------------------------ main Person p1 new Person(张三,23); Person p2 new Person(李四,20); Person p3 new Person(王五,16); Person p4 new Person(Lucy,29); SetPerson set new TreeSetPerson(new Person()); //其中的new Person()是一个比较器 set.add(p1); set.add(p2); set.add(p3); set.add(p4); for(Person p : set){ System.out.println(p.name p.age); } } ------------ class Person implements ComparatorPerson{//把person对象存到TreeSet中并且按照年龄排序 int age; String name; public Person(){ } public Person(String name, int age){ this.name name; this.age age; } Override public int compare(Person o1, Person o2) {//年龄正序排列 if(o1.age o2.age){ return 1; }else if(o1.age o2.age){ return -1; }else{ return 0; } }List集合List 代表一个元素有序、且可重复的集合集合中的每个元素都有其对应的顺序索引List 允许使用重复元素可以通过索引来访问指定位置的集合元素。List 默认按元素的添加顺序设置元素的索引。List 集合里添加了一些根据索引来操作集合元素的方法ListString list new ArrayListString(); list.add(b);//第一个索引下标0 list.add(d);//索引下标1 list.add(c);//索引下标2 list.add(a);//索引下标3 list.add(d);//允许使用重复元素 System.out.println(list); System.out.println(list.get(2));//通过索引来访问指定位置的集合元素 list.add(1,f);//在指定索引下标的位置插入数据 System.out.println(list); ListString l new ArrayListString(); l.add(123); l.add(456); list.addAll(2, l);//在指定索引下标的位置插入集合 System.out.println(list); System.out.println(list.indexOf(d));//获取指定元素在集合中第一次出现的索引下标 System.out.println(list.lastIndexOf(d));//获取指定元素在集合中最后一次出现的索引下标 list.remove(2);//根据指定的索引下标移除元素 System.out.println(list); list.set(1, ff);//根据指定的索引下标修改元素 System.out.println(list); //根据索引下标的起始位置截取一段元素形参一个新的集合截取的时候包含开始的索引不包含结束时的索引 ListString sublist list.subList(2, 4);//取索引下标在大于等于2小于4的元素 System.out.println(sublist); System.out.println(list.size());//集合的长度不可变list集合List l List.of(“1”,“2”); //其它集合Set、Map最多10个用ofEntries都有of方法创建不可变集合内容不可修改for(String s :l){​ sout(s);}MapHashMapMapString, Integer map new HashMapString, Integer(); map.put(b, 1);//添加数据 map.put(c, 2); map.put(e, 2); System.out.println(map); System.out.println(map.get(b));//根据key取值 map.remove(c);//根据key移除键值对 System.out.println(map); System.out.println(map.size());//map集合的长度 System.out.println(map.containsKey(a));//判断当前的map集合是否包含指定的key System.out.println(map.containsValue(10));//判断当前的map集合是否包含指定的value map.clear();//清空集合 SetString keys map.keySet();//获取map集合的key的集合 map.values();//获取集合的所有value值 //遍历map集合,通过map.keySet(); for(String key : keys){ System.out.println(key: key , value: map.get(key)); } //通过map.entrySet();遍历map集合 SetEntryString, Integer entrys map.entrySet(); for(EntryString, Integer en : entrys){ System.out.println(key: en.getKey() , value: en.getValue()); }Treemap//TreeMap的自然排序是字典排序 MapInteger,String map new TreeMapInteger, String(); map.put(4, a); map.put(2, a); map.put(3, a); map.put(1, a); System.out.println(map); MapString,String map1 new TreeMapString, String(); map1.put(b, b); map1.put(c, c); map1.put(d, d); map1.put(a, a); map1.put(ab, ab); map1.put(1, ab); map1.put(10, ab); System.out.println(map1);Collections(操作集合的工具)排序操作reverse(List)反转 List 中元素的顺序shuffle(List)对 List 集合元素进行随机排序sort(List)根据元素的自然顺序对指定 List 集合元素按升序排序sort(ListComparator)根据指定的 Comparator 产生的顺序对 List 集合元素进行排序swap(Listint int)将指定 list 集合中的 i 处元素和 j 处元素进行交换Object max(Collection)根据元素的自然顺序返回给定集合中的最大元素Object max(CollectionComparator)根据 Comparator 指定的顺序返回给定集合中的最大元素Object min(Collection)Object min(CollectionComparator)int frequency(CollectionObject)返回指定集合中指定元素的出现次数boolean replaceAll(List listObject oldValObject newVal)使用新值替换 List 对象的所有旧值同步控制Collections 类中提供了多个 synchronizedXxx() 方法该方法可使将指定集合包装成线程同步的集合从而可以解决多线程并发访问集合时的线程安全问题泛型类1.对象实例化时不指定泛型默认为Object。2.泛型不同的引用不能相互赋值。public class Test1 { public static void main(String[] args) { // B1Object b1 new B1Object(); // B1String b2 new B1String(); // // B2 b3 new B2(); CcObject c new CcObject(); c.test(xxx); //泛型方法在调用之前没有固定的数据类型 //在调用时传入的参数是什么类型就会把泛型改成什么类型 //也就是说泛型方法会在调用时确定泛型距离数据类型 Integer i c.test1(2);//传递的参数是Integer泛型就固定成Integer返回值就是Integer Boolean b c.test1(true);//传递的参数是Boolean泛型就固定成Boolean返回值就是Boolean } } interface IBT{ T test(T t); } /** * 未传入泛型实参时与泛型类的定义相同在声明类的时候需将泛型的声明也一起加到类中 * author lby * * param T */ class B1T implements IBT{ Override public T test(T t) { return t; } } /** * 如果实现接口时指定接口的泛型的具体数据类型 * 这个类实现接口所有方法的位置都要泛型替换实际的具体数据类型 * author lby * */ class B2 implements IBString{ Override public String test(String t) { return null; } } class CcE{ private E e; /** * 静态方法的泛型方法 * param t */ public static T void test3(T t){ //在静态方法中不能使用类定义泛型如果要使用泛型只能使用静态方法自己定义的泛型 // System.out.println(this.e); System.out.println(t); } /** * 无返回值的泛型方法 * param s */ public T void test(T s){ //在类上定义的泛型可以在普通的方法中使用 System.out.println(this.e); T t s; } /** * 有返回值的泛型方法 * param s */ public T T test1(T s){ return s; } /** * 形参为可变参数的泛型方法 * param strs */ public T void test2(T... strs){ for(T s : strs){ System.out.println(s); } } }枚举类在某些情况下一个类的对象是有限而且固定的。例如季节类只能有 4 个对象手动实现枚举类private 修饰构造器属性使用 private final 修饰把该类的所有实例都使用 public static final 来修饰public class Test3 { public static void main(String[] args) { //Season.SPRING,这段执行就是获取一个Season的对象 Season spring Season.SPRING; spring.showInfo(); Season summer Season.SUMMER; summer.showInfo(); Season spring1 Season.SPRING; //每次执行Season.SPRING获得是相同的对象枚举类中的每个枚举都是单例模式的 System.out.println(spring.equals(spring1)); spring1.test(); } } enum Season implements ITest{ SPRING(春天,春暖花开),//此处相当于在调用有参的私有构造private Season(String name,String desc) SUMMER(夏天,炎炎夏日), AUTUMN(秋天,秋高气爽), WINTER(冬天,寒风凛冽); private final String name; private final String desc; private Season(String name,String desc){ this.name name; this.desc desc; } public void showInfo(){ System.out.println(this.name : this.desc); } Override public void test() { System.out.println(这是实现的ITest接口的test方法); } } interface ITest{ void test(); }Annotation(注解) 概述自定义注解I/O流File 类文件的遍历//遍历d盘下的test文件把test文件夹下所有的目录与文件全部遍历出来不论层级有多深要全部遍历出来 //这个使用递归的方式来实现 File f new File(D:\\test); new Test().test(f); } /** * 递归遍历文件 * param file */ public void test(File file){ if(file.isFile()){ System.out.println(file.getAbsolutePath() 是文件); }else{ System.out.println(file.getAbsolutePath() 是文件夹); //如果是文件夹这个文件夹里就可能有子文件夹或者文件 File[] fs file.listFiles();//获取当前文件夹下的子文件夹或者文件的file对象 if(fs ! null fs.length 0){ for(File ff : fs){ test(ff);//递归 } } } }流的分类按操作数据单位不同分为字节流(8 bit)字符流(16 bit)按数据流的流向不同分为输入流输出流按流的角色的不同分为节点流处理流定义文件路径时注意可以用“/”或者“\”。 在写入一个文件时如果目录下有同名文件将被覆盖。在读取文件时必须保证该文件已存在否则出异常。(抽象基类)字节流字符流输入流InputStreamReader输出流OutputStreamWriter文件字节流/** * 文件字节输入流FileInputStream * 。 * 在读取文件时必须保证该文件已存在否则出异常 */ public static void testFileInputStream(){ try { FileInputStream in new FileInputStream(D:/test/abc/tt1.txt); byte[] b new byte[10];//设置一个byte数组接收读取的文件的内容 int len 0;//设置一个读取数据的长度 // in.read(b);//in.read方法有一个返回值返回值是读取的数据的长度如果读取到最后一个数据还会向后读一个这个时候返回值就是-1 //也就意味着当in.read的返回值是-1的时候整个文件就读取完毕了 while((len in.read(b)) ! -1){ System.out.println(new String(b,0,len)); //new String(b,0,len),参数1是缓冲数据的数组参数2是从数组的那个位置开始转化字符串参数3是总共转化几个字节 } in.close();//注意。流在使用完毕之后一段要关闭 } catch (Exception e) { e.printStackTrace(); } } /** * 文件字节输出流FileOutputStream * 在写入一个文件时如果目录下有同名文件将被覆盖 */ public static void testFileOutputStream(){ try { FileOutputStream out new FileOutputStream(D:/test/abc/tt4.txt);//指定行tt4输出数据 String str knsasjadkajsdkjsa; out.write(str.getBytes());//把数据写到内存 out.flush();//把内存中的数据刷写到硬盘 out.close();//关闭流 } catch (Exception e) { e.printStackTrace(); } } /** * 复制文件到指定位置 * param inPath 源文件路径 * param outPanth 复制到的文件夹位置 */ public static void copyFile(String inPath, String outPanth){ try { FileInputStream in new FileInputStream(inPath);//读取的源文件 FileOutputStream out new FileOutputStream(outPanth);//复制到哪里 byte[] b new byte[100]; int len 0; while((len in.read(b)) ! -1){ out.write(b, 0, len);//参数1是写的缓冲数组参数2是从数组的那个位置开始参数3是获取的数组的总长度 } out.flush();//把写到内存的数据刷到硬盘 out.close(); in.close(); } catch (Exception e) { e.printStackTrace(); } }文件字符流public static void main(String[] args) { Test2.testFileReader(D:/test/abc/tt1.txt); //在写入一个文件时如果目录下有同名文件将被覆盖。 // Test2.testFileWriter(!!!!!!!, D:/test/abc/tt5.txt); // Test2.copyFile(D:/test/abc/tt5.txt, D:/test/abc/cc/tt5.txt); } /** * 文件字符输入流FileReader * 在读取文件时必须保证该文件已存在否则出异常 * param inPath */ public static void testFileReader(String inPath){ try { FileReader fr new FileReader(inPath);//创建文件字符输入流的对象 char[] c new char[10];//创建临时存数据的字符数组 int len 0;//定义一个输入流的读取长度 while((len fr.read(c)) ! -1){ System.out.println(new String(c, 0, len)); } fr.close();//关闭流 } catch (Exception e) { e.printStackTrace(); } } /** * 文件字符输出流FileWriter * 在写入一个文件时如果目录下有同名文件将被覆盖 * param text 输出的内容 * param outPath 输出的文件 */ public static void testFileWriter(String text,String outPath){ try { FileWriter fw new FileWriter(outPath); fw.write(text);//写到内存中 fw.flush();//把内存的数据刷到硬盘 fw.close();//关闭流 } catch (Exception e) { e.printStackTrace(); } } /** * 字符流完成拷贝文件,字符流只适合操作内容是字符文件 * param inPaht * param outPath */ public static void copyFile(String inPaht, String outPath){ try { FileReader fr new FileReader(inPaht); FileWriter fw new FileWriter(outPath); char[] c new char[100]; int len 0; while((len fr.read(c)) ! -1){//读取数据 fw.write(c,0,len);//写数据到内存 } fw.flush(); fw.close(); fr.close(); } catch (Exception e) { e.printStackTrace(); }缓冲字符流为了提高数据读写的速度Java API提供了带缓冲功能的流类在使用这些流类时会创建一个内部缓冲区数组**BufferedInputStream 和 BufferedOutputStream **BufferedReader 和 BufferedWriterpublic static void main(String[] args) { try { // Test.testBufferedInputStream(); // Test.testBufferedOutputStream(); Test.copyFile(); } catch (Exception e) { e.printStackTrace(); } }/** * 缓冲字节输入流 * BufferedInputStream * throws Exception */ public static void testBufferedInputStream() throws Exception{ //文件字节输入流对象 FileInputStream in new FileInputStream(D:\\testdemo\\demo\\src\\day13\\tt.txt); //把文件字节输入流放到缓冲字节输入流对象 BufferedInputStream br new BufferedInputStream(in); byte[] b new byte[10]; int len 0; while((len br.read(b)) ! -1){ System.out.println(new String(b,0,len)); } //关闭流的时候本着一个最晚开的最早关依次关 br.close(); in.close(); } /** * 缓冲字节输出流 * BufferedOutputStream */ public static void testBufferedOutputStream() throws Exception{ //创建字节输出流对象 FileOutputStream out new FileOutputStream(D:\\testdemo\\demo\\src\\day13\\tt1.txt); //把字节输出流对象放到缓冲字节输出流中 BufferedOutputStream bo new BufferedOutputStream(out); String s hello world; bo.write(s.getBytes());//写到内存中 bo.flush();//刷到硬盘上 //关闭流的时候本着一个最晚开的最早关依次关 bo.close(); out.close(); } /** * 缓冲流实现文件的复制 */ public static void copyFile() throws Exception{ //缓冲输入流 BufferedInputStream br new BufferedInputStream(new FileInputStream(D:\\testdemo\\demo\\src\\day13\\tt1.txt)); //缓冲输出流 BufferedOutputStream bo new BufferedOutputStream(new FileOutputStream(D:\\testdemo\\demo\\src\\day13\\tt2.txt)); byte[] b new byte[1024]; int len 0;//设置一个没出读取到的数据的长度直到br.read方法执行到最后比如说文件中只有hello world执行到最后一个就读取d的后面这个时候返回值就是-1 while((len br.read(b)) ! -1){ bo.write(b, 0, len);//写到内存 } bo.flush();//刷到硬盘 bo.close(); br.close(); }对于输出的缓冲流写出的数据会先在内存中缓存使用flush()将会使内存中的数据立刻写出转换流/** * 转换流 * 可以把字节流转换为字符流 * 当字节流中的数据都是字符的时候使用转换流转为字符流处理效率更高 * author lby * */ public class Test2 { public static void main(String[] args) { //所有的文件都是有编码格式 //对于我们来说TXT和java文件一般来讲有三种编码 //ISO8859-1西欧编码是纯粹英文编码不适应汉字 //GBK和UTF-8这两编码是适用于重要和英文 //我们一般使用UTF-8编码 try { // Test2.testInputStreamReader(); Test2.testOutputStreamWriter(); } catch (Exception e) { e.printStackTrace(); } } /** * 转换字节输入流为字符输入流 * 注意在转换字符流的时候设置的字符集编码要与读取的文件的数据的编码一致 * 不然就会出现乱码 * InputStreamReader */ public static void testInputStreamReader() throws Exception{ FileInputStream fs new FileInputStream(D:\\testdemo\\demo\\src\\day13\\tt5.txt); //把字节流转换为字符流 InputStreamReader in new InputStreamReader(fs,GBK);//参数1是字节流参数2是编码 // InputStreamReader in new InputStreamReader(fs,UTF-8);//参数1是字节流参数2是编码 char[] c new char[100]; int len 0; while((len in.read(c)) ! -1){ System.out.println(new String(c,0,len)); } in.close(); fs.close(); } /** * 转换字节输出流为字符输出流 * 注意在转换字符流的时候设置的字符集编码要与读取的文件的数据的编码一致 * 不然就会出现乱码 * OutputStreamWriter */ public static void testOutputStreamWriter() throws Exception{ FileOutputStream out new FileOutputStream(D:\\testdemo\\demo\\src\\day13\\tt6.txt); // OutputStreamWriter os new OutputStreamWriter(out, UTF-8); OutputStreamWriter os new OutputStreamWriter(out, GBK); os.write(你好你好); os.flush(); os.close(); out.close(); } }Class类反射调用过程Class p Person.class; Constructor con p.getConstructor(); //获取无参构造 Object obj con.newInstance(); //使用无参构造创建对象 Methode m p.getMethod(test,String.classint.class); //获取方法名为test参数为一个String类型的 //Methode m p.getDeclareMethod(test,String.classint.class); //调用私有方法 //m.setAccessible(true); //接触私有的封装 m.invoke(obj,hell,1); //开始调用hell是实际参数线程首先新写一个类(MyThread)继承Thread类实现runnable接口class Test extends Thread{ }1.重写Tread 的run【也可以实现多线程】Thread d new Test(); d.start( ); //多线程 //1.实现Runable接口 class MyRunnable implements Runnable{ //2.覆盖run()方法 Override public void run() { for (int i0;i20;i){ try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()----i);//获取当前线程名 } } } public class RunnableTest { public static void main(String[] args) { //3.创建MyRunnable的实例 MyRunnable tasknew MyRunnable(); //4.通过task对象来创建Thread对象 Thread thread1new Thread(task); //5.启动线程 thread1.start(); Thread thread2new Thread(task); thread2.start(); } }2.实现Runnable接口实现多线程Thread d new Thread(new test(),线程名称); d.start( );方法d.setName(String ); //设置线程名字 d.getName(); d.currentTread(); d.yield(); //线程让步 执行机会让给优先级相同或更高的 d.join(); //线程插入 d.sleep(); //线程睡眠ms d.stop() //强制停止线程优先级getPriority(); //获取新城优先级 setPriority(int newPriority); //设置线程优先级 默认5 1-10锁public synchroized void draw(){} //在普通对象上加锁锁的是对象不是方法 只是针对某一个对象解决对static的对象加锁线程通信wait(); //令当前线程挂起notify();唤醒正在排队的线程notifyAll();唤醒正在排队的所有等待线程这三个方法只能用在有同步锁的方法线程池APIMath–APIMath.max(int a,int b); round(); ceil();//向上正负数也是取整 floor(); PI 3.14...; pow(int a,int b);//a的b次幂 sqrt(); cbrt(); //开立方 random(); //[0,1)之间的随机数SystemSystem.exit();//0:正常停止 其他异常停止 long l System.currentTimeMillis(); //获取系统运行时间 System.arraycopy(arr1,0,arr2,0,10);//(拷贝数组1)-2 (数组1第几索引开始拷数组2从几索引开始贴拷贝数量)RuntimeRuntime.getRuntime().availableProcessors();//获取内核数 Runtime.getRuntime().maxMemory();//获取可用内存 Runtime.getRuntime().exec(nitepad); //运行cmd命令正则表达式String qq 123456; qq.matches([1-9]\\d{5,19}) //5-19位 \s:一个空白字符 \S:非空白字符 \w[1-9a-z_A-Z] \W:非单词 \\d: //数字 \\D: //非数字 X {?,*,} // 1/0 0-n 1-n X {n,m} //n-m次 -? : //可出现可不出现 (?!)java: //忽略大小写 (java)(?:8|11); //?代表java可以单独 后边跟着8或者11 (java)(8|11); //必须java后跟着8|11 捕获分组 (.)\\1: //.表示任意字符 \\1表示把第一组第几组主要看左括号“”的字符再次拿出来使用 String str我学学学嘻嘻嘻; String re str.replaceAll(regex:(.)\\1,replacement:$1); //正则内用\\1 正则外用$1 非捕获分组(?:)(?)(?!) 更多使用第一个(?:) 不占组号 //?:中的?也是代表前边见到知道是非捕获分组即可 String regex [1-9]\\d{16}(?://d|X|x) //身份证号Lambda表达式简化匿名内部类书写只有FunctionInterfaceArrays.sort(arr,(Integer o1,Integer o2)-{​ return o1-o2; //升序排序})流序列化流ObjectOutputStream(内存-文件)和ObjectInputStream(文件-内存)需要实现空接口class Student implements Serializable{} //此对象可以序列化 属性public transient String address; //瞬态关键字该关键字标记的成员变量不参与序列化过程打印流字符和字节打印流:PrintWrite和PrintStream网络编程B/S:浏览器/服务器C/S:客户端/服务器三要素1、IP设备在网络上的地址唯一标识2、端口号应用程序在设备中唯一的标识3、协议数据在网络中传输的规则UDP:DatagramSocket d new DatagramSocket(); //创建对象快递公司数据包 String s hello; byte[] bytes s.getBytes(); InetAddress address InetAddress.*getByName*(127.0.0.1); int port 10086; DatagramPacket s1 new DatagramPacket(bytes,bytes.length,address,port); //打包数据 d.send(s1); //发送数据 d.close(); //释放资源上边都是单播11组播224.0.0.0-239.255.255.255MuticastSocket创建对象TCP发送数据接受数据反射​ class是指当前类的class对象getClassLoader()是获取当前的类加载器什么是类加载器简单点说就是用来加载java类的,类加载器负责把class文件加载进内存中并创建一个java.lang.Class类的一个实例也就是class对象并且每个类的类加载器都不相同。getResourceAsStream(path)是用来获取资源的而类加载器默认是从classPath下获取资源的因为这下面有class文件吗所以这段代码总的意思是通过类加载器在classPath目录下获取资源.并且是以流的形式。​ 我们知道在Java中所有的类都是通过加载器加载到虚拟机中的而且类加载器之间存在父子关系就是子知道父父不知道子这样不同的子加载的类型之间是无法访问的虽然它们都被放在方法区中所以在这里通过当前类的加载器来加载资源也就是保证是和类类型同一个加载器加载的。原文链接https://blog.csdn.net/feeltouch/article/details/83796764获取class对象Class.forName(“类名”)//包名类名类名.class对象.getClass();获取构造方法类、实例和Class对象区分类是面向对象编程语言的一个重要概念它是对一项事物的抽象概括可以包含该事物的一些属性定义以及操作属性的方法。面向对象编程中我们都是以类来编码。实例简单理解就是new就是对类的实例化创建这个类对应的实际对象类只是对事物的描述而实例化就相当于为这个描述新开辟了一块内存可以改变这块区域里的各种属性成员变量当然也可以实例化多块区域只是不同的对象而已。Class注意这里C大写了与类概念区分开在java里Class是一个实实在在的类在包 java.lang 下有这样一个Class.java文件它跟我们自己定义的类一样是一个实实在在的类Class对象就是这个Class类的实例了。在Java里所有的类的根源都是Object类而Class也不例外它是继承自Object的一个特殊的类它内部可以记录类的成员、接口等信息也就是在Java里Class是一个用来表示类的类。o(∩_∩)o 有点绕啊抓住关键一点Class是一个实实在在的类可以为它创建实例也就是本文后面提到的Class对象也看叫做Class实例。java提供了下面几种获取到类的Class对象的方法1) 利用对象实例调用getClass()方法获取该对象的Class实例2) 使用Class类的静态方法forName(包名类名)用类的名字获取一个Class实例3)运用 类名.class 的方式来获取Class实例我们知道java世界是运行在JVM之上的我们编写的类代码在经过编译器编译之后会为每个类生成对应的.class文件这个就是JVM可以加载执行的字节码。运行时期间当我们需要实例化任何一个类时JVM会首先尝试看看在内存中是否有这个类如果有那么会直接创建类实例如果没有那么就会根据类名去加载这个类当加载一个类或者当加载器(class loader)的defineClass()被JVM调用便会为这个类产生一个Class对象一个Class类的实例用来表达这个类该类的所有实例都共同拥有着这个Class对象而且是唯一的。动态代理查漏/t制表符打印时补齐字符1-8位/b :退格符子类方法抛出的异常不能大于父类被重写方法的异常CtrlAltt:包围方式CtrlAltv:变量声明Ctrlp 提示方法形参