Java基础总结

1、JVM、JRE和JDK的区别：
    JVM:java虚拟机，用于保证java的跨平台的特性。
                  java语言是跨平台，jvm不是跨平台的。
    JRE:java的运行环境,包括jvm+java的核心类库。    
    JDK:java的开发工具,包括jre+开发工具

2、环境变量path和classpath的作用是什么？
    (1)path是配置Windows可执行文件的搜索路径，即扩展名为.exe的程序文件所在的目录，
       用于指定DOS窗口命令的路径。
    (2)Classpath是配置class文件所在的目录，用于指定类搜索路径，JVM就是通过它来寻找该类的class类文件的。  

3、构造代码块：
    (1)作用：给对象进行初始化，对象一建立就执行，而且优先于构造函数执行
    (2)构造代码块和构造函数的区别：
        构造代码块是给所有不同对象的共性进行统一初始化
        构造函数是给对应的对象进行初始化 

4、this关键字
    (1)this关键字代表本类对象的一个引用，谁调用this所在的方法，this就代表谁  
    (2)this的使用场景
        A:用于区分同名成员变量和局部变量；
        B:在定义函数时，该函数内部要用到调用该函数的对象时，因为此时对象还没建立，故this代表此对象
        B:构造函数间调用
            **这个时候，this(参数)必须作为第一条语句存在。

5、Person p = new Person();在内存中做了哪些事情。
    (1)将Person.class文件加载进内存中。
    (2)如果p定义在主方法中，那么，就会在栈空间开辟一个变量空间p。
    (3)在堆内存给对象分配空间。
    (4)对对象中的成员进行默认初始化。
    (5)对对象中的成员进行显示初始化。
    (6)调用构造代码块对对象进行初始化。(如果没有就不执行)
    (7)调用构造方法对对象进行初始化。对象初始化完毕。
    (8)将对象的内存地址赋值给p变量，让p变量指向该对象。

6、static关键字：
    (1)静态的意思，用来修饰成员变量和成员函数
    (2)静态的特点:
        随着类的加载而加载
        优先于对象存在
        对所有对象共享
        可以被类名直接调用
    (3)静态的注意事项
        A:静态方法只能访问静态成员
            为什么：因为静态的内容是随着类的加载而加载，它是先进内存的。
        B:静态方法中不能使用this,super关键字
        C:主方法是静态的
            public static void main(String[] args)
            public:公共的意思，是最大权限修饰符。
            static:由于jvm调用main方法的时候，没有创建对象。
                   只能通过类名调用。所以，main必须用static修饰。
            void:由于main方法是被jvm调用，不需要返回值。用void修饰。
            main:main是主要的意思，所以jvm采用了这个名字。是程序的入口。

            String[]:字符串数组
            args:数组名

            在运行的时候，通过java命令给args数组赋值。
            格式：java MainTest hello world itcast
    (4)静态变量和成员变量的区别
        A：调用方式
            静态变量也称为类变量，可以直接通过类名调用。也可以通过对象名调用。
            这个变量属于类。
            成员变量也称为实例变量，只能通过对象名调用。这个变量属于对象。
        B：存储位置
            静态变量存储在方法区长中的静态区。
            成员变量存储在堆内存。
        C：生命周期
            静态变量随着类的加载而存在，随着类的消失而消失。生命周期长。
            成员变量随着对象的创建而存在，随着对象的消失而消失。
        D：与对象的相关性
            静态变量是所有对象共享的数据。
            成员变量是每个对象所特有的数据。
    (5)静态的优点和弊端
        优点：
        对对象的共享数据进行单独空间的存储，节省内存，没有必要每个对象都存储一份
        可直接被类名调用
        弊端：
        生命周期过长，随着类的消失而消失
        访问出现权限，即静态虽好但只能访问静态
    (6)什么使用使用静态呢？
        A:当所有对象共享某个数据的时候，就把这个成员变量定义为静态修饰的。
        B:当某个方法没有访问该类中的非静态成员，就可以把这个方法定义为静态修饰。

        静态的生命周期比较长，所以一般不推荐使用。
    (7)静态代码块
        A:它只执行一次，它比main还先执行。
        B:执行顺序
            静态代码块--构造代码块--构造方法

