自己学习用记录

java 初始化顺序

image.png

clone 方法

在函数调用或“=”时：
基本数据类型：按值传递
其他类型：按引用传递

深复制：

image.png

image.png

super.clone()用来复制基本数据类型
深复制内容需手动复制

抽象和接口

抽象类不可实例化，有一个抽象方法就是抽象类
接口中的方法只能是public abstract（可以不写或写一部分），成员变量只能是public static final
抽象类的成员变量默认为default，抽象类的抽象方法不能用private/static/native/synhronized 修饰，并必须以 : 结尾

多态

编译时多态：重载
运行时多态：重写

import java.util.Scanner;
class Father{
    private int a=1;
    public  int b=1;
    public void geta(){
        System.out.println(this.a);
    }
    public void number(){
        System.out.println("father");
    }
    private void number2(){
        System.out.println("father");
    }
}
class Child extends Father{
    private int a=2;
    public  int b=2;
    public void geta(){
        System.out.println(this.a);
    }
    public void number(){
        System.out.println("child");
    }
    public void number2(){
        System.out.println("child");
    }
}

public class Main1{
    public static void main(String arg[]){
        Father father=new Child();
        Child child=new Child();
        //测试
        father.geta();  //2
        System.out.println(father.b);  //1 ，方法才有多态，成员变量没有
        father.number();  //child，重写
        //father.number2();报错,并没有重写，调用私有函数出错
        child.geta();  //2
        System.out.println(child.b);  //2
        child.number();  //child，重写
        child.number2();  //child，并没有重写，调用子类的函数
}
}

内部类

1.成员内部类

import java.util.Scanner;
class Outclass {
    private int a = 0;
    private int b = 0;


    public Outclass(int a) {
        this.a = a;
        Inclass onclass=new Inclass();//必须新建内部类对象来调用
        onclass.print();
        onclass.print2();
    }

    class Inclass {     //内部类
        private int b = 1;
        public void print() {
            System.out.println(a);//成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
            System.out.println(b);
            System.out.println(Outclass.this.b);//内部类拥有和外部类同名,需要：外部类.this.成员变量/方法
        }
        public void print2() {
            System.out.println("private");
        }
    }
}

public class Main1{
    public static void main(String arg[]){
        Outclass outclass=new Outclass(1);
        Outclass.Inclass inclass=outclass.new Inclass();//必须通过outclass对象来创建
        inclass.print();
        //如果成员内部类Inner用private修饰，则只能在外部类的内部访问，
        //如果用public修饰，则任何地方都能访问；
        //如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；
        //如果是默认访问权限，则只能在同一个包下访问。
        //非静态内部类不能有static成员
    }
}
//输出：1 1 0 private 1 1 0

2.静态内部类
静态内部类在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类而实例化，并且它不能使用外部类的非static成员变量或者方法，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

创建静态内部类对象的一般形式为： 外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
创建成员内部类对象的一般形式为： 外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
3.局部内部类
局部内部类就像是方法里面的一个局部变量一样，不能有public、protected、private以及static修饰符的。

class People{
    public People() {
    }
}
class Man{
    public Man(){
    }
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

4.匿名内部类

abstract class parent {
public abstract void like();
}
public class Demo {
    public static void main(String[] args) {
        parent pt = new parent(){
            public void like(){
                System.out.println("吃饭睡觉打豆豆。。。");
            }
        };
        pt.like();
    }
}
//一般使用匿名内部类的方法来编写事件监听代码,或者临时重写一个方法

final、finally、finalize区别

final：声明
finally：关闭数据库资源
finalize：垃圾回收相关

assert断言

https://www.cnblogs.com/binbang/p/6386780.html

volatile

读取变量时从内存中读取非缓存，不可替代syhronized
可以用来设置一个变量，用于立刻终止线程

image.png

instanceof

判断左边的对象是否是他右边的类的实例
result=object instanceof class

strictfp

声明的类、接口、方法保证浮点数的精度

基本数据类型

null:表明引用没有对象，对空对象做任何操作都不行,但实际是置0；
String s=null;只是定义了一个句柄，也就是说你有了个引用，但是这个引用未指向任何内存空间
String s="";这个引用已经指向了一块是空字符串的内存空间，是一个实际的东东了，所以你可以对它操作，而不用担心什么了
float c=1.4;//错误，默认为double
Float d=1.4;//错误，默认为double
boolean a =null//错误，只能二选一
Boolean a=null;//正确,但null作为if的条件会报npe

值传递和引用传递

https://www.zhihu.com/question/31203609

public class littertest {
    public static void main(String arg[]){
        String s1="abc";
        String s2="abc";
        String s3=new String("abc");
        String s4=new String("abc");
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s3==s4);//false
    }
}

public class littertest {
    public static void main(String arg[]){
        changeclass aa=new changeclass();
        dataclass bb=new dataclass();
        dataclass cc=bb;
        aa.change(bb);
        int hascode1=bb.hashCode();
        int hascode2=cc.hashCode();
        System.out.println(bb.a);//2,值被改变
        System.out.println(hascode1==hascode2);//true，证明是引用同一个内存

    }
}
class dataclass {
    int a=1;
        }
class changeclass{
    public  void change(dataclass a){
        a.a=2;
    }

        }

image.png

拆箱装箱

https://blog.csdn.net/diyinqian/article/details/78899740

public class littertest {
    public static void main(String arg[]){
        Integer a=144;
        Integer b=144;
        b=a;//去掉结果为false
        System.out.println(a==b);
    }
}
//结果为true，b和a的引用一致，==比较引用，equals()比较的是值(如果类没有重写equals，则比较引用)，hashCode()返回对象在内存中的地址转换的int，不同对象不同,指向同一个对象的相同。

