自己學習用記錄

java 初始化順序

image.png

clone 方法

在函數(shù)調用或“=”時：
基本數(shù)據(jù)類型：按值傳遞
其他類型：按引用傳遞

深復制：

image.png

image.png

super.clone()用來復制基本數(shù)據(jù)類型
深復制內容需手動復制

抽象和接口

抽象類不可實例化自脯，有一個抽象方法就是抽象類
接口中的方法只能是public abstract（可以不寫或寫一部分）丈氓，成員變量只能是public static final
抽象類的成員變量默認為default兼砖，抽象類的抽象方法不能用private/static/native/synhronized 修飾，并必須以 : 結尾

多態(tài)

編譯時多態(tài)：重載
運行時多態(tài)：重寫

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 灌危，方法才有多態(tài)，成員變量沒有
        father.number();  //child碳胳，重寫
        //father.number2();報錯,并沒有重寫勇蝙，調用私有函數(shù)出錯
        child.geta();  //2
        System.out.println(child.b);  //2
        child.number();  //child，重寫
        child.number2();  //child挨约，并沒有重寫味混，調用子類的函數(shù)
}
}

內部類

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成員和靜態(tài)成員）产雹。
            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對象來創(chuàng)建
        inclass.print();
        //如果成員內部類Inner用private修飾，則只能在外部類的內部訪問翁锡，
        //如果用public修飾蔓挖，則任何地方都能訪問；
        //如果用protected修飾馆衔，則只能在同一個包下或者繼承外部類的情況下訪問瘟判；
        //如果是默認訪問權限，則只能在同一個包下訪問角溃。
        //非靜態(tài)內部類不能有static成員
    }
}
//輸出：1 1 0 private 1 1 0

2.靜態(tài)內部類
靜態(tài)內部類在類的前面多了一個關鍵字static拷获。靜態(tài)內部類是不需要依賴于外部類而實例化，并且它不能使用外部類的非static成員變量或者方法减细，如果允許訪問外部類的非static成員就會產生矛盾匆瓜，因為外部類的非static成員必須依附于具體的對象。

創(chuàng)建靜態(tài)內部類對象的一般形式為： 外部類類名.內部類類名 xxx = new 外部類類名.內部類類名()
創(chuàng)建成員內部類對象的一般形式為： 外部類類名.內部類類名 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();
    }
}
//一般使用匿名內部類的方法來編寫事件監(jiān)聽代碼,或者臨時重寫一個方法

final又碌、finally、finalize區(qū)別

final：聲明
finally：關閉數(shù)據(jù)庫資源
finalize：垃圾回收相關

assert斷言

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

volatile

讀取變量時從內存中讀取非緩存绊袋，不可替代syhronized
可以用來設置一個變量毕匀，用于立刻終止線程

image.png

instanceof

判斷左邊的對象是否是他右邊的類的實例
result=object instanceof class

strictfp

聲明的類、接口癌别、方法保證浮點數(shù)的精度

基本數(shù)據(jù)類型

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.構造函數(shù)為private掘殴，防止調用

    }
    public static synchronized SingletonDemo getInstance(){//3.synchronized赚瘦，線程安全，并返回自身
        if(instance==null){//4.有一個if奏寨，保證實例化一次
            instance=new SingletonDemo();//5.類中調用自身構造函數(shù)
        }
        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();//這里一般是函數(shù)傳進來
        clazz = obj.getClass();
        System.out.println(clazz.getName());


        //3.通過全類名(會拋出異常)
        //一般框架開發(fā)中這種用的比較多，因為配置文件中一般配的都是全類名套菜，通過這種方式可以得到Class實例
        String className="reflexA";
        try {
            clazz = Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        /////////////////////////////////////////////////////
        System.out.print("方法測試\n");
        //1.獲取方法
        // 1.1 獲取取clazz對應類中的所有方法--方法數(shù)組（一）
        // 不能獲取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.獲取所有方法亲善，包括私有方法 --方法數(shù)組（二）
        //  所有聲明的方法，都可以獲取到逗柴，且只獲取當前類的方法
        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.獲取指定的方法
        //  需要參數(shù)名稱和參數(shù)列表蛹头，無參則不需要寫
        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是獲取不到的，因為方法的參數(shù)類型是int型
            //  如果方法用于反射戏溺，那么要么int類型寫成Integer： public void setAge(Integer age) {  }
            //  要么獲取方法的參數(shù)寫成int.class
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }


        ///////////////////////////////////////////////
        System.out.print("執(zhí)行測試\n");
        //2.執(zhí)行方法
        //  invoke第一個參數(shù)表示執(zhí)行哪個對象的方法渣蜗，剩下的參數(shù)是執(zhí)行方法時需要傳入的參數(shù)
        Object obje = null;
        try {
            obje = clazz.newInstance();
            try {
                //method.setAccessible(true);//如果執(zhí)行為私有方法，不會執(zhí)行于购，需要抑制Java的訪問控制檢查
                method.invoke(obje,2);

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


        //如果一個方法是私有方法袍睡，第三步是可以獲取到的知染，但是這一步卻不能執(zhí)行
        //私有方法的執(zhí)行肋僧，必須在調用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程序員面試筆記寶典-何昊