7、单例设计模式：
    (1)设计模式：
        解决某类问题行之有效的方法，是一种思想，是规律的总结
    (2)用来保证某个类在内存中只有一个对象
    (3)保证唯一性的思想及步骤
        **为了避免其他程序建立该类对象，先禁止其他程序建立该类对象，即将构造函数私有化
        **为了其他程序访问到该类对象，须在本类中创建一个该类私有对象
        **为了方便其他程序访问到该类对象，可对外提供一个公共访问方式

    比如API中的Runtime类就是单例设计模式。

    (4)单例设计模式的两种方式
        A:饿汉式 当类加载的时候，就创建对象。    
        class Student
        {
            private Student(){}
            
            private static final Student s = new Student();
            
            public static Student getInstance()
            {
                return s;
            }
        }
        B:懒汉式 当使用的使用，才去创建对象。
        class Student
        {
            private Student(){}

            private static final Student s = null;
            
            public static Student getInstance()
            {
                if(s==null) 
                {
                    //线程1就进来了，线程2就进来了。
                    s = new Student();
                }
                return s;
            }
        }
    饿汉式和懒汉式的区别：
        **
        饿汉式是类一加载进内存就创建好了对象；
        懒汉式则是类才加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，
        对象才开始创建。
        **
        懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题
        可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，
        所以可以加双重判断来提高程序效率。
        注：开发常用饿汉式，因为饿汉式简单安全。懒汉式多线程的时候容易发生问题

 

8、Scanner类的使用
    (1)可以获取从键盘的输入数据
    (2)掌握内容
        构造方法：
            Scanner(InputStream source) 构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。
            如：Scanner sc = new Scanner(System.in);
        方法摘要
            sc.nextInt();获取整型数据
            sc.nextLine();获取字符串数据

9、继承(重点)
    (1)把很多类的相同特征和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系。
       这样的话，多个类就可以省略很多代码。这个关系就是继承。java中用extends关键字表示。
    (2)继承的体系结构
        A:多个具体的对象，不断的向上抽取共享的内容，最终形成了一个体系。这个体系叫做继承体系。
        B:继承体系的学习和使用原则
            **学习顶层的内容。因为他是整个体系的共性内容。
            **创建子类使用。也就是使用底层的具体对象。
    (3)继承的特点:
        A:java中只能单继承，没有多继承。
        B:java可以有多重(层)继承。
    (4)继承的好处：
        继承的出现提高了代码的复用性。
        继承的出现让类与类之间产生了关系，提供了多态的前提。
    (5)子父类中的成员关系
        A:成员变量
            在子类方法中使用一个变量时：
            首先，在方法的局部变量中找这个变量，有则使用。
            否则，在本类中找成员变量，有则使用。
            否则，在父类中找成员变量，有则使用。
            否则，报错。
        B:成员方法
            用子类对象使用一个方法时。
            首先，在子类中找这个方法，有则使用。
            否则，在父类中找这个方法，有则使用。
            否则，报错。

        重写和重载的区别？
            重载：在同一类中。方法名相同，参数列表不同。重载可以改变返回类型。
            重写：在不同类中(子父类中)。
                  方法声明相同(返回类型，方法名，参数列表均相同)。
        重写需要注意：
            **子类方法的访问权限要大于等于父类方法的访问权限。
            **静态只能重写静态。但是这种情况一般不会出现。

        构造方法
            **子类的实例化过程
                ***子类创建对象时，会先去创建父类的对象。
                    默认是去调用父类的无参构造方法。
                ***子类构造方法中，第一行默认是super()
                ***为什么子类中第一行会默认有super()
                    因为他继承父类的成员使用，使用前这些成员必须初始化，
                    而他们是父类的成员，所以，必须通过父类进行初始化。
                    所以，会先创建一个父类的对象。
            **当父类没有无参构造方法时
                必须使用this或者super调用其他的构造方法。
    (6)this和super的区别
        this:代表本类对象的引用。
        super:代表父类的存储空间。

