public class People {
    int m = 10,n;
    //应该把这些代码定义在一个方法里面
    n = 200; //Unexpected token
    if(){} //Unexpected token
}

Long a = 153434L, b =153434L;
System.out.println(a==b);   //false

byte b = (byte)129;  //-127
//byte range：-128 ~ 127
//127：0111 1111
//128：1000 0000 （-128）
//129：1000 0001 =》（即二进制的10000001在补码表示中解释为-127）

public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new MyThread("Thread 1");
        Thread thread2 = new MyThread("Thread 2");

        thread1.start();
        thread2.start();

        // 使用 yield() 方法暂停当前线程，让其他线程有机会执行
        Thread.yield();

        // 使用 join() 方法等待 thread1 和 thread2 执行完毕
        thread1.join();
        thread2.join();

        System.out.println("All threads have finished execution.");
    }

public class B
{
    public static B t1 = new B(); //1
    public static B t2 = new B(); //2
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块"); //3
    }
    public static void main(String[] args)
    {
        B t = new B(); //4
    }
}

public class Test
{
    public static Test t1 = new Test(); //1
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB"); //2
    }
    public static void main(String[] args)
    {
        Test t2 = new Test(); //3
    }
 }

/**
 * 父类初始化<clinit>
 * 1、j = method()
 * 2、 父类的静态代码块
 *
 * 父类实例化方法:
 * 1、super()（最前）
 * 2、i = test() (9)
 * 3、子类的非静态代码块 (3)
 * 4、子类的无参构造（最后）(2)
 *
 *
 * 非静态方法前面其实有一个默认的对象this
 * this在构造器或<init> 他表示的是正在创建的对象，因为咱们这里是正在创建Son对象，所以
 * test()执行的就是子类重写的代码(面向对象多态)
 *
 * 这里i=test() 执行的就是子类重写的test()方法
 */
public class Father {
    private int i = test();
    private static int j = method();

    static{
        System.out.println("(1)");
    }
    Father() {
        System.out.println("(2)");
    }
    {
        System.out.println("(3)");    //我主要被这个代码块卡住，其实这块和上面的 int i 同等地位。<inti>() 会执行
    }
    public int test(){
        System.out.println("(4)");
        return 1;
    }
    public static int method() {
        System.out.println("(5)");
        return 1;
    }
}

-----------------------------------------
/**
 * 子类的初始化<clinit>
 * 1、j = method()
 * 2、子类的静态代码块
 *
 * 先初始化父类 (5)(1)
 * 初始化子类 (10) (6)
 *
 * 子类实例化方法:
 * 1、super()（最前
 * 2、i = test() (9)
 * 3、子类的非静态代码块 (8)
 * 4、子类的无参构造（最后）(7)
 */ 
public class Son extends Father {
    private int i = test();
    private static int j = method();
    static {
        System.out.println("(6)");
    }
    Son() {
        super();
        System.out.println("(7)");
    }
    {
        System.out.println("(8)");
    }
    public int test(){
        System.out.println("(9)");
        return 1;
    }
    public static int method() {
        System.out.println("(10)");
        return 1;
    }

    public static void main(String[] args) {
        Son son = new Son();
        System.out.println();
        Son son1 = new Son();
    }
}

public class MyClass {
    long var;
    public void MyClass(long param) { var = param; }//(1) 因为用了修饰方法的 void 所以它是一个普通方法！

final byte b4=4,b5=6; 
b6=b4+b5; //在编译时就已经变为b6=10了，编译通过

链接：https://www.nowcoder.com/questionTerminal/47ffaf4670384e34a925e294fcd686c0
来源：牛客网

final Student t = new Student();      t.setStuName("11");      t.setStuNo(1);    //不报错 因此final修饰的可以改变属性
再看我们把Teacher类继承Student:
final Student t = new Student();      t = new Teacher();   //t编译错误,因此不可以再指向其他对象

int i = 0;
i= i ++;
System.out.println(i); //0

public class User implements Cloneable {
    private String name;
    private Address address;
    // constructors, getters and setters
    @Override
    public User clone() throws CloneNotSupportedException {
        User user = (User) super.clone();
        user.setAddress(this.address.clone());
        return user;
    }
}
//name 不可变性所以没关系，original的改变不会影响deepCopy

容量小->容量大:
byte、short、char、< int < long < float < double
    
难点：
    1. float表示的范围比long大原因是，float与long在内存中的存储方式不一样。
    2. 至于为什么 Java 中 char无论中英文数字都占用2字节，是因为 Java 中使用 Unicode 	   	  字符，所有字符均以2个字节存储。 而如果需要识别字符是否为中文，可以使用正则匹配式。
    3. char c = ''; //编译不通过
	4. char + int = int

