看了下java基础，还是有不少收获的。

其实仔细想想，也只是抛砖引玉，要想更深层次理解，还要看jdk文档。

记录如下。

//数组的声明及赋值（数组大小确定后，系统先为数组赋默认值）
        //常见异常，数组越界异常
        int[] sorces = null;
        int[] socres2 = new int[10];
        float[] prices = {10.01f,45.78f};
        float[] prices2 = new float[]{11.01f,46.78f};
       
        //new 对象时,内存变化分析：Person p = new Person("Tom",18);
       
        //实参，形参
        //a,b实参，i,j形参
        int result = p2.add(a,b);
        int add(int i,int j){
                return i+j;
        }
       
        //this,super
        //this指的是属于本类的对象，当前类的一个对象的引用，是调用当前方法的那个对象的引用
        //super指的是此类的父类对象， super()父类对象的空的构造器
        //this(),super()不能同时在一个构造方法中出现；只能在构造方法的第一句出现
        public Class Boy entends Person{
                private String name;
                //get,set方法
                public Boy(){
                }
                public Boy(String name){
                        super();
                        this.name = name;
                }
                public void marry(Girl girl){
                        System.out.println(girl.getName());
                        girl.shout(this);
                }
        }
       
        //访问控制
        //private 本类使用
        //default 本类，同一个包 访问
        //protected 本类，同一个包，子类
        //public 本类，同一个包，子类，整体。不受限制，谁都可以访问，公开的
       
        //static 修饰类后，可以不创建对象就访问；也可以创建对象，通过对象访问
        //static 只能访问类的static属性，不能访问非static属性。static方法中不能含有this
        //B继承A，AB，都含有静态代码块，非常静态代码块，空构造
        //则创建B的对象的，访问顺序：访问父类A各静态代码块，B静态代码块，A非静态代码块，A构造，B非静态代码块，B构造
       
        //单例模式（在系统中，此类只有一个对象）
        //私有空构造 ，私有new 对象，公开访问方法，返回对象

        //final标记的变量，只能被赋值一次；且可在声明时或者构造方法中显式赋值，才能使用。
       
        //抽象类（父类设计得非常抽象，抽象到它没有具体的实例）
        //特点：只有方法声明，没有方法实现，以分号结束；不能被实例化；不能有私有方法，构造方法，静态方法
       
        //接口，接口之前可以继承
        接口和抽象类有什么区别
        你选择使用接口和抽象类的依据是什么？

        接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。
        抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。
        人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.
        所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。
        总结几句话来说：
        1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
        2、抽象类要被子类继承，接口要被类实现。
        3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
        4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
        5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
        6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
        7、抽象类里可以没有抽象方法
        8、如果一个类里有抽象方法，那么这个类只能是抽象类
        9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
        10、接口可继承接口，并可多继承接口，但类只能单根继承。

        1.抽象类 和 接口 都是用来抽象具体对象的. 但是接口的抽象级别最高
        2.抽象类可以有具体的方法 和属性,  接口只能有抽象方法和不可变常量
        3.抽象类主要用来抽象类别,接口主要用来抽象功能.
        4、抽象类中，且不包含任何实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的。

        当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
        抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的
        所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。
       
        //异常（关键是异常名，见名就知异常是什么）
        //自定义异常：1.继承 RuntimeException 2.空构造 3.带参构造
        //重写方法不能抛出比父类更大的异常（类比做生意时你谈好的条件让子签合同，不能再加过分的条款）
        //捕获异常时先小后大，否则编译不通过
       
        //容器Collection
        //公有方法clear();remove(obj),通过equals()方法查询元素是否存在。若存在，则移除;
        //add(obj);size();removeAll(Collection);移除相同的；retainAll(Collection) 保存相同的
        //isEmpty();toArray();toArray(T[] a)
        //遍历元素：1.for 2.迭代器
       
        //set集合（不允许有相同的元素，判断两对象是否相等用equals方法）
        //HashSet 根据hashCode()存放元素，所以不能保证元素的顺序
        //LinkedHashSet hashCode()存放元素，但用链表来维护次序，所以 可以保证插入次序
//treeSet 元素处于排序状态，实现了SortedSet接口
        //两种排序，自然排序（实现Comparator接口，实现compare方法）和定制排序(集合中的元素必须实现Comparable接口，实现compareTo方法)，默认使用自然排序



---------------------
【转载，仅作分享，侵删】
作者：xinyuebaihe
原文：https://blog.csdn.net/xinyuebaihe/article/details/77825987
版权声明：本文为博主原创文章，转载请附上博文链接！

奈斯，感谢分享