10、抽象类(重点)
    (1)多个类有相同的方法声明，但是方法体不一样。这个时候，我们考虑把方法声明进行抽取。
       让子类继承后，自己去实现方法体。没有方法体的方法，我们需要用抽象标志下。
       抽象的关键字是：abstract。
    (2)抽象类：
        该方法称为抽象方法，包含抽象方法的类就是抽象类。
    (3)抽象类的特点：
        A:抽象类和抽象方法都要用abstract进行修饰
        B:抽象类不能被实例化
        C:抽象类中不一定有抽象方法，但是，有抽象方法的类一定是抽象类。
    (4)抽象类中数据的特点
        A:成员变量
            抽象类中可以有变量，也可以有常量。
        B:成员方法
            抽象类中可以有抽象方法，也可以有非抽象方法。
        C:构造方法
            抽象类是一个类，所以，它有构造方法。
            虽然本身不能实例化。但是可以给子类实例化使用。
    (5)抽象类中的问题
        A:抽象类中是否有构造方法？能不能被实例化？如果不能，为什么有构造方法？
          抽象类有构造方法。
              抽象类不能被实例化。
          抽象类中的构造方法供子类实例化调用。
        B:抽象关键字abstract不可以和哪些关键字共存？
          **private:
            私有内容子类继承不到，所以，不能重写。
            但是abstract修饰的方法，要求被重写。两者冲突。
              **final
            final修饰的方法不能被重写。
            而abstract修饰的方法，要求被重写。两者冲突。            
          **static
            假如一个抽象方法能通过static修饰，那么这个方法，就可以直接通过类名调用。
            而抽象方法是没有方法体的，这样的调用无意义。所以，不能用static修饰。
        C:抽象类中可不可以没有抽象方法？如果可以，这样的类有什么用吗？
          抽象类可以没有抽象方法。
          抽象类中没有抽象方法的作用，只是为了不让别的类建立该抽象类对象。这个在awt中有体现。
11、接口interface
    (1)当一个类中的方法都是抽象的时候，java提供了另一种表示方式，叫接口。
       用interface关键字表示。类与接口关系用implements表示。
    (2)接口的成员特点
        A:成员变量
            是常量，默认修饰 public static final    
        B:成员方法
            都是抽象的，默认修饰 public abstract    
    (3)关系
        A:类与类的关系
            是继承关系。类与类只能单继承，可以多重继承。
        B:类和接口的关系
            是实现关系。类可以多实现接口。
            类在继承一个类的同时，可以实现多个接口。
        C:接口和接口的关系
            是继承关系。接口可以多继承接口。
    (4)接口的特点
        A:是对外暴露的规则
        B:是功能的扩展
        C:接口的出现降低耦合性。
            耦合(类与类之间的关系)
            内聚(类完成功能的能力)
            编程规范：低耦合，高内聚。
        D:接口可以多实现。如：CPU和主板、笔记本的USB插口、插座
    (5)接口和抽象类的区别
        A：抽象类只能被单继承
           接口可以多实现,接口的出现避免了多继承的局限性。
        B：抽象类中的数据特点：
                成员变量：可以是变量，也可以是常量
                成员方法：可以是抽象方法，也可以是非抽象方法
                构造方法：有构造方法
           接口中的数据特点：
                成员变量：是常量。默认修饰 public static final
                成员方法：都是抽象方法。都有默认修饰 public abstract
                构造方法：没有构造方法
        C：抽象类中定义的是继承体系中的共性功能。
           接口中定义的是继承体系中的扩展功能。
        D：抽象类被继承是"is a"关系:xx是yy的一种
           接口被实现是"like a"关系:xx像yy的一种
12、多态：
    (1)同一个对象，在程序不同时刻的多种运行状态。举例：动物，狗是狗，狗是动物。水(气态，液态，固态)
    (2)多态前提
        A:存在着继承或者实现关系
        B:有方法的重写
        C:父类(接口)引用指向子类(实现)对象
    (3)多态的好处和弊端：
        好处：多态的存在提高了程序的扩展性和后期可维护性
        弊端：虽然可以预先使用，但是只能访问父类中已有的功能，运行的是后期子类的功能内容。
              不能预先使用子类中定义的特有功能。
    (4)多态中对象调用成员的特点
        Fu f = new Zi();
        
        A:成员变量
            编译看左边，运行看左边
        B:成员方法 
            编译看左边，运行看右边
        C:静态方法
            编译看左边，运行看左边
    (5)多态的思想
        指挥同一批对象做事情。举例：带兵打仗，下课等。

13、instanceof关键字
        A:用于判断某个对象是否是某种类型。
        B:格式
            对象名 instanceof 子类(实现)名