		int a = 12,b = 5;
        double c = a / b;
        double d = a / (b+0.0);
        System.out.println(c+"\t"+d); //2.0	2.4
		注意这个2.0！！！

		short s1 = 10;
        s1 ++;//自增1不会改变本身变量的数据类型

	题目: 如何求一个0-255范围内的整数的十六进制值，例如60
        //要求手动实现   十六进制表示形式3C.

        //分析：0-255 8位所以只关注后面8位就行，且按规则每4位组一个数
        //15的二进制数是1111 所以取这个数的后四位就是&15 这是关键*****  【每个十六进制位对应4个二进制位】
        int n = 60;
        int ans01 = n & 15;
        String s1 = ans01 > 9 ? (char)(ans01-10+'A')+"" : ans01+"";

        ans01= n >>> 4 & 15;
        String s2 = ans01 > 9 ? (char)(ans01-10+'A')+"" : ans01+"";

        System.out.println(s2+s1);//3C

整型（byte、short、int、long）：0

浮点型（float、double）：0.0

字符型（char）：0  （或'\u0000'）

布尔型（boolean）：false

引用数据类型（类、数组、接口）：null

意味着，我们在调用局部变量之前，一定要显式赋值。

特别地：形参在调用时，我们赋值即可。

    1. 默认初始化
    2. 显示初始化/代码块
    3. 构造器
    4. 对象.属性   对象.方法

 属性：加载到堆空间中   （非static）
     
 局部变量：加载到栈空间

    抽象和接口用到多态，因为它们不能实例化（new）。
    例如：Employee x = new Manager();
    既然不能new的话就通过多态，如上Employee这个抽象类就可以用属于自己的属性和方法。
    一般多态体现在方法的形参上。一般形参申明为父类，实际传子类对象，这样父类和子类都可以穿。
    注意抽象类是能继承非抽象类的（默认继承Object）
    
    
    接口是多继承的！
    接口不能定义构造器！抽象类可以！
    接口属性默认：public static final
        方法默认：public abstract
        
    接口默认为public abstract，所以接口的修饰符可以为abstract
        
    
    //XD 2023/12/13 接口中可以有static default方法
    jdk8接口除了可以定义全局常量和抽象方法外，还可以定义静态方法和默认方法（这两个有方法体），如下：
    注意默认还是public！！！
    static void a() {
        //接口中的静态方法只能接口来调，实现类是掉不了这个a方法的。    【不要想复杂了，就和平时一样静态方法属于类    这里属于接口】
        //有点像工具类靠，换句话说接口越来越像类了例如Collection
    }
    
    default void b() {
        
    }
    

    
    
    
    
    
    
    
    ！！！
    有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。

    目的：图省事，只用一次。可以lambda

因为Integer作为常量时，对于-128到127之间的数，会进行缓存，也就是说int a1 = 127时,在范围之内，这个时候就存放在缓存中，当再创建a2时，java发现缓存中存在127这个数了，就直接取出来赋值给a2，所以a1 == a2的。当超过范围就是new Integer()来new一个对象了，所以a、b都是new Integer(128)出来的变量，所以它们不等。



首先这是JDK在1.5版本中添加的一项新特性，把-128~127的数字缓存起来了，用于提升性能和节省内存。所以这个范围内的自动装箱（相当于调用valueOf(int i)方法）的数字都会从缓存中获取，返回同一个数字，所以现在你理解为什么了吧。同时这也会给我们开发带来预想不到的陷阱，直得注意！！
    
