有关注意事项的小总结

1.成员变量与局部变量的区别

（1）区别

在类中定义的位置不同
成员变量：类中，但是在方法外
局部变量：定义在方法内部

在内存中的位置也不同
成员变量：在堆内存中
局部变量：在栈内存中

初始化值也不同
成员变量：系统会给予默认值
局部变量：没有系统给的默认值，必须在定义的时候赋值，亦
或者在方法中使用之前赋值，然后才能使用。

生命周期不同
成员变量的生命周期：随着对象的创建而创建，随着对象的消失而消失
局部变量的生命周期：随着方法的调用而创建，随着方法的调用完毕而消失

（2） 注意事项：

局部变量的名字可以和成员变量的名字一样，在方法中使用的时候，采用就近原则
方法中使用的变量，会先在方法内部查找，如果方法内部没有，去成员变量中查找。

方法与方法之间里面的局部变量变量，不能互相调用。

2.形式参数的问题：分别是基本数据类型和引用数据类型的时候的区别。

（1）当形式参数是基本数据类型的时候,将来调用方法的时候传入的是常量值,或者是该类型的变量
（2）当形式参数是引用数据类型的时候，将来调用方法的时候传入的是该类对象的地址值
（3）当形式参数是基本数据类型的时候，在方法中对变量做修改，不会影响到外部实际的栈内存中的值。因为在方法调用完成后方法会在栈中消失，因此无论你怎么在方法中对变量进行修改也不回影响到外部的参数。
（4）当形式参数是引用数据类型的时候，在方法中对变量做修改，会影响到外部实际的堆内存中的值。

3.构造方法

（1）

1. 问题：我们之前在类中从来都没有写过构造方法，但是我们依旧可以创建对象，请问用的是哪里的构造方法呢？
   注意： 1、如果我们没有给出构造方法，JVM会自动提供一个无参空方法体的构造 方法 2、如果我们给出了一个构造方法，还会提供嘛？
   如果我们提供了一个构造方法，系统就不会再提供默认的无参空方法体的构造 方法
   3、构造方法可以发生重载 给成员变量赋值的方式： 1、使用setXxx(…)的方式给私有成员变量赋值
   2、使用带参数的构造方法给私有的成员变量赋值，这里需要与this关键字 配合使用

（2）构造方法用法

构造方法：给成员变量做初始化作用的

构造方法可以发生重载

如果我们没有提供构造方法，系统会默认提供一个无参空方法体的构造方法

如果我们提供了构造方法，无论提供的是无参还是有参，系统都不会再提供了

格式：方法名与类名一致，没有返回值类型，连return都没有。 构造方法在创建对象的时候调用。

4.static关键字

（1）static关键字的特点：它可以修饰成员变量和成员方法

1.随着类的加载而加载 观察main方法

2.优先于对象而存在的，不随着对象的改变而改变。

3.被类的所有对象共享： 举例：所有中国人的国籍信息都是中国都是一样。 什么时候使用静态static关键字呢？
如果某个成员变量是被所有的对象共享的，值是一样的，那么它就应该被定义为static静态的。 举例现实生活的案例：
哈罗共享单车（可以用静态的修饰） 自己的水杯（不可以用静态的修饰）

4.可以通过类名直接调用 一般情况下，只要我们看到一个类中有静态修饰的成员变量或者是成员方法 我们一律推荐使用 类名.静态成员 这种方式去使用
5.静态修饰的内容我们一般称之为：类成员，与类相关的。

（2）static关键字使用注意事项：

1、在静态方法中是没有this关键字的 this代表的是当前调用该方法的对象，而被static修饰的成员是优先于对象而存在的。
被static修饰的成员是随着类的加载而加载，这时候，还没有对象产生，也就说明没有this关键字 所以在静态方法中无法使用this关键字。
2、将成员方法分成两类：
（1） 静态的成员方法： 访问的内容：
成员变量：只能访问静态的成员变量
成员方法：只能访问静态的成员方法
（2） 非静态的成员方法： 访问的内容：
成员变量：既可以访问非静态的成员变量，也可以访问静态的成员变量
成员方法：既可以访问非静态的成员方法，也可以访问静态的成员方法

