首页手记 java基础入门知识必知

java基础入门知识必知

标签：

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)面试题：
构造方法，构造代码块，静态代码块的执行流程?
静态代码块 -- 构造代码块 -- 构造方法。
特点：
静态代码块只执行一次。
构造代码块每次调用构造方法都执行。

方法重写和方法重载的区别?重载可以改变返回值类型吗?(面试题。)
方法重写：
子类中出现和父类中一模一样的方法声明的方法。
方法重载：
同一个类中，出现方法名相同，参数列表不同的方法。跟返回值无关。重载可以改变返回值类型，因为他跟返回值无关。

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的关系。接口中定义的是继承体系的扩展功能。