    后来：
    * Integer i = 10 等价于 Integer i = Integer.value0f(10)   ###装箱
    * int n = i 等价于 int n = i.intValue();   ###拆箱
基本数据类型不能拥有面向对象的好处，包装类可以。。。
1）基本数据类型都有默认值，而包装类可以是 null 更加符合业务！！！
2）包装类型可用于泛型，而基本类型不可以



对Integer的缓存，我们在日常开发时，对于小的整型值应该充分利用Integer的缓存对象省去过多的对象创建，回收的操作，这样会极大的提高程序性能

    interface A {
        int x = 0;
    }
    
    class B {
        int x = 1;
    }
    
    class C {
        public static void main(String[] args) {
            System.out.println(super(x));
            System.out.println(A.x);//要记得接口的属性默认为：public static final
        }
    }
    ------------------------以上error-------------------------
    
    //下面才是正确的写法，注意super！！！（super是指向父类的引用）
    interface A {
         int x = 0;
    }
    
    class B {
        int x = 1;
    }

class Solution extends B implements A {
    public void pX() {
        System.out.println(super.x);
        System.out.println(A.x);
        
    }

    public static void main(String[] args) {
        new Solution().pX();
    }
}

    person中有brain（大脑）如果我放外面那就和person平级了别的地方又用不到，但是brain用String这种又差点意思，所有有了内部类。
    
    内部类：成员内部类 vs 局部内部类
    
    一般看源码会出现，实际开发少。

  要写出常见的异常
  
  try/catch  try抛出   发现这条语句有异常，跳对应的catch中处理，那条有异常的语句后面的代码就不会再执行了！！！   catch处理完后继续往下运行。
  
  注意catch一般都是细致的异常写前面，大的写后面（Exception）
  编译时的异常用try/catch包起来就不会爆红了，但运行时依旧是错的，相当于把编译时的可能出现的异常，延迟到运行时出现。
  
  
  为什么需要finally：因为像数据库连接，IO流，socket网络编程等资源JVM是无法自动回收的，我们需要手动进行资源释放，所以要放finally（finally是无论是否发生异常代码总会执行的！）
  自己后面补充(不知道对不对) ---> 关闭资源为什么不写到catch里面：因为catch里如果又发生异常了又会产生一样的场景
  
  
  一般try/catch/finally是针对编译时异常使用。
  要保证资源的关闭，所以不能用throws
  
  
  在每一个可能返回(return)的地方，以及每一个可能出现异常而导致程序跳转的地方，程序员不得不考虑如何释放资源，导致复杂和冗余。所以，需要finally语句。把资源释放或状态还原的代码放到finally块中，可以保证在try和catch语句执行完后，一定会执行finally语句块，而不用考虑各种复杂的跳转情况。



//代码1
public static void test() throws Exception  {

    throw new Exception("参数越界"); 
    System.out.println("异常后"); //编译错误，「无法访问的语句，不可达代码」
}


//代码2
try{
    throw new Exception("参数越界"); 
}catch(Exception e) {
    e.printStackTrace();
}
System.out.println("异常后");//可以执行


//代码3
if(true) {
    throw new Exception("参数越界"); 
}
System.out.println("异常后"); //抛出异常，不会执行
  
  
  可以自定义异常类：三步，模仿API的异常类
                    1、继承Exception/RuntimeException
                    2、序列化
                    3、调构造方法super()

位运算 是公认的 高效运算，在高频计算中，可以使用位运算替换一般简单的乘除法来提升系统性能。 
位运算比直接的乘除法 在效率上 提升了 不止一个数量级，这是非常可观的。

自己的理解：
    程序：一段静态代码
    进程：程序放内存中跑起来运行了
    线程：比如360可以杀毒，清理垃圾等同时进行
    
    
    一个java程序跑起来至少有3个线程：1. main 主线程
                                     2. GC垃圾回收线程
                                     3. 异常处理线程
                                     
