【Java基础篇】（更新中）

JAVA基础篇

public class Java基础篇 {
    public static void main(String[] args) {
        //强引用
        //强引用是平常中使用最多的引用，强引用在程序内存不足（OOM）的时候也不会被回收
        String str = new String("str");
        System.out.println(str);
        //软引用
        //软引用在程序内存不足时，会被回收，使用方式：
        SoftReference<String> srf = new SoftReference<String>(new String("str"));
        //可用场景： 创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。
        //弱引用
        //弱引用就是只要JVM垃圾回收器发现了它，就会将之回收，使用方式：(例如：WeakHashMap)
        WeakReference<String> wrf = new WeakReference<String>(str);
        //可用场景： Java源码中的 java.util.WeakHashMap 中的 key 就是使用弱引用，我的理解就是，
        //一旦我不需要某个引用，JVM会自动帮我处理它，这样我就不需要做其它操作。

        //虚引用
        //PhantomReference<String> prf = new PhantomReference<String>(new String("str"),
        //new ReferenceQueue<>());
        //被回收之前，会被放入 ReferenceQueue 中
        //可用场景： 对象销毁前的一些操作，比如说资源释放等。 Object.finalize() 虽然也可以做这
        //类动作，但是这个方式即不安全又低效
    }
    //Java创建对象的几种方式
        //new创建新对象
        //通过反射机制
        //采用clone机制
        //通过序列化机制

    //深拷贝和浅拷贝的区别
        //浅拷贝:被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指
            //向原来的对象.换言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象.
        //深拷贝:被复制对象的所有变量都含有与原来的对象相同的值.而那些引用其他对象的变量将指向
            //被复制过的新对象.而不再是原有的那些被引用的对象.换言之.深拷贝把要复制的对象所引用的对象都复制了一遍.


    //final有哪些用法
        //被final修饰的类不可以被继承
        //被final修饰的方法不可以被重写
        //被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.
        //被final修饰的方法,JVM会尝试将其内联,以提高运行效率
        //被final修饰的常量,在编译阶段会存入常量池中

    //Static用法
        //静态变量 静态方法 静态块 静态内部类

