变量与方法
成员变量与局部变量的区别有哪些
变量：在程序执行的过程中，在某个范围内其值可以发生改变的量。从本质上 讲，变量其实是内存中的
一小块区域 成员变量：方法外部，类内部定义的变量 局部变量：类的方法中的变量。 成员变量和局部
变量的区别
作用域
成员变量：针对整个类有效。
局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)
存储位置
成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。
局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。当方法调用完，或者语句结
束后，就自动释放。
生命周期
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：当方法调用完，或者语句结束后，就自动释放。
初始值
成员变量：有默认初始值。
局部变量：没有默认初始值，使用前必须赋值。
使用原则
在使用变量时需要遵循的原则为：就近原则 首先在局部范围找，有就使用；接着在成员位置找。
在Java中定义一个不做事且没有参数的构造方法的作用
Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构 造方法，则会调用父类中
“没有参数的构造方法”。因此，如果父类中只定义了 有参数的构造方法，而在子类的构造方法中又没有
用super()来调用父类中特定 的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参数
的构 造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。在调用子类构造方法之前会先调用父类没有参数的构造方法，其 目的
是？
帮助子类做初始化工作。
一个类的构造方法的作用是什么？若一个类没有声明构造方法， 改程
序能正确执行吗？为什么？
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构 造方法也会有默认的不
带参数的构造方法。
构造方法有哪些特性？
名字与类名相同；
没有返回值，但不能用void声明构造函数；
生成类的对象时自动执行，无需调用。
静态变量和实例变量区别
静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会 有一份，在类的加载过程
中，JVM只为静态变量分配一次内存空间。
实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量 是属于实例对象的，在内
存中，创建几次对象，就有几份成员变量。
静态变量与普通变量区别
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有 的对象所共享，在内存
中只有一个副本，它当且仅当在类初次加载时会被初始 化。而非静态变量是对象所拥有的，在创建对象
的时候被初始化，存在多个副 本，各个对象拥有的副本互不影响。
还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。
静态方法和实例方法有何不同？
静态方法和实例方法的区别主要体现在两个方面：
1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使 用"对象名.方法名"的方式。而
实例方法只有后面这种方式。也就是说，调 用静态方法可以无需创建对象。
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量 和静态方法），而不允许访
问实例成员变量和实例方法；实例方法则无此 限制
在一个静态方法内调用一个非静态成员为什么是非法的？
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静 态变量，也不可以访问
非静态变量成员。
什么是方法的返回值？返回值的作用是什么？
方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提 是该方法可能产生结
果）。返回值的作用:接收出结果，使得它可以用于其他的 操作！
内部类什么是内部类？
在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内 部类本身就是类的一个
属性，与其他属性定义方式一致。
内部类的分类有哪些
内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。
静态内部类
定义在类内部的静态类，就是静态内部类。
静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量； 静态内部类的创建方
式，new 外部类.静态内部类()，如下：
成员内部类
定义在类内部，成员位置上的非静态类，就是成员内部类。
成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公 有。成员内部类依赖于外
部类的实例，它的创建方式外部类实例.new 内部类()，如 下：
1 public class Outer {
2
3 private static int radius = 1;
4
5 static class StaticInner {
6 public void visit() {
7 System.out.println("visit outer static variable:" + radius);
8 }
9 }
10 }
1 Outer.StaticInner inner = new Outer.StaticInner();
2 inner.visit
1 public class Outer {
2
3 private static int radius = 1;
4 private int count =2;
5
6 class Inner {
7 public void visit() {
8 System.out.println("visit outer static variable:" + radius);
9 System.out.println("visit outer variable:" + count);
10 }
11 }
12 }
1 Outer outer = new Outer();
2 Outer.Inner inner = outer.new Inner();
3 inner.visit();局部内部类
定义在方法中的内部类，就是局部内部类
定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法 中的局部类只能访问外
部类的静态变量和方法。局部内部类的创建方式，在对应 方法内，new 内部类()，如下：
匿名内部类
匿名内部类就是没有名字的内部类，日常开发中使用的比较多。
1 public class Outer {
2
3 private int out_a = 1;
4 private static int STATIC_b = 2;
5
6 public void testFunctionClass(){
7 int inner_c =3;
8 class Inner {
9 private void fun(){
10 System.out.println(out_a);
11 System.out.println(STATIC_b);
12 System.out.println(inner_c);
13 }
14 }
15 Inner inner = new Inner();
16 inner.fun();
17 }
18 public static void testStaticFunctionClass(){
19 int d =3;
20 class Inner {
21 private void fun(){
22 // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外
部类的实例变量
23 System.out.println(STATIC_b);
24 System.out.println(d);
25 }
26 }
27 Inner inner = new Inner();
28 inner.fun();
29 }
30 }
1 public static void testStaticFunctionClass(){
2 class Inner {
3 }
4 Inner inner = new Inner();
5 }
1 public class Outer {
2
3 private void test(final int i) {
4 new Service() {
5 public void method() {
6 for (int j = 0; j < i; j++) {
7 System.out.println("匿名内部类" );除了没有名字，匿名内部类还有以下特点：
匿名内部类必须继承一个抽象类或者实现一个接口。
匿名内部类不能定义任何静态成员和静态方法。
当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方 法。
匿名内部类创建方式：
内部类的优点
我们为什么要使用内部类呢？因为它有以下优点：
一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
内部类不为同一包的其他类所见，具有很好的封装性；
内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
匿名内部类可以很方便的定义回调。
内部类有哪些应用场景
1. 一些多算法场合
2. 解决一些非面向对象的语句块。
3. 适当使用内部类，使得代码更加灵活和富有扩展性。
4. 当某个类除了它的外部类，不再被其他的类使用时。
局部内部类和匿名内部类访问局部变量的时候，为什么变量必须 要加
上final？
局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final呢？ 它内部原理是什么呢？
先看这段代码：
8 }
9 }
10 }.method();
11 }
12 }
13 //匿名内部类必须继承或实现一个已有的接口
14 interface Service{
15 void method();
16 }
1 new 类/接口{
2 //匿名内部类实现部分
3 }以上例子，为什么要加final呢？是因为生命周期不一致， 局部变量直接存储在 栈中，当方法执行结束
后，非final的局部变量就被销毁。而局部内部类对局部变 量的引用依然存在，如果局部内部类要调用局
部变量时，就会出错。加了final， 可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这
个问题。
内部类相关，看程序说出运行结果
运行结果：
重写与重载
构造器（constructor）是否可被重写（override）
构造器不能被继承，因此不能被重写，但可以被重载。
1 public class Outer {
2
3 void outMethod(){
4 final int a =10;
5 class Inner {
6 void innerMethod(){
7 System.out.println(a);
8 }
9
10 }
11 }
12 }
1 public class Outer {
2 private int age = 12;
3
4 class Inner {
5 private int age = 13;
6 public void print() {
7 int age = 14;
8 System.out.println("局部变量：" + age);
9 System.out.println("内部类变量：" + this.age);
10 System.out.println("外部类变量：" + Outer.this.age);
11 }
12 }
13
14 public static void main(String[] args) {
15 Outer.Inner in = new Outer().new Inner();
16 in.print();
17 }
18
19 }
1 局部变量：14
2 内部类变量：13
3 外部类变量：12重载（Overload）和重写（Override）的区别。重载的方法能 否根
据返回类型进行区分？
方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态 性，而后者实现的是运行
时的多态性。
重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不 同、顺序不同），与方法
返回值和访问修饰符无关，即重载的方法不能根据返回 类型进行区分
重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛 出的异常小于等于父
类，访问修饰符大于等于父类（里氏代换原则）；如果父类 方法访问修饰符为private则子类中就不是重
写。