    跑一个线程有4步：1. 写一个类继承Thread
                     2. 重写Thread的run方法（放自己的业务代码）
                     3. new出自己写的那个类（Thread类的子类对象）
                     4. 调这个对象的start()方法：注意不是run()
                     
    如果线程只用一次可以考虑用Thread类的匿名子类的方式：
                    new Thread(
                        ()-> System.out.print();
                    ).start();
                    
    关于同步方法的总结：1. 不需要显示声明同步监视器
                        2. 非静态同步方法，同步监视器是--->this
                        3. 静态同步方法，同步监视器是--->当前类本身
                    
    yield()
    join()：在线程a中调用线程b的join()，此时线程a就会进入阻塞状态，直到线程a等线程b全部执行完，结束阻塞状态。
    
    线程的优先级：默认是5，最大是10，最小是1   ------> 概率
    
    
    
    
    
    
    创造多线程的方式二: 实现Runnable接口 ------> 具体看api文档，有模板
                                        ------> 开发时优先选择  1. 没有类的单继承局限
                                                                 2. 更适合处理多个线程有共享数据的情况
                                                                 
                                                                 
    wait() notify() notifyAll() 是定义在java.lang.Object类中
    
    
    
    
    
    sleep()和wait()的异同：
        1. sleep()在Thread类中，wait()在Object中
        2. sleep()不会释放同步监视器(锁)，wait()会释放同步监视器。
        3. wait()必须在同步代码块中使用，sleep()可以在任何场景。
        
        
        
        
    实现线程有四种方式：
        jdk 5.0加了一个实现callable接口，相对于Runnable的优势：
            1. 相比run()方法，可以有返回值
            2. 方法可以抛出异常（run()只能try catch）
            3. 支持泛型的返回值
            4. 需要借助FutureTask类
        还有一种线程池

    String 1. final,不可被继承，不可变性！（这个在值传递问题考的多！）
           2. 实现了serializable接口，表示字符串是支持序列化的（IO流部分）
           3. 实现了comparable接口，表示String可以比较大小。
           
           
           
    注意：People p1 = new People("Tom",1);
          People p2 = new People("Tom",2);
          p1.name == p2.name;    //true
          //因为上面都是以字面量的形式赋值Tom，所以都是指向字符串常量池中的Tom

    String对象的创建：
        String s1 = new String();
        //本质上   this.value = new char[0];
        
    
    1. 常量和常量拼接结果在常量池，且常量池不会存在相同内容的常量。
    2. 只要有一个是变量，结果就在堆中（实际内容再从常量池中引）
    3. 如果拼接的结果调用intern()方法，返回值就在常量池中
    String s1 = "javaEEhadoop";
    String s2 = "javaEE";
    String s3 = s2 + "hadoop"; //false
    
    final String s4 = "javaEE";
    String s5 = s4 + "hadoop"; //true
    
    
    
    utf-8一个字符3个字节，gbk一个汉字2个字节。
    byte[] bytes = str.getBytes();//使用默认的字符集进行编码
    new String(bytes);//使用默认字符集进行解码
    
    
    开发中推荐用StringBuffer(容量) //如果知道容量就给，避免反复扩容影响效率 
    
    
    
    //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
    String s1 = "javaEE";
    String s2 = "javaEE";
    //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
    String s3 = new String("javaEE");
    String s4 = new String("javaEE");
    
    
    
    
    
    
    
    
    //一道面试题  ------> String的不可变性
    public class StringTest {

    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

    comparable   comparator    接口
    
    首先实现comparable的类必须实现comparaTo(),然后就可以通过Arrays.sort或者Collectoins.sort进行自动排序