14、Object类：
    (1)是所有类的根类，超类。
       java中提供的类以及我们自定义的类都直接或者间接的继承自Object类。
    (2)Object类中的方法
        A:void finalize() 
          当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
        B:Class getClass()
          获取对象的字节码文件的描述类，后面再讲反射的时候还会在说这个类。
          String name = s.getClass().getName();
        C:int hashCode()
          获取对象的哈希值。其实就是对象的内存地址值十进制表示
        D:String toString()
          返回对象的字符串表示。
          表示格式：
          getClass().getName()+"@"+Integer.toHexString(hashCode());

          一般我们输出对象名的时候，其实底层调用的就是该对象的toString()方法。
          这种返回没有意义，所以，我们会重写这个方法，显示类的成员变量信息。
        E:boolean equals(Object obj)
          用于比较两个对象的地址值是否相同。
          我们获取对象后，比较它的地址值意义不大。所以也会对这个方法进行重写。
          重写要完成什么功能，是根据需求定的。
    (3)==和equals的用法：
        A:==怎么用？
            **可以用于比较基本数据类型，比较的就是基本数据类型的值是否相等。
            **可以用于比较引用数据类型，比较的是对象的地址值是否相等。
        B:equals怎么用？
            equals只能用于比较引用数据类型的。
            **Object提供的equals是用于比较对象地址值是否相同。
            **自定义类中，如果重写了equals方法，那么就是按照你自己的需求来比较的。

 

15、内部类(次重点)
    (1)把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。
    (2)访问特点：
        A:内部类可以直接访问外部类中的成员，因为内部类持有外部类的引用，
          格式为：外部类名.this
        B:外部类要想访问内部类的成员，必须创建对象访问。
    (3)内部类的访问格式：
        A:当内部类定义在外部类的成员位置，而且非私有，则可以在其他外部类中直接建立内部类对象
          格式：外部类名.内部类名  变量名 = new 外部类对象.内部类对象
            如：Outer.Inner in = new Outer().new Inner()
        B:当内部类在外部类成员位置，且被static修饰时
            **外部其他类可直接访问静态内部类的非静态成员
              格式：new 外部类名.内部类名().内部类成员
              如：new Outer.Inner().function();
            **外部其他类可直接访问静态内部类的静态成员
              格式：new 外部类名.内部类名.内部类成员
              如：new Outer.Inner.function();
    (4)什么使用时候内部类呢？
        假如有A类和B类，A类想直接访问B类的成员，B类访问A类成员的时候，
        需要创建A类对象进行访问，这个时候，就可以把A类定义为B类的内部类。
    (5)内部类的位置
        A:成员位置
            **可以被private修饰(Body，Heart)
            **可以被static修饰。(它访问的外部类的成员必须是静态的)    
        B:局部位置
            **可以直接访问外部类中的成员，因为还持有外部类的持用
            也可以直接访问局部成员，但是局部成员要用final修饰。      
        注意：局部内部类不能用private和static修饰        
    (6)通过class文件我们就可以区分是否带有内部类，以及内部类的位置
        Outer$Inner:成员内部类
        Outer$1Inner:局部内部类

16、匿名内部类(局部内部类的简写) (重点)
        (1)前提：继承一个类或者实现一个接口
        (注意不要弄混匿名内部类的前提和多态的前提)
        (2)格式：
            new 父类名或者接口名()
            {
                重写父类方法或者实现接口中的方法。
                也可以自定义其他方法。
            };
        (3)什么时候定义匿名内部类？
            匿名内部类只是为了简化书写，匿名内部类有局限，通常定义匿名内部类时，该类方法不超过3个
        (4)匿名内部类的好处和弊端：
            好处：简化代码书写
            弊端：
                不能直接调用自己的特有方法
                不能执行强转换动作
                如果该类里面方法较多，不允许使用匿名内部类

17、可变参数
    (1)数组的可变参数
        格式：
            int... arr
    (3)方法的可变参数
        格式：
            public static void show(String str，int... arr)
            {

            }
        注意：可变参数一定要放在参数列表的最后面

18、Map集合和Collection集合的区别？

1.  Map中一次存储是键值对。Collection中一次存储是单个元素。
2.  Map的存储使用的put方法。Collection存储使用的是add方法。 
3.  Map集合没有迭代器，Map的取出，是将Map转成Set，在使用迭代器取出。Collection取出，使用就是迭代器。
4.  如果对象很多，必须使用集合存储。
    如果元素存在着映射关系，可以优先考虑使用Map存储或者用数组，
    如果没有映射关系，可以使用Collection存储。