        // 静态导包
        //是在JDK 1.5之后引入的新特性,可以用来指定导入某个类中的静态资源,并且不需要使用类名,可以直接使用资源名
    public void test() {
        //System.out.println(Math.sin(20));传统做法
        System.out.println(sin(20));

        //3*0.1 == 0.3返回值是什么
        System.out.println( 3 * 0.1 == 0.3 ); //fales


    // a = a + b 与 a += b 有什么区别吗?

    //+= 操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,
    // 而a=a+b则不会自动进行类型转换.如：
        //byte a = 127;
        //byte b = 127;
        //b = a + b; // 报编译错误:cannot convert from int to byte
        //b += a;
        //short s1 = 1; // s1 short 型  s1 + 1 int 型
        //s1 = s1 + 1; // 类型不一致
        //s1 += 1; 正确写法

    //try catch finally，try里有return，finally还执行么？
        //执行，并且finally的执行早于try里面的return
        //结论：
            //1、不管有木有出现异常，finally块中代码都会执行；
            //2、当try和catch中有return时，finally仍然会执行；
            //3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的
                //值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），
                //所以函数返回值是在finally执行前确定的；
            //4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
    //---------------------------------------------------------------------
    //Excption与Error包结构
        //Java可抛出(Throwable)的结构分为三种类型：
            //被检查的异常(CheckedException)
                //定义:Exception类本身，以及Exception的子类中除了"运行时异常"之外的其它子类都属于被检查异常
                //特点:Java编译器会检查它。 此类异常，要么通过throws进行声明抛出，要么通过try-catch进行捕获处理，否则不能通过编译
                //例如，CloneNotSupportedException就属于被检查异常。
                    //IOException
                    //FileNotFoundException
                    //SQLException
            //运行时异常(RuntimeException)
                //定义:RuntimeException及其子类都被称为运行时异常。
                //特点:Java编译器不会检查它。
                //例如:除数为零时产生的ArithmeticException异常
                        //数组越界时产生的IndexOutOfBoundsException异常
                        //fail-fast机制产生的ConcurrentModificationException异常
                //常见的五种运行时异常：
                    //ClassCastException（类转换异常）
                    //IndexOutOfBoundsException（数组越界）
                    //NullPointerException（空指针异常）
                    //ArrayStoreException（数据存储异常，操作数组是类型不一致）
                    //BufferOverflowException
            //错误(Error)
                //定义 : Error类及其子类。
                //特点 : 和运行时异常一样，编译器也不会对错误进行检查。
                //例如，VirtualMachineError就属于错误。出现这种错误会导致程序终止运行。
                    //OutOfMemoryError、ThreadDeath。
    //---------------------------------------------------------------------
    //OOM你遇到过哪些情况，SOF你遇到过哪些情况
        //OOM (OutOfMemoryError)
            //1，Java Heap 溢出：
            //2，虚拟机栈和本地方法栈溢出
            //3，运行时常量池溢出
            //4，方法区溢出
        //SOF(堆栈溢出StackOverflow)
            //StackOverflowError 的定义：当应用程序递归太深而发生堆栈溢出时，抛出该错误。
            //栈溢出的原因：递归调用，大量循环或死循环，全局变量是否过多，数组、List、map数据过大。
    //---------------------------------------------------------------------
    //简述线程、程序、进程的基本概念。以及他们之间关系是什么?
        //TODO

    //Java 序列化中如果有些字段不想进行序列化，怎么办？
        //对于不想进行序列化的变量，使用 transient 关键字修饰。
        //transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，
        //被 transient 修饰的变量值不会被持久化和恢复。transient 只能修饰变量，不能修饰类和方法。




    //说说Java 中 IO 流
        //Java 中 IO 流分为几种?
            //按照流的流向分，可以分为输入流和输出流；
            //按照操作单元划分，可以划分为字节流和字符流；
            //按照流的角色划分为节点流和处理流。
            //Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。
                //InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
                //OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
        // Java IO与 NIO的区别（补充）
            //NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，
            //NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO
                //①针对标准输入输出NIO，
                //②网络编程NIO。



    //java反射的作用于原理
        //定义:反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意个对象，都能够调用它的任意一个方法。
            //在java中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。
            //这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
        //哪里会用到反射机制？
            //jdbc就是典型的反射
                //Class.forName('com.mysql.jdbc.Driver.class');//加载MySQL的驱动类
        //反射的实现方式：
            //第一步：获取Class对象，有4中方法：
            // 1）Class.forName(“类的路径”)；
            // 2）类名.class
            // 3）对象名.getClass()
            // 4）基本类型的包装类，可以调用包装类的Type属性来获得该包装类的Class对象
        //实现Java反射的类：
            // 1）Class：表示正在运行的Java应用程序中的类和接口 注意： 所有获取对象的信息都需要Class类来实现。
            // 2）Field：提供有关类和接口的属性信息，以及对它的动态访问权限。
            // 3）Constructor：提供关于类的单个构造方法的信息以及它的访问权限
            // 4）Method：提供类或接口中某个方法的信息
        //反射机制的优缺点：
            //优点： 1）能够运行时动态获取类的实例，提高灵活性；
            //      2）与动态编译结合
            //缺点： 1）使用反射性能较低，需要解析字节码，将内存中的对象进行解析。
            //解决方案：1、通过setAccessible(true)关闭JDK的安全检查来提升反射速度；
                    //2、多次创建一个类的实例时，有缓存会快很多
                    //3、//ReflectASM工具类，通过字节码生成的方式加快反射速度
                        //2）相对不安全，破坏了封装性（因为通过反射可以获得私有方法和属性）

    //说说List,Set,Map三者的区别
        //List(对付顺序的好帮手)： List接口存储一组不唯一（可以有多个元素引用相同的对象），有序的对象
        //Set(注重独一无二的性质): 不允许重复的集合。不会有多个元素引用相同的对象。
        //Map(用Key来搜索的专家): 使用键值对存储。Map会维护与Key有关联的值。
            //两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。
    }
}