5.创建对象初始化的流程

a:先将class文件加载到方法区中
b:在栈中为变量开辟空间
c:在堆内存中创建对象
d:系统给成员变量进行默认赋值
e:给成员变量进行显示赋值
f:构造方法给成员变量进行赋值
g:将堆内存中的地址赋值给栈内存中的变量

6.代码块的优先级介绍

（1） 代码块：在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同， 可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

• 局部代码块：在方法中出现，限定变量的生命周期，及早释放，提高内存的利用在同一个类中的同一个方法中，如果存在多个局部代码块，执行顺序是自上而下的。在类中的方法内部。
• 构造代码块：（在创建对象的时候调用）
  定义在类中方法外。当一个类中既存在构造代码块也存在构造方法的时候，在创建对象时，会先执行构造代码块，后执行构造方法。
  无论类中有多少个构造代码块，构造代码块之间会先进行自上而下的顺序执行，然后再执行构造方法。构造代码块 – 构造方法
• 静态代码块：
  在类中方法外定义，并加上static修饰。静态代码块是优先于其他代码块之前执行，在类中方法外部。
  静态代码块 – 局部代码块 – 构造代码块 – 构造方法
  在加载的时候执行，并且只执行一次

7.使用继承时所需要的注意事项：

（1）、**要想初始化子类，必须先初始化父类 **
举例：现有父亲，才能有儿子
（2）、子类只能继承父类的非私有的成员（成员变量和成员方法）
（3）、子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法
因为要想初始化子类，必须先初始化父类，是通过构造方法进行初始化的。
（4）、不要为了部分的功能而去使用继承
（5）、那么，什么时候使用继承呢？
在英语中有一个语法叫“is a”
当两个类满足语法什么是什么的时候，就可以使用继承了

继承与成员变量之间的关系：*
1、当子类中的成员变量与父类中的成员变量名字一样的时候
查找：（就近原则）
1）先在方法的局部范围内进行查找，如果找到就返回
2）如果在方法局部范围找不到，去本类中成员位置上查找，如果找到
就返回
3）如果在中成员位置上找不到，去父类中成员位置上查找，如果找到就
返回
4）如果在父类中成员位置上找不到，报错。
2、当子类中的成员变量与父类中的成员变量名字不一样的时候，使用什
么变量名，就访问谁

8.super和this

继承中出现的问题：
我们现在不仅仅要输出局部范围内的num，我们还想输出父类中num,怎么办呢？

如果有一个东西，根this相似，也可以代表父类的引用，通过这个东西去 访问父类中的数据就好了。
Java替你考虑到了这个问题，提供了一个关键字给我们使用：super 面试题：this关键字与super关键字的使用区别？
this代表的是调用该类的当前对象
super代表的是父类存储空间的标识（父类的引用，可以操作父类的成员）

一.怎么用呢？
1、访问成员变量
this.成员变量 访问的是本类中的成员变量
super.成员变量 访问的是父类中的成员变量
2、访问构造方法
this(…)
super(…)
3、访问成员方法
this.成员方法()
super.成员方法()
当父类中没有无参构造方法的时候，怎么办呢？
使用super关键字带参数的形式访问父类的带参数构造方法

二.子类通过this关键字调用本类的其他构造方法 注意，本类其他构造方法也必须可以访问父类拥有的构造方法
使用this关键字间接的调用父类的构造方法 无论在哪里调用父类的构造方法，只要最后保证在子类构造方法内容执行之前完成了父类的初始化就可以了

super(…)或者this(…)必须出现在第一条语句上，否则就会出现父类的数据进行了多次初始化 （重点）每个类只能初始化一次

9.重写与重载的区别

子类的方法名能不能和父类方法的声明一样？
如果子类的方法声明与父类的方法声明一样，这样的现象叫做方法的重写。
重写现象是发生在继承的关系中。