包装类和String都是不可变类

short s=1;
s=s+1//错误,s->int,int不能再转为short
s+=1//正确，Java做了特殊处理

>> 有符号右移动，高位补0或1
>>>无符号右移动，高位补0
<< 低位补0

内存泄漏

image.png

image.png

容器和迭代器

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class littertest {
    public static void main(String arg[]){
        List<String> list=new LinkedList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        Iterator<String> ite=list.iterator();
        Iterator<String> ite2=list.iterator();
        while(ite.hasNext()) {//hasNext(),判断是否有下一个元素
            String a=ite.next();
            System.out.println(a);//next()取下一个元素，
        }
        while(ite2.hasNext()) {//对JAVA集合进行遍历删除时务必要用迭代器,会抛出ConcurrentModificationException异常
            String a=ite2.next();
            if(a.equals("2"))
                ite2.remove();
            System.out.println(a);//next()取下一个元素，
        }
        Iterator<String> ite3=list.iterator();//注意如果在删除前定义，一样会抛出ConcurrentModificationException异常
        while(ite3.hasNext()) {//hasNext(),判断是否有下一个元素
            String a=ite3.next();
            System.out.println(a);//next()取下一个元素，
        }

    }
}
//结果：1 2 3 4 1 2 3 4 1 3 4 ，第三次遍历去掉了2

容器：

image.png

hashmap使用注意，案例位于书150-153页

image.png

单例模式要点：

class SingletonDemo {
    private static SingletonDemo instance; //1.类中定义自己
    private SingletonDemo(){  //2.构造函数为private，防止调用

    }
    public static synchronized SingletonDemo getInstance(){//3.synchronized，线程安全，并返回自身
        if(instance==null){//4.有一个if，保证实例化一次
            instance=new SingletonDemo();//5.类中调用自身构造函数
        }
        return instance;
    }
}

java中类加载时机

反射

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class reflex {
    public static void main(String arg[]){
        System.out.print("类测试\n");

        Class clazz = null;
        //1.通过类名
        clazz = reflexA.class;

        //2.通过对象名
        //这种方式是用在传进来一个对象，却不知道对象类型的时候使用
        reflexA a = new reflexA();
        clazz = a.getClass();
        //上面这个例子的意义不大，因为已经知道person类型是Person类，再这样写就没有必要了
        //如果传进来是一个Object类，这种做法就是应该的
        Object obj = new reflexA();//这里一般是函数传进来
        clazz = obj.getClass();
        System.out.println(clazz.getName());


        //3.通过全类名(会抛出异常)
        //一般框架开发中这种用的比较多，因为配置文件中一般配的都是全类名，通过这种方式可以得到Class实例
        String className="reflexA";
        try {
            clazz = Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        /////////////////////////////////////////////////////
        System.out.print("方法测试\n");
        //1.获取方法
        // 1.1 获取取clazz对应类中的所有方法--方法数组（一）
        // 不能获取private方法,且获取从父类继承来的所有方法
        System.out.print("方法测试1\n");
        Method[] methods = clazz.getMethods();
        for(Method method:methods){
            System.out.print(" "+method.getName());
        }
        System.out.println();

        System.out.print("方法测试2\n");
        //  1.2.获取所有方法，包括私有方法 --方法数组（二）
        //  所有声明的方法，都可以获取到，且只获取当前类的方法
        methods = clazz.getDeclaredMethods();
        for(Method method:methods){
            System.out.print(" "+method.getName());
            //得到方法返回类型的类类型
            Class returnType = method.getReturnType();
            System.out.print(" "+returnType.getName());
        }
        System.out.println();

        System.out.print("方法测试3\n");
        //
        //  1.3.获取指定的方法
        //  需要参数名称和参数列表，无参则不需要写
        Method method = null;
        try {
            //  对于方法public void setName(String name) {  }
            method = clazz.getDeclaredMethod("setName", String.class);
            System.out.println(method);
            //  而对于方法public void setAge(int age) {  }
            method = clazz.getDeclaredMethod("setAge", int.class);
            System.out.println(method);
            //  如果写Integer是获取不到的，因为方法的参数类型是int型
            //  如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) {  }
            //  要么获取方法的参数写成int.class
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }


        ///////////////////////////////////////////////
        System.out.print("执行测试\n");
        //2.执行方法
        //  invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数
        Object obje = null;
        try {
            obje = clazz.newInstance();
            try {
                //method.setAccessible(true);//如果执行为私有方法，不会执行，需要抑制Java的访问控制检查
                method.invoke(obje,2);

            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }


        //如果一个方法是私有方法，第三步是可以获取到的，但是这一步却不能执行
        //私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;
    }
}

class reflexA{
    public static final int stfl=0;
    public static int st=0;
    public int publica=0;
    private int privatea=0;
    static{
        System.out.println("static zero");
    }
    public static void staticmethod(){
        System.out.println("staticmethod");
    }
    public void method(){
        System.out.println("method");
    }
    public reflexA(){
        System.out.println("structurereflexA");
    }
    private void privatemethod(){
        System.out.println("privatemethod");
    }
    public void setName(String name) {
        System.out.println("setName");
    }
    public void setAge(int age) {
        System.out.println("setAge");
    }
}

JAVA装饰者模式

https://www.cnblogs.com/panhouye/p/6120232.html

信号量和PV操作

https://www.cnblogs.com/lavenderzh/p/5324961.html

来自书：java程序员面试笔记宝典-何昊