Java入门必知知识点

1．continue和break(掌握)

    (1)作用：用于控制循环语句跳转的。

    (2)在哪里使用呢?  不能单独使用。

continue必须在循环中。break可以在循环和switch语句中。

    (3)区别：

        continue：结束本次循环，进入下一次循环。

        break：结束当前循环。

 

2：类与对象的关系(掌握)

    (1)现实世界的事物：

        属性：事物的特征

        行为：事物的功能

    (2)java中最基本的单位是类。所以，我们要把事物转换为对应的类。

    (3)如何转换呢：

        类      事物

        成员变量    属性

        成员方法    行为

    (4)类与对象的概念

        类：是一组相关的属性和行为的抽象的集合体。

        对象：是该类事物的具体存在的个体。

 

3：成员变量和局部变量的区别?

    (1)在类中的位置不同：

        成员变量：类中方法外。

        局部变量：方法中或者方法声明上。

    (2)在内存中的位置不同：

        成员变量：堆中。

        局部变量：栈中。

    (3)生命周期不同：

        成员变量：随着对象的存在而存在，随着对象的消失而消失。

        局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

    (4)初始化值不同；

        成员变量：有默认初始化值。

        局部变量：没有默认初始化值。

 

4.封装(理解)

    (1)隐藏实现细节，提供公共的访问方式。

    (2)体现有哪些呢?

        A:类      B:方法体

        C:private修饰成员变量

    (3)private关键字：

        是私有的意思。可以修饰类中的成员变量和成员方法。

        注意：被它修饰的成员只能在本类中被访问。

 

5：this关键字。(掌握)

    (1)代表当前类的一个对象。谁调用代表谁。

    (2)应用场景：

        A:使用本类的成员变量(掌握)

            this.变量名;

        B:使用本类其他构造方法

            this(...)

        C:使用本类的其他成员方法

            this.方法名();

 

6．static关键字(理解)

    (1)是静态的意思，可以修饰类中成员变量和成员方法。

    (2)静态的特点：

        A:随着类的加载而加载。

        B:优先于对象存在。

        C:被所有对象共享的数据。

        D:让我们的调用多了一种方式：

            a:非静态的数据，必须创建对象访问。

            b:静态的数据，可以通过对象访问，也可以通过类名访问。

    (3)静态的访问问题：

        总之：静态只能访问静态。

称呼: 静态的成员被成为类成员。跟类相关。

非静态的成员被称为实例成员。跟对象相关。

 

7．代码块(理解)

(1)用{}括起来的代码。

(2)分类：

A:局部代码块。

       方法内。

       作用：限定变量的生命周期，提高效率。

     B:构造代码块。

        类中，方法外。

        作用：把所有构造方法中相同的代码定义到一处。

C:静态代码块。

        类中，方法外，加static。

        作用：在整个系统运行过程中只执行一次的内容。

(3)面试题：

        构造方法，构造代码块，静态代码块的执行流程?

        静态代码块 -- 构造代码块 -- 构造方法。

        特点：

            静态代码块只执行一次。

            构造代码块每次调用构造方法都执行。

 

8.方法重写和方法重载的区别?重载可以改变返回值类型吗?(面试题。) 

方法重写：

子类中出现和父类中一模一样的方法声明的方法。

方法重载：

同一个类中，出现方法名相同，参数列表不同的方法。跟返回值无关。重载可以改变返回值类型，因为他跟返回值无关。

      

 

9: this和super的区别,以及应用场景?(面试题。)     

this:当前类的引用对象。谁调用代表谁。

super:父类的存储空间标识。可以理解为父类对象，谁调用代表谁父亲。

       应用场景：

A:成员变量

        this.成员变量   本类的成员变量

        super.成员变量  父类的成员变量

B:构造方法

        this(...)   本类的构造方法

        super(...)  父类的构造方法

C:成员方法

        this.成员方法()本类的成员方法

        super.成员方法() 父类的成员方法

 

10．final(掌握)

    (1)是一个关键字，表示的是最终的意思。

    (2)它可以修饰类，修饰成员变量，修饰成员方法。

    (3)特点：

        它修饰的类不能被继承。

        它修饰的变量是常量。

        它修饰的成员方法不能被重写。

    (4)面试题：

        修饰局部变量。

        方法的形式参数：

            基本类型：基本类型的值不能发生改变。

            引用类型：引用类型的地址值不能发生改变，但是内容可以发生改变。

 

