写在最前面

这个项目是从20年末就立好的 flag，经过几年的学习，回过头再去看很多知识点又有新的理解。所以趁着找实习的准备，结合以前的学习储备，创建一个主要针对应届生和初学者的 Java 开源知识项目，专注 Java 后端面试题 + 解析 + 重点知识详解 + 精选文章的开源项目，希望它能伴随你我一直进步！

说明：此项目我确实有很用心在做，内容全部是我参考了诸多博主（已注明出处），资料，N本书籍，以及结合自己理解，重新绘图，重新组织语言等等所制。个人之力绵薄，或有不足之处，在所难免，但更新/完善会一直进行。大家的每一个 Star 都是对我的鼓励 ！希望大家能喜欢。

注：所有涉及图片未使用网络图床，文章等均开源提供给大家。

项目名: Java-Ideal-Interview

Github 地址： Java-Ideal-Interview - Github

Gitee 地址：Java-Ideal-Interview - Gitee（码云）

持续更新中，在线阅读将会在后期提供，若认为 Gitee 或 Github 阅读不便，可克隆到本地配合 Typora 等编辑器舒适阅读

若 Github 克隆速度过慢，可选择使用国内 Gitee 仓库

• 二 Java面向对象
  • 1. 类和对象
    • 1.1 什么是面向过程？什么又是面向对象？
      • 1.1.1 能举个例子谈谈你对面向过程和面向对象的理解吗
      • 1.1.2 面向过程和面向对象的优缺点
    • 1.2 说一说类、对象、成员变量和成员方法的关系和理解
    • 1.3 成员变量和局部变量有什么区别？
      • 1.3.1 为什么局部变量存在于栈中而不是堆中
    • 1.4 访问权限修饰符 public、private、protected, 以及不写（默认）时的区别
    • 1.5 类在初始化的时候做了些什么？
    • 1.6 static 关键字修饰的作用？
      • 1.6.1 什么是静态方法
      • 1.6.2 什么是静态变量
      • 1.6.3什么是 静态代码块
  • 2. 面向对象三大特征
    • 2.1 封装
    • 2.2 继承
    • 2.3 多态
  • 3. 其他
    • 3.3 抽象类和接口
      • 3.3.1 谈谈你对抽象类和接口的认识
        • 运行结果：
      • 3.3.2 抽象类和接口的区别（重要）
    • 3.4 谈谈几种内部类和使用内部类的原因
      • 3.4.1 几种内部类
      • 3.4.2 为什么使用内部类

二 Java面向对象

1. 类和对象

1.1 什么是面向过程？什么又是面向对象？

面向过程——步骤化

• 面向过程就是分析出实现需求所需要的步骤，通过函数（方法）一步一步实现这些步骤，接着依次调用即可

面向对象——行为化（概念相对抽象，可结合下面的例子理解）

• 面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成类（类实例化后才是对象），创建了对象不是为了完成某一个步骤，而是描述某个事物在解决问题的步骤中的行为

1.1.1 能举个例子谈谈你对面向过程和面向对象的理解吗

例如我们设计一个桌球游戏（略过开球，只考虑中间过程）

A：面向过程方式思考：

把下述的步骤通过函数一步一步实现，这个需求就完成了。（只为演示概念，不细究逻辑问题）。

① palyer1 击球 —— ② 实现画面击球效果 —— ③ 判断是否进球及有效 —— ④ palyer2击球

⑤ 实现画面击球效果 —— ⑥ 判断是否进球及有效 —— ⑦ 返回步骤 1—— ⑧ 输出游戏结果

B：面向对象方式思考：

经过观察我们可以看到，其实在上面的流程中存在很多共性的地方，所以我们将这些共性部分全集中起来，做成一个通用的结构

1. 玩家系统：包括 palyer1 和 palyer2

2. 击球效果系统：负责展示给用户游戏时的画面

3. 规则系统：判断是否犯规，输赢等

我们将繁琐的步骤，通过行为、功能，模块化，这就是面向对象，我们甚至可以利用该程序，分别快速实现8球和斯诺克的不同游戏（只需要修改规则、地图和球色即可，玩家系统，击球效果系统都是一致的）

1.1.2 面向过程和面向对象的优缺点

A：面向过程

优点：性能上它是优于面向对象的，因为类在调用的时候需要实例化，开销过大。

缺点：不易维护、复用、扩展

用途：单片机、嵌入式开发、Linux/Unix等对性能要求较高的地方

B：面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

缺点：一般来说性能比面向过程低

低耦合：简单的理解就是说，模块与模块之间尽可能的独立，两者之间的关系尽可能简单，尽量使其独立的完成成一些子功能，这避免了牵一发而动全身的问题。这一部分我们会在面向对象学习结束后进行系统的整理和总结。