    for(String a : arr) {
        a = "hh";
    }
    注意：这里再重新遍历这个arr数组发现还是没变。
    
    
    List 1.2 : 有序、可重复
    ArrayList 1.2  ------> 线程不安全，效率高
                            避免扩容，在知道长度的情况下尽量调有参构造器把容量确定好
                            1.8的源码是在调用add()时才把数组创建好，不然一开始只是一个常量{}。。。这样的好处是延迟了数组的创建，节省内存。类似于单例的懒汉式。
                            1.7类似单例的饿汉式，一开始声明的时候就给你开辟一个大小为10的空间。
                            
                            注意remove()有两个，一个是根据下表，一个是根据值
    LinkedList 1.2  ------> 双向链表，适合频繁的插入、删除操作
    Vector 1.0  ------> 出现的比上面的都早！和List作比较：线程安全，效率低
                        这个基本不用了，因为ArrayList可以通过工具类Collections的SynchronizedList转成一个线程安全的！！！
                        
                        
                        
    set : 无序、不可重复
          如需像set添加数据，所在的类需要重写hashCode() equals()方法，不然都默认用的是Object类中的方法。。。注意重写这两个方法时要保证一致性。
          
    HashSet（数组+链表） ------> 线程不安全 
                        无序：不等同于随机性，在底层数组中并不是按照数组索引依次添加，而是按照数       据hash值决定的
                        不可重复（重要用的多）：根据equals()判断
                        ps：假如自己设计一个set该如何设计，要保证不能重复就每添加一个元素就和数组里已有的元素equals，假如数组里有1000个元素，你加第1001个的时候就需要equals1000下这样显然效率太低了。所以有通过hash来实现这样的操作。先根据hashcode的某种算法找在数组的位置，如果该位置没有元素就直接添加到这，如果有元素了就equals比较true就证明一样，添加失败，全比完全false就证明没有一样的就可以添加，就加在链表的最后    
    LinkedHashSet ------> 可以按照添加的顺序遍历
                          在添加数据时还维护了两个引用，记录前一个数据和后一个数据。好处：对于频繁的遍历操作，效率要高于HashSet
    TreeSet ------> 可以按照添加的对象的指定属性进行排序，底层是红黑树
                    要求添加的数据都是相同类的对象，如果加int就所有元素都得是int
                    比较两个对象是否相同的标准：ComparaTo返回0  不再是 equals
                    
                    
                                      
                    
                    
                    
                    
                    
                    
                    
                    
    Map: 存的是Map.Entry<K,V>     Map源码看着还是很痛苦，有时间再回过头看视频
        HashMap ------> 1. 线程不安全
                        2. key,vlue可以存null值
                        3. 1.7: 数组+链表  1.8: 数组+链表+红黑树  
                        4. 所有的key用set存   key所在的类要重写hashCode() equals()
                        5. Entry也是用set存
                        6. jdk7 的底层实现和HashSet有点像，先得到key的hashCode()再通过某种算法得到在Entry数组中的存放位置，再和这个位置上的元素比（见HashSet）区别就是比完发现key有一样的此时把现在这个key的value替换数组里以前的这个key对应的value
                        
                        7. jdk8实现与7的区别：1. 底层数组是Node[] 而不是 Entry[]，其实本质还是Entry
                                             2. new的时候没有创建长度为16的数组，调用put()的时候才创建（和ArrayList一样）
                                             3. 核心！！！当数组长度 > 64 且某一个索引位置以链表形式存在的数据个数 > 8时，此时索引位置上的所有数据改为使用红黑树存
                LinkedHashMap ------> 对于频繁遍历操作，效率比hashMap高。可以按照添加顺序遍历
        TreeMap ------> 对key进行排序(自然排序/定制排序) 底层红黑树
        Hashtable ------> 古老  key/value不能存null
                Properties ------> 常用来处理配置文件，框架！key/value都是String类型
        
        

                            
                            
哈希桶（数组的每个位置称为一个桶）