面试题： 重写与重载的区别：
重写是发生在继承的关系的关系中，重载是发生在本类中。
重载是方法名一致，参数列表不一致就是重载。
重写是方法名，参数列表，返回值都一样，实现不一样，叫方法的
重写。
重载的英文单词：overload
重写的英文单词：override

10.final的特点：

final:最终的的意思。它可以修饰类，成员变量，成员方法

特点：
1、修饰类，类不能被继承
2、修饰成员变量，变量变常量，并且只能赋值一次,在构造方法完毕之前赋值即可。
常量：
字面值常量
自定义常量：被final修饰变量变成自定义常量
3、final修饰成员方法：方法不能被重写

final修饰引用数据类型时 面试题： final修饰局部变量

1、在方法内部，修饰基本数据类型的变量，变量值只能赋值一次，不能发生改变
2、final修饰引用数据类型的变量呢？
引用的地址值不可以发生改变你，但是该对象的堆内存中的值是可以发生改变的。

11.多态访问成员的特点（重点）

多态的前提： 1、要有继承关系 2、要有方法的重写。 其实没有重写也是可以的，但是不重写就没有意义
动物都有吃这个方法，但是每个具体的动物吃的实现不一样，变现出不同动物的特有属性 3、要有父类的引用指向子类对象 父类名 f = new
子类名(…);

（1）、成员变量
编译看左，运行看左
（2）、构造方法
创建子类对象的时候，先访问父类中的构造方法，对父类的数据先进行初始化
（3）、成员方法
编译看左，运行看右。
因为成员方法存在重写，所以访问看右边
（4）、静态成员方法
编译看左，运行也看左。
由于被static修饰的成员都是与类相关的，这里不是重写，所以运行的时候，访问的还是左边的。

12.抽象类的特点：

1、抽象类和抽象方法都要用一个关键字修饰：abstract
修饰一个类 放在class的前面
举例： abstract class Animal3{}
修饰一个方法 一般是放在权限修饰符后面
定义一个抽象的show方法
举例：public abstract void show();
2、有抽象方法的类一定要是抽象类，抽象类不一定要有抽象方法，具体的类中不能有抽象方法，抽象类中既可以存在抽象方法
也可以存在有方法体的方法。
3、抽象类不能被实例化
既然不能被实例化，那写在抽象类中的方法如何被调用呢？
抽象类如何创建呢？
通过多态的形式，使用具体的子类去实例化调用方法，专业术语称之为：抽象多态
4、如果继承抽象类的是一个具体的子类，需要重写该抽象类中所有的抽象方法
如果继承抽象的也是一个抽象类，可以不去重写父类中的抽象方法，也可以选择性的去重写。

抽象类的特点：
1、抽象类和抽象方法都要用一个关键字修饰：abstract 修饰一个类 放在class的前面 举例： abstract
class Animal3{} 修饰一个方法 一般是放在权限修饰符后面 定义一个抽象的show方法 举例：public abstract
void show();
2、有抽象方法的类一定要是抽象类，抽象类不一定要有抽象方法，具体的类中不能有抽象方法，抽象类中既可以存在抽象方法
也可以存在有方法体的方法。
3、抽象类不能被实例化 既然不能被实例化，那写在抽象类中的方法如何被调用呢？ 抽象类如何创建呢？
通过多态的形式，使用具体的子类去实例化调用方法，专业术语称之为：抽象多态
4、如果继承抽象类的是一个具体的子类，需要重写该抽象类中所有的抽象方法
如果继承抽象的也是一个抽象类，可以不去重写父类中的抽象方法，也可以选择性的去重写。

13.方法重写的注意事项：

1、父类中私有的方法不能被重写
2、子类重写父类的方法时候，访问权限不能更低
要么子类重写的方法访问权限比父类的访问权限要高或者一样
建议：以后子类重写父类的方法的时候，权限修饰符写一样就不会发生这样的问题。
3、父类中静态的方法不能被重写，也就是说不能被Override修饰，因为静态的是属于类本身的东西。
4.将父类中的静态成员看作一个全局共享的，被所有的子类共享

14.接口中成员的特点：

成员变量：
只能是常量，并且是静态的
JVM在真正运行之前会自动补齐修饰符：public static final
建议：在学习阶段手动补齐，在开发阶段，省略不写。 构造方法：
接口中没有构造方法。 成员方法：
接口中的方法只能是抽象方法，没有方法体，连大括号都没有
JVM在真正运行之前会自动补齐修饰符：public abstract
建议：在学习阶段手动补齐，在开发阶段，省略不写。

注意：
1、当一个具体的类实现接口的时候，必须实现接口中所有的抽象方法
2、当一个抽象类实现接口的时候，可以选择不实现接口中的方法，也可
以选择性的实现
3、接口与接口之间什么关系呢？
类与类，类与接口，接口与接口的关系
类与类：
存在继承关系，只能进行单继承，不可以进行多继承，但是可以是多层继承
类与接口：
实现关系，可以是单实现，也可以是一次性实现多个接口，也可以
在继承一个类的同时，实现多个接口
接口与接口：
存在的是继承关系，可以进行单继承，也可以进行多继承

15…有关包的问题

（1） 包：在这里就是文件夹的意思

面试题：package,import,class他们三个之间有没有顺序呢？

package: 到达的路径，所在文件的路径，它最终以包结束。 （在最前面）

import: 导入外界你想要使用的类，它最终以你想要导入的那个类/java 结束。 （在package与class之间）
要想导入某一包下所有的类，.(开发不推荐) 只要当你需要导入大于30个类的时候，可以考虑.

class: 表示定义一个类，java的最基本的单位 （在import后面）

16.权限修饰符问题：在不同情况下被不同权限修饰符修饰的参数的访问情况。

权限修饰符：         同一类下     同一包子类中，其他类      不同包的子类      不同 包的其他类public           √                    √                   √                 √protected        √                    √                   √默认的            √                    √private          √

要注意的是：在不同包的子类中被protected修饰的参数需要用super.参数 才能访问到。

17. 类及其组成可以用的修饰符：

修饰符：访问权限修饰：public,protected,默认的,private状态修饰饰：static,final抽象修饰符：abstract类：访问权限修饰：public,默认的,状态修饰饰：final抽象修饰符：abstract成员变量：访问权限修饰：public,protected,默认的,private状态修饰饰：static,final构造方法：访问权限修饰：public,protected,默认的,private成员方法：访问权限修饰：public,protected,默认的,private状态修饰饰：static,final抽象修饰符：abstract常见的修饰符组合：成员变量：public static final 在接口中遇见成员方法：1、public abstract2、public static3、public final将来开发中，除了封装必须使用private以外，如果你实在不知道
用谁，就用public

18.内部类：

把类定义在其他类的内部，我们称之为内部类
内部类有哪些特点：
（1）、内部类可以访问外部类的成员，包括私有
（2）、外部类要想访问内部类的成员，必须要创建内部类的对象
按照内部类在类中定义的位置不同，可以分为如下两种格式：
成员位置(成员内部类)
局部位置(局部内部类)

成员内部类常见的修饰符
（1）private:
其他类不能直接创建内部类的对象，要想使用被private修饰内部类成员，必须在本类中间接的创建对象调用
（2）static:
内部类如果是被satic修饰的时候，只能访问外部类中静态成员

局部内部类：
1、定义在方法中的类
2、局部内部类可以直接访问外部类中所有成员
3、要想使用局部内部类中的方法，在定义局部内部类的成员方法中，创建局部内部类对象调用方法。

在局部内部类中引用的本地的变量必须是最终变量或者实际上的最终变量
通过反编译工具观察发现，存在局部内部类的方法中定义的局部变量自动加上了final关键字 在JDK1.8之后会自动加上final关键字