总结：只通过教科书后的例题是无法体会到面向过程所存在的问题的，在一些小例程中，面向过程感觉反而会更加的简单，但是一旦面临较大的项目，我们需要编写N个功能相似的函数，函数越来越多，代码量越来越多，你就知道这是一场噩梦了。

说明：关于性能的问题，这里只是在笼统意义上来说，具体性能优劣，需要结合具体程序，环境等进行比对

1.2 说一说类、对象、成员变量和成员方法的关系和理解

类：一组相关的属性和行为的集合，是一个抽象的概念。

对象：该类事物的具体表现形式，具体存在的个体。

成员变量：事物的属性

成员方法：事物的行为

上面我们说了这几个概念，那么到底应该怎么理解呢？

类就是对一些具有共性特征，并且行为相似的个体的描述。

比如小李和老张都有姓名、年龄、身高、体重等一些属性，并且两人都能够进行聊天、运动等相似的行为。

由于这两个人具有这些共性的地方，所以我们把它抽象出来，定义为一个类——人类，而小李、老王正是这个类中的个体（对象），而每一个个体才是真正具体的存在，光提到人类，你只知道应该有哪些属性行为，但你不知道他具体的一些属性值，比如你知道他属于 “人类” 所以他应该拥有姓名，年龄等属性，但你并不知道他具体叫什么，年龄多大了。而小李和老王这两个具体的对象，却能够实实在在的知道老王今年30岁了、身高175等值。

所以可以得出结果：类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而真正根据类实例化出具体的对象，就需要占用内存空间了。

1.3 成员变量和局部变量有什么区别？

A：在类中的位置不同

• 成员变量：类中方法外

• 局部变量：代码块，方法定义中或者方法声明上（方法参数）

B：在内存中的位置不同

• 成员变量：在堆中

• 局部变量：在栈中

C：生命周期不同

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

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

D：初始化值不同

• 成员变量：有默认值（构造方法对它的值进行初始化）

• 局部变量：没有默认值，必须定义，赋值，然后才能使用

1.3.1 为什么局部变量存在于栈中而不是堆中

有一个问题，在我们学习 Java 中内存分配的时候，有这样一句话，“堆内存用来存放 new 创建的对象和数组”。 换句话说对象存在于堆中，而成员变量又存在于类中，而且对象是类具体的个体，所以成员变量也存在于堆中，那么问题就来了，同理，是不是方法也和成员变量一样存在于对象中，而局部变量又定义在方法中，岂不就是说，局部变量也存在于堆中呢？这明显与我们上面的定义有区别

解释：一个类可以创建 n 个不同的对象，当我们 new 一个对象后，这个对象实体，已经在堆上分配了内存空间，由于类的成员变量在不同的对象中各不相同（例如，小李和老王的姓名不同），都需要自己各自的存储空间，所以类的成员变量会随着对象存储在堆中，而由于类的方法是所有对象通用的，所以创建对象时，方法还未出现，只有声明，方法里面的局部变量也并没有被创建，只有等到对象使用方法的时候才会被压入栈。

补充：类变量（静态变量）存在于方法区，引用类型的局部变量声明在栈，存储在堆

1.4 访问权限修饰符 public、private、protected, 以及不写（默认）时的区别

• public：公共的，可以被项目中所有的类访问。
• protected：受保护的，可以被这个类本身访问；被同一个包中的类访问；被它的子类（同一个包以及不同包中的子类）访问。
• default：默认的，可以被这个类本身访问；被同一个包中的类访问。
• private：私有的，只能被这个类本身访问。

1.5 类在初始化的时候做了些什么？

public class Student {
    private String name = "BWH_Steven";
    private Integer age = 22;
    
    // 是个无参构造，为了演示初始化顺序，特意加了两个赋值语句
    public Student (){ 
        name = "阿文";
        age = 30;
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student(); 
    }
}

static {
	... 内容
}

public class Student {
	//定义成私有成员变量（private）
    private String name;
    private int age;
	
    //无参构造
    public Student() {
        super();
    }

    //带参构造
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
	
    //成员变量的set和get方法（与外界联系的桥梁）
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        //创建学生类对象 s
        Student s = new Student()；
            
        //对象s调用类中的公共方法setName()和setAge()
        //set方法给成员变量赋值
        s.setName("BWH_Steven");
        s.setAge(20);
        
        //get方法获取成员变量
        System.out.println(s.getName() + s.getAge());
    }
}

public class Student {

    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    //在setAge()方法中加入了校验的内容
    //不合法数据是不允许传递给成员变量的
    public void setAge(int age) {
        if (age < 0 || age > 120) {
            System.out.println("Error");
        }else {
            this.age = age;
        }     
    }

    public int getAge() {
        return age;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.getName() + s.getAge());
        
        //错误的方式！！！
        s.name = "BWH_Steven";
        s.age = 20;
        System.out.println(s.getName() + s.getAge());
        