    泛型常见的表示可以是<E> <T> <K,V>  也可以是自给随便给<E1,E2,E3,A,B,C>都行
    
        
    T[] arr = new T[10]; // 编译不通过  因为T只是类型，不是类！
    T[] arr = (T[]) new Object[10]; //编译通过
    
    
    泛型方法：在方法中出现了泛型结构，泛型参数与类的泛型参数没有任何关系比如类是<E>  泛型方法是<T>    换句话说，泛型方法所属的类是不是泛型类都没有关系
    
    
    public <E> List<E> copyFromArrayToList(E[] arr)  //注意public后面的<E> 不加会编译报错，会看成是不是有个类叫E。。。。。所以要表示一下前面加<E>
    
    通配符：
    List<String> a 不能赋值给  List<Object> b
    解决途径：通配符 ？    List<?> c      c = a; //ok  c = b //ok    但对于c就不能向里添加数据了，除了添加null之外（因为所有类类型都可以赋值为null）
    总结：类A是类B的父类，G<A>和G<B>是没有任何关系的，二者共同的父类是：G<?>
    
    
    
    有限制条件的通配符使用：
        List<? extends Person> l1 = null; //extends ---> <=
        List<Person> List<student> 可以赋值给l1  List<Object>不行
        List<? super Person> l1 = null; //super ---> >=
        List<Person> List<Object> 可以赋值给l1  List<student>不行
        
        可以这样理解：?（-∞，+∞） extends ---> （-∞，A]
                                  super ---> [A，+∞）
        写数据时注意，对于l1来说，不能把add(new Student) //因为不清楚是不是还有比Student小的类，拿上面数学的方式理解，因为负无穷大，假如有比Student小的子类，我不能把Student赋给这个子类。（向下强转，向上自然转）

    File类的一个对象：代表一个文件或文件目录  
    注意路径：windows是'\'    linux和url是'/'


    输入流 vs 输出流 : 注意看站位：我站位内存的位置，就是进内存的为输入，出内存的为输出
    
    字符流 vs 字节流 : 字符流处理文本，其他像图片、视频什么的都是字节流
    
    节点流 vs 处理流 ：节点流是直接怼到数据的(可以理解为最原始的那根管道)，处理流是作用在已有流的基础之上的(相当于管道外面再包一层)


    关流：先关外层的再关内层的，关外层流时，内层流会自动关闭，所以关于内层流的关闭可以省略。
    
    
    题目 : 实现图片加密操作(提示：异或)  a^b^b = a  a^5^5 = a
           统计文本中每个字符出现的次数
           
           
    处理流之二 : 转换流(属于字符流)，提供字符流和字节流之间的转换
    
    字符集：见视频p602，ANSI是平台默认编码，例如中文操作系统编码是GBK，英文操作系统是ISO-8859-1
    
    对象流：
    序列化：把对象存到数据源 ---> 允许把内存中的java对象转换成与平台无关的二进制流，允许把这种二进制流存到磁盘中，或通过网络传输
    反序列化：把对象从数据源拿到内存 ---> 当其他程序获取到这种二进制流，可以把它恢复成原来的java对象
    前台后台如果想传对象，就得要求这个对象是可序列化的
    
    序列化需要加常量id，不加会有以下情况，假如person类，我序列化完成后再回过头会把person类给改动了，多加了一个id属性。这时我再反序列化是会报错的。
    
    注意：可序列化类中所有属性要是可序列化的(基本数据类型和String默认是可序列化的)
          static/transient修饰的属性不能序列化，也就是说序列化的时候明明给值了比如String我给了值但是在反序列化的时候没值是null（序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。）
          
          不过一般序列化传值很少传Person这种，一般都是json(字符串格式，默认是可序列化的)
        序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。

    ip和端口号 and 网络通信协议
    ip 定位到主机
    端口号 定位正在运行的进程(程序)
    网络协议太复杂 ---> 分层  OSI参考模型(7层，理想化)实施有困难，落地：TCP/IP参考模型(4层)     两台机器数据的传输   就相当于一台经过这4层一层层数据封装，拿数据的那一台就一层层的数据拆封
    
    
    本地回环地址指的是以127开头的地址（127.0.0.1 - 127.255.255.254），通常用127.0.0.1来表示。
    
    内网IP一般是私有IP通常有一下3种：
    10.x.x.x
    172.16.x.x---172.31.x.x
    192.168.x.x

    假如回到十几年前就别买房子了太贵了，买域名
    
    InetAddress类
    
    Socket = ip + 端口号
    网络通信通常也叫Socket编程
    
    UDP适合播放视频，丢几帧无所谓，但别给我卡在那
    更好的生活例子：TCP(1.可靠，2.可大数据量传输，3.需释放已建立的连接，效率低)：打电话
                    TCP三次握手四次挥手
                    UDP(1.不需要建立连接，2.每个数据包大小限制在64K内，3.无需释放资源，开销小，速度快)：发短信，发电报
                    
                    
                    
                    
    TCP --->                
    客户端：Socket
    服务端：ServerSocket
    注意一个类：ByteArrayInputStream包含一个内部缓冲区，其中包含可以从流中读取的字节 ---> 好处：假如取的时候原先传过来的时候有中文一个中文3个字节，可能有乱码。而这个类会把取到的缓存起来最后再一次性拿出来。就不会有一个中文劈成两半的情况。
    需先启动服务器端，等待客户端访问
    如先启动客户端握手会报错，连接失败
    而UDP只管发，先启动谁都不会报错
    
    
    
    UDP ---> 以数据报形式发送
    发送端：
    接收端：
    
    
    TCP/IP参考模型 ---> 
    应用层(HTTP,FTP,Telent,DNS...)
    传输层(TCP,UDP...)
    网络层(IP,ICMP,ARP...)
    物理+数据链路层(Link)

    特征：动态性
    某种意义上 框架 = 反射 + 注解 + 设计模式

    Class类是用来描述class类的类
    具体看java.lang中的Class类和java.lang.reflect
    
    反射的应用场景：编译时确定不下来造哪个对象
                    程序在服务器中已经运行起来了，如用户想注册（register)/登录（login）。这时通过反射服务器中运行的代码就会通过判断动态的创造相应的对象
                    
                    
    关于java.lang.Class类的理解
    1.类的加载过程：
    程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。
    接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件
    加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此
    运行时类，就作为Class的一个实例。