11.内部类(理解)

    (1)把类定义在其他类的内部，就被称为内部类。

    (2)内部类的访问特点：

        A：内部类可以直接访问外部类的成员，包括私有。

        B：外部类要访问内部类的成员，必须创建对象。

    (3)内部类的分类：

        A:成员内部类

            a:private 访问的安全性

            b:static 访问的方便

        B:局部内部类

            a:带名字的(类)

            b:不带名字的(对象)

    (4)面试题：

        局部内部类访问局部变量必须加final修饰。

    (5)匿名内部类：(掌握)

        格式：

            new 类名或者接口名() {

                重写方法;

 

12.继承(掌握)

    (1)把多个类中相同的内容提取出来，定义到一个类中。

       然后让这多个类和这个类产生一个关系，这多个类就具备该类的数据了。

       这种关系叫：继承。

    (2)表现形式：

        class SonClass extends FuClass {}

 

        SonClass: 子类,派生类

        FuClass: 父类，基类，超类

    (3)继承的好处：

        A:提高了代码的复用性。

        B:让类与类之间产生了一个关系，是多态的前提。

    (4)Java中继承的特点：

        A:Java中类只支持单继承。

        B:Java中类可以多层(重)继承。

    (5)继承间的成员关系：

        A:成员变量

            在子类方法中使用变量：

                局部范围

                成员范围

                父类成员范围

        B:构造方法

            a:子类构造方法中默认去访问父类的无参构造方法。

                原因：因为子类要使用父类的数据，父类的数据必须先初始化。

            b:假如父类没有构造方法

                要么，使用super(...)调用带参

                要么，使用this(...)访问本类其他构造，本类至少有一个构造方法访问了父类构造方法。

        C:成员方法

            通过子类对象使用成员方法：

                子类

                父类

12.多态(掌握)

    (1)同一个对象在不同时刻表现出现的多种状态。

        理解：

            编译时期状态和运行时期状态不一致的现象。

            判断下面哪个有问题：从右边往左边念。

            Fu f = new Zi(); //多态

            Zi z = new Fu(); //报错

    (2)多态的前提：

        A:要有继承或者实现关系。

        B:有方法重写。

            因为一般都是抽象类或者接口的多态。

        C:要有父类/父接口的引用指向子类对象。

    (3)多态访问的成员特点：

        Fu f = new Zi();

        A:成员变量

            编译看左边，运行看左边。

        B:成员方法

            编译看左边，运行看右边。

        C:静态方法

            编译看左边，运行看左边。

    (4)多态的好处和弊端：

        A:好处

            提高了程序的可维护性和可扩展性。

            维护性：继承保证

            扩展性：多态保证

        B:弊端

            父类/父接口不能访问子类特有功能。

    (5)多态中的类型转换：

        A:向上转型

            Fu f = new Zi();

        B:向下转型

            Zi z = (Zi)f;

    (6)多态的体现形式：

        A:具体类多态

            class Fu {}

            class Zi extends Fu {}

       

            Fu f = new Zi();

        B:抽象类多态

            abstract class Fu {}

            class Zi extends Fu {}

 

            Fu f =  new Zi();

        C:接口多态

            interface Inter {}

            //接口的实现类命名：接口名+Impl

            class InterImpl implements Inter{}

 

            Inter i = new InterImpl();

 

13．抽象类(掌握)

    (1)把多个类中相同的方法声明给抽取出来。定义到一个类中。

       一个方法如果只有方法声明，没有方法体，那么该方法必须定义为抽象方法。

       而一个类中如果有抽象方法，那么，该类必须定义为抽象类。

    (2)抽象类的特点：

        A:抽象方法和抽象类都必须用abstract表示。

        B:一个类继承抽象类的时候；

            要么：本身是一个抽象类。

            要么：实现抽象类中的所有抽象方法。

        C:抽象类不能实例化。可以按照多态的使用方式使用。

        D:成员特点：

            a:成员变量

                可以是变量，也可以是常量。

            b:构造方法

                有

            c:成员方法

                可以是抽象，也可以非抽象。

    (3)抽象类的好处：

        A:抽象类中的非抽象方法提高了代码的复用性。

        B:抽象类中的抽象方法强制要求子类必须重写某些方法。

    (4)抽象类中的几个小问题：

        A:抽象类不能实例化，构造方法有什么用呢?

            用于子类访问父类数据的初始化。

        B:如果一个类中没有抽象方法，而类却被定义为了抽象类，请问为什么?

            不让创建对象。

        C:abstract不能和哪些关键字共存：

            private: 冲突   final: 冲突    static: 无意义

 

14.接口(掌握)

(1)如果一个抽象类中的所有成员方法都是抽象的，java就提高了一种更抽象的表达方式：接口。

    (2)接口的特点：

        A:接口用interface定义。

          类实现接口用implements关键字。

        B:一个类要实现接口：

            要么：本身是抽象类。

            要么：实现接口中的所有抽象方法。

        C:接口不能实例化。可以按照多态的使用方式使用。

        D:成员特点：

            a:成员变量：只能是常量。

                      默认修饰符：public static final

            b:成员方法：只能是抽象方法。

                  默认修饰符：public abstract

    (3)类与接口的关系：

        A:类与类的关系

            继承，单继承。

        B:类与接口的关系

            实现，单实现，多实现。

            继承一个类的同时实现多个接口。

        C:接口与接口的关系

            继承，单继承，多继承。

    (4)抽象类和接口的区别:

        A:成员区别

            抽象类：

                a:成员变量

                    可以是变量，也可以是常量。

                b:构造方法

                    有

                c:成员方法

                    可以是抽象，也可以非抽象。

            接口：

                a:成员变量：只能是常量。

                        默认修饰符：public static final

                b:成员方法：只能是抽象方法。

                        默认修饰符：public abstract

        B:关系区别

            a:类与类的关系

                继承，单继承。

            b:类与接口的关系

                实现，单实现，多实现。

                继承一个类的同时实现多个接口。

            c:接口与接口的关系

                继承，单继承，多继承。

        C:设计理念不同

            抽象类被继承体现的是：is a的关系。抽象类中定义的是继承体系共性功能。

            接口被实现体现的是：like a的关系。接口中定义的是继承体系的扩展功能。