       	//正确的方式！！！
        s.setName("BWH_Steven");
        s.setAge(20);
    }
}

// Animal类

public abstract class Animal {

    public void sleep() {
        System.out.println("我趴着睡");
    }
    public abstract void eat(); 
}

// Dog类
public class Dog extends Animal {

    public Dog() {
        super();
    }
    
    @Override
    public void eat() {
        System.out.println("我实现了父类方法，狗吃肉");
    }
}

// Cat类
public class Cat extends Animal{
    public Cat() {
        super();
    }

    @Override
    public void eat() {
        System.out.println("我实现了父类方法，猫吃鱼");
    }
}

// 测试类
public class AnimalTest {
    public static void main(String[] args) {
        Animal a1 = new Dog();
        a1.sleep();
        a1.eat();
        System.out.println("-------------------------");
        Animal a2 = new Cat();
        a2.sleep();
        a2.eat();
    }
}

我趴着睡
我实现了父类方法，狗吃肉
-------------------------
我趴着睡
我实现了父类方法，猫吃鱼

// 通过抽象类定义
public abstract class Dog {
	public abstract void eat();
	public abstract void sleep();  
}

// 通过接口定义
public interface Dog {
    public abstract void eat();
    public abstract void sleep();
}

// 定义接口，含有钻火圈方法
public interface DrillFireCircle() {
    public abstract void drillFireCircle();
}

// 定义抽象类狗类
public abstract class Dog {
    public abstract void eat();
    public abstract void sleep();
}
 
// 继承抽象类且实现接口
class SpecialDog extends Dog implements drillFireCircle {
    public void eat() {
      // ....
    }
    public void sleep() {
      // ....
    }
    public void drillFireCircle() () {
      // ....
    }
}

class Outer {
    class Inner {
    }
}

class Outer {
    private int age = 20;
    // 成员位置
    class Inner {
        public void show() {
            System.out.println(age);
        }
    }
}

class Test {
    public static void main(String[] ages) {
        // 成员内部类是非静态的演示
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

// 成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

// 成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();	

class Outer {
    private class Inner {
        public void show() {
            System.out.println(“密码备份文件”);
        }
    }
    
    public void method() {
    	if(你是管理员){
    		Inner i = new Inner();
    		i.show();
    	}else {
    		System.out.println(“你没有权限访问”);
    	}
   	}
}

class Outer {
    private class Inner {
        public void show() {
            System.out.println(“密码备份文件”);
        }
    }
    // 使用getXxx()获取成员内部类，可以增加校验语句（文中省略）
    public Inner getInner() {
		return new Inner();
   	}
    
    public static void main(String[] args) {
    	Outer outer = new Outer();
        Outer.Inner inner = outer.getInner();
        inner.show();
    }
}

class Outer {
	public int age = 18;	
	class Inner {
		public int age = 20;	
		public viod showAge() {
			int age  = 25;
			System.out.println(age);//空1
			System.out.println(this.age);//空2
			System.out.println(Outer.this.age);//空3
		}
	}
} 

class Outer {
    public void method(){
        class Inner {
        }
    }
}

// 在局部位置，可以创建内部类对象，通过对象调用和内部类方法
class Outer {
    private int age = 20;
    public void method() {
        final int age2 = 30;
        class Inner {
            public void show() {
           	    System.out.println(age);
                // 从内部类中访问方法内变量age2，需要将变量声明为最终类型。
                System.out.println(age2);
            }
        }
        
        Inner i = new Inner();
        i.show();
    }
}

class Outter {
    int age = 10;
    static age2 = 20;
    public Outter() {        
    }
     
    static class Inner {
        public method() {
            System.out.println(age);//错误
            System.out.println(age2);//正确
        }
    }
}

public class Test {
    public static void main(String[] args)  {
        Outter.Inner inner = new Outter.Inner();
        inner.method();
    }
}

new 类名或者接口名() {
    重写方法();
}

interface Inter {
	public abstract void show();
}

class Outer {
    public void method(){
        new Inner() {
            public void show() {
                System.out.println("HelloWorld");
            }
        }.show();
    }
}

class Test {
	public static void main(String[] args)  {
    	Outer o = new Outer();
        o.method();
    }
}    

Inter i = new Inner() {  //多态，因为new Inner(){}代表的是接口的子类对象
	public void show() {
		System.out.println("HelloWorld");
	}
};

public interface Demo {
    void show();
}

class Outer {
    private class test implements Demo {
        public void show() {
            System.out.println("密码备份文件");
        }
    }
    
    public Demo getInner() {
        return new test();
    }
    
}

    public static void main(String[] args) {
    	Outer outer = new Outer();
        Demo d = outer.getInner();
        i.show();
    }

//运行结果
密码备份文件

public class Demo1 {
    public String name() {
        return "BWH_Steven";
    }
}

public class Demo2 {
    public String email() {
        return "xxx.@163.com";
    }
}