    2.换句话说，Class的实例就对应着一个运行时类。
    3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式
    来获取此运行时类。
    
    
    
    
    
        1）获取Class实例：
        
        //方式一：调用运行时类的属性：.class  编译时就写死了，没有体现动态性
        //通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性）
        Class clazz1 = Person.class;
        //Class clazz = hello.class;  //如果我没创hello会报这样的错：hello 无法解析为类型(hello不是类、接口、枚举、注解、数组、基本数据类型、void)
        System.out.println(clazz1);
        
        //方式二：通过运行时类的对象,调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);

        //方式三：调用Class的静态方法：forName(String classPath)   
        //用的最多，也更好体现运行时的动态性，像第一种定死了，这种里面是个String只有运行时才会去判断有没有错找不不找得到
        Class clazz3 = Class.forName("com.atguigu.java.Person");
//        clazz3 = Class.forName("java.lang.String");
        System.out.println(clazz3);
        
        //方式四:ClassLoader 了解    类加载器的作用就是把类(cllas)装载进内存中   具体到JVM学类加载器，有三个
        


		2）创建对象（基于上一步）
            //方式一：直接Class对象API newInstance()
      	    // 获取Class对象
            Class<?> clazz = MyClass.class;
            // 创建对象
            Object obj = clazz.newInstance();
            

			//方式二：通过Class对象获取构造对象，调用构造对象同名方法 newInstance()
			// 获取Class对象
            Class<?> clazz = MyClass.class;
            // 获取构造函数
            Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
            // 创建对象
            Object obj = constructor.newInstance("example", 123);
            
        
        需要学习JVM
        
        // m = 0  m = 300  finally:m = 100
        class A {
            static {
                m = 300;
            }
            static int m = 100;
        }
        
        // m = 300
        class A {
            static int m = 100;
            static {
                m = 300;
            }
        }
        
        
        
        
        在javabean中要求提供一个public的空参构造器。原因：
        1.便于通过反射，创建运行时类的对象
        2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
        
        
        
        
    有些东西封装好了直接用就好了，像api像后面导入的第三方开源jar包。就像以后自己有孩子了不可能学语言让他从甲骨文开始，人的精力有限，不要过于深究。知道这个干这个用的就好。

    Spring: IOC容器(依赖注入)  AOP(动态代理)
    懂反射更好的理解框架的地层实现
    
    
    
    代理模式 

    代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 
    
    代理模式一般涉及到的角色有： 
    
    抽象角色：声明真实对象和代理对象的共同接口； 
    
    代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 
    
    真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
    
    
    
    
    多敲代码才能理解
    
    静态代理例子：
    
    class MyThread implements Runnable{} //被代理类
    class Thread implements Runnable{} //代理类
    
    main() {
        MyThread t = new MyThread();
        Thread thread = new Thread(t);
        thread.start(); //启动线程，调用线程的run()
    }

    * java内置的4大核心函数式接口
    *
    * 消费型接口 Consumer<T>     void accept(T t)
    * 供给型接口 Supplier<T>     T get()
    * 函数型接口 Function<T,R>   R apply(T t)
    * 断定型接口 Predicate<T>    boolean test(T t)

    
    方法引用：
    Consumer中的void accept(T t)
    PrintStream中的void println(T t)
    发现这两个刚好匹配上了(返回值，形参个数类型都一样)
    又 System.out的类型为PrintStream (PrintStream ps = System.out;)
    则可以 System.out::println

    Stream API可以对集合数据进行操作，就类似SQL执行数据库查询
    
    像mysql这种关系型数据库，一些过滤操作之类的都可以用sql语句实现，实现完后给java。
    但是MongDB，Radis等，这种NoSQL的数据就需要到java层面处理过滤，这时用Stream API
    
    Collection关注的是数据的存储，跟内存打交道
    Stream关注的数据的运算，跟CPU打交道
    
    方式一：
    针对集合 Collection中两个default方法:
    stream() 顺序流
    parallelStream() 并行流：并行操作
    
    方式二：
    针对数组需要用Arrays有静态方法
    
    方式三：
    Stream of()
    
    方式四：创建无限流（了解）
        //迭代
//      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);


        //生成
//      public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
        
        
        
        
        map()映射就像hashMap根据K,V映射，这个方法可以根据你给定的规则映射
        Reduce()规约例如把映射的信息做一个sum，计算1-10的自然数的和可以用这个
        
        
        
        
        Optional类可以避免空指针异

class People {
	People(String s) {
	}
}

public class StudyTest extends People {
    //此时这个类会报错
    //没有为缺省构造函数定义隐式超构造函数 People（）。必须定义显式构造函数
    
    //必须加以下
    StudyTest(String s) {
		super(s);
	}
}





以下是默认情况：
class People {
}

public class StudyTest extends People {
}
会默认的在StudyTest默认的构造函数中，默认调super()

package com.example.spring_boot;

/**
 * @author XD
 * 2020/8/10 23:06
 **/
public class Example {
    String str = "good";
    char[] ch = {'a', 'b', 'c'};

    int a = 1;
    String b = "a";

    public static void main(String[] args) {
        Example ex = new Example();
        ex.change(ex.str, ex.ch); //good and  abc
        System.out.println(ex.str + "and");
        System.out.println(ex.ch);

        ex.change2();
        System.out.println(ex.a + "  " + ex.b); //2,b
    }

    private void change2() {
        a = 2;
        b = "b";
    }

    private void change(String str, char[] ch) {
        str = "test ok";
        ch = new char[]{'g'};
//        ch[0] = 'g';
    }
}




看下面这个简单的例子：答案是1

public static void main(String[] args) {
        int[] ary = new int[] {1,2,3,4,5};
        change(ary);
        System.out.println(ary[0]);
    }

    public static void change(int[] i) {
        i = new int[] {6};
    }