后端 - Java基础 - 《后端 Java 技术栈》

1、jdk、jre、jvm区别
2、访问修饰符">

2、访问修饰符
3、& 和&&区别
4、final、finally、finalize区别
5、this、super关键字">
5、this、super关键字
- 5.1 、this代表对象自身
- 5.2、super 指向自己父类对象
6、static关键字">6、static关键字
- 6.1、静态变量
- 6.2、静态方法
- 6.3、静态代码块
- 6.4、静态内部类
- 6.5、静态导包
7、break、continue、return
8、面向对象、面向过程区别
9、面向对象三大特性
- 9.1 封装
- 9.2 继承
- 9.3 多态
10、抽象类和接口
- 10.1 抽象类
- 10.2 接口
11、重写和重载的区别
- 11.1 重写
- 11.2 重载
12、== 与equals 区别
13、JDK常用的包
14、IO流
- 14.1 BIO,NIO,AIO 有什么区别?
15、Files的常用方法
16、反射
- 16.1 反射获取对象的三种方式
17、网络编程
18、String和StringBuffer、StringBuilder的区别是什么？
19、包装类
20、泛型面试题">20、泛型面试题

1、jdk、jre、jvm区别

JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。（jdk编译器javac.exe）

JRE：Java Runtime Environment 的简称，Java 运行环境，为 Java 的运行提供了运行环境。（jre里有运行.class的java.exe）

JVM（Java Virtual Machine），即java虚拟机, java运行时的环境参考参考二参考三

运行过程:
通过JDK中的编译程序（javac）将我们的文本java文件编译成JAVA字节码，在JRE上运行这些JAVA字节码，JVM解析这些字节码，映射到CPU指令集或OS的系统调用。

三者区别：
a.JDK和JRE区别：在bin文件夹下会发现，JDK有javac.exe而JRE里面没有，javac指令是用来将java文件编译成class文件的，这是开发者需要的，而用户（只需要运行的人）是不需要的。JDK还有jar.exe, javadoc.exe等等用于开发的可执行指令文件。这也证实了一个是开发环境，一个是运行环境。
b.JRE和JVM区别：JVM并不代表就可以执行class了，JVM执行.class还需要JRE下的lib类库的支持，尤其是rt.jar。

2、访问修饰符

public、private、protected
[

](https://blog.csdn.net/ancientear/article/details/79483592)

3、& 和&&区别

虽然二者都要求运算符左右两端的布尔值都是true 整个表达式的值才是 true。
&&之所以称为短路运算，是因为如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行运算。

4、final、finally、finalize区别

final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾，一个对象是否可回收的最后判断。

5、this、super关键字
5.1 、this代表对象自身
1.普通的直接引用，this相当于是指向当前对象本身。
2.形参与成员名字重名，用this来区分：
```
public Person(String name, int age) {
  this.name = name;
  this.age = age;
}
```
3.调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
4、this首先是一个对象,它代表调用这个函数的对象。

5.2、super 指向自己父类对象

1.普通的直接引用，super相当于指向当前对象的父类的引用
2.子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区分

class Person{
    protected String name;
    public Person(String name) {
        this.name = name;
    }
}
class Student extends Person{
    private String name;
    public Student(String name, String name1) {
        super(name);
        this.name = name1;
    }
    public void getInfo(){
        System.out.println(this.name);      //Child
        System.out.println(super.name);     //Father
    }
}
public class Test {
    public static void main(String[] args) {
       Student s1 = new Student("Father","Child");
       s1.getInfo();
    }
}

3.调用父类中的某一个构造函数（应该为构造函数中的第一条语句）

6、static关键字

定义：static是一个修饰符，用于修饰类的成员变量、成员方法、静态代码块来优化性能。
意义：

在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！
用来形成静态代码块以优化程序性能,因为只会在类加载的时候执行一次

6.1、静态变量

静态变量也称类变量，static只能定义在类的{}中，不能定义在方法中。

static属于类所有，由类来直接调用 static 修饰的变量，它不需要手动实例化类进行调用

public class Test {
  static int i = 10;
  public static void main(String[] args) {
      System.out.println(Test.i);
  }
}

6.2、静态方法

static 方法就是没有 this（相当于对象）的方法，也就是说，可以在不用创建对象的前提下使用类名.变量名进行调用

static 修饰方法的注意事项
- static 修饰的方法内部不能调用非静态方法

非静态方法内部可以调用 static 静态方法

6.3、静态代码块

代码块分为两种，一种是使用 {} 代码块；一种是 static {} 静态代码块。
static 修饰的代码块被称为静态代码块。静态代码块可以置于类中的任何地方，类中可以有多个 static 块，在类初次被加载的时候，会按照 static 代码块的顺序来执行，每个 static 修饰的代码块只能执行一次

6.4、静态内部类

用 static 修饰的内部类

public class ClassDemo {
    private int a = 10;
    private static int b = 20;
    static class StaticClass{
        public static int c = 30;
        public int d = 40;
        public static void print(){
            //下面代码会报错，静态内部类不能访问外部类实例成员
            //System.out.println(a);
            //静态内部类只可以访问外部类类成员
            System.out.println("b = "+b);
        }
        public void print01(){
            //静态内部内所处的类中的方法，调用静态内部类的实例方法，属于外部类中调用静态内部类的实例方法
            StaticClass sc = new StaticClass();
            sc.print();
        }   
    }
}

6.5、静态导包

静态导入就是使用 import static 用来导入某个类或者某个包中的静态方法或者静态变量。

import static java.lang.Integer.*;
public class StaticTest {
    public static void main(String[] args) {
        System.out.println(MAX_VALUE);
        System.out.println(toHexString(111));
    }
}

7、break、continue、return

break 跳出总上一层循环，不再执行循环(结束当前的循环体)
continue 跳出本次循环，继续执行下次循环(结束正在执行的循环进入下一个循环条件)
return 程序返回，不再执行下面的代码(结束当前的方法直接返回)

8、面向对象、面向过程区别

面向过程：

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展

面向对象：

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

9、面向对象三大特性

9.1 封装

隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。

9.2 继承

子类拥有父类非 private 的属性和方法。
子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。

子类如果对继承的父类的方法不满意（不适合），可以自己编写继承的方法，这种方式就称为方法的重写。当调用方法时会优先调用子类的方法。

9.3 多态

多态是同一个行为具有多个不同表现形式或形态的能力

Java实现多态有三个必要条件：继承、重写、向上转型
案例：
有一个Animal类，它有Cat，和Dog两个子类，在Animal中有个say方法，当Cat调用这个方法的时候输出的是“小猫喵喵喵”，当Dog调用这个方法时，输出的是“小狗汪汪汪”，这就是Java多态的实现。

向上和向下转型:

向上转型:将一个父类的引用指向一个子类对象，称为向上转型，自动进行类型转换
    用法: Father f = new Son（）；
向下转型：子类引用指向父类引用的子类对象  通俗的说就是子类实例对象赋值给父类引用，然后父类引用又要赋值给子类引用，这个过程就是向下转型。
  语法:
Father f = new Son（）；
Son s = （Son）f； //看语法，要有（类型）
a、向上转型后，父类引用只能调用与子类共有的实例方法与实例变量，子类独有的实例变量与实例方法将不能调用。多态：动态绑定知识点哈。
不明白就自己敲一遍。你看看能不能发消息！！！（通过引用调用方法，也称为向实例对象发送一个消息）
b、注意向下转型的前提条件：首先父类引用指向一个子类实例对象。。。。这样绝对不可以Father father = new Father（）； Son s = （son）father；
不好意思，直接抛给你ClassCastException！！即父类实例对象绝对不能强制转换为子类的实例对象。

10、抽象类和接口

10.1 抽象类

抽象类是用来捕捉子类的通用特性的，从设计层来看抽象类是对类的抽象，是一种模板设计

题目：定义Shape类表示一般二维图形。Shape具有抽象方法area和perimeter，分别计算形状的面积和周长。试定义一些二维形状类（如矩形、三角形、圆形等）

//形状类public abstract class Shape {
    public abstract double area();
    public abstract double perimeter();
}

//矩形类public class Rectangle extends Shape {
    private double length;
    private double width;
    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }
    public double getWidth() {
        return width;
    }
    public void setWidth(double width) {
        this.width = width;
    }
    @Override
    public double area() {
        return getLength() * getWidth();
    }
    @Override
    public double perimeter() {
        return 2 * (getWidth() + getWidth());
    }
}

//三角形类public class Triangle extends Shape {
    private double a, b, c;
    public double getA() {
        return a;
    }
    public void setA(double a) {
        this.a = a;
    }
    public double getB() {
        return b;
    }
    public void setB(double b) {
        this.b = b;
    }
    public double getC() {
        return c;
    }
    public void setC(double c) {
        this.c = c;
    }
    @Override
    public double area() {
        double p = (getA() + getB() + getC()) / 2;
        return Math.sqrt(p * (p - getA()) * (p - getB()) * (p - getC()));
    }
    @Override
    public double perimeter() {
        return getA() + getB() + getC();
    }
}

//圆形类public class Circle extends Shape {
    private double diameter;
    public double getDiameter() {
        return diameter;
    }
    public void setDiameter(double diameter) {
        this.diameter = diameter;
    }
    @Override
    public double area() {
        return Math.PI * Math.pow(getDiameter() / 2, 2);
    }
    @Override
    public double perimeter() {
        return Math.PI * getDiameter();
    }
}

//测试代码public class 测试 {
    public static void main(String [] args){
        Rectangle rec = new Rectangle();
        rec.setLength(10);
        rec.setWidth(5);
        double rec_area = rec.area();
        double rec_perimeter = rec.perimeter();
        System.out.println("矩形的面积："+rec_area+"，周长"+rec_perimeter);
        Triangle tri = new Triangle();
        tri.setA(3);
        tri.setB(4);
        tri.setC(5);
        double tri_area = tri.area();
        double tri_perimeter = tri.perimeter();
        System.out.println("三角形的面积："+tri_area+"，周长"+tri_perimeter);
        Circle cir = new Circle();
        cir.setDiameter(10);
        double cir_area = cir.area();
        double cir_perimeter = cir.perimeter();
        System.out.println("圆形的面积："+cir_area+"，周长"+cir_perimeter);
    }
}

10.2 接口

接口是抽象方法的集合。从设计层面接口是行为的抽象，是一种行为的规范。

相同点:

接口和抽象类都不能实例化
都位于继承的顶端，用于被其他实现或继承
都包含抽象方法，其子类都必须覆写这些抽象方法

不同点:

11、重写和重载的区别

11.1 重写

其实就是在子类中把父类本身有的方法重新写一遍

public class Father {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Son s = new Son();
        s.sayHello();
    }
    public void sayHello() {
        System.out.println("Hello");
    }
}
class Son extends Father{
    @Override
    public void sayHello() {
        // TODO Auto-generated method stub
        System.out.println("hello by ");
    }
}

11.2 重载

在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。

public class Father {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Father s = new Father();
        s.sayHello();
        s.sayHello("wintershii");
    }
    public void sayHello() {
        System.out.println("Hello");
    }
    public void sayHello(String name) {
        System.out.println("Hello" + " " + name);
    }
}

12、== 与equals 区别

基本数据类型(byte\short\int\float\double\long\char\boolean) : 比较的是值
引用数据类型: 比较的是应用地址如string

equals

类没有覆盖 equals() 方法，等价于通过“==”。
类覆盖了 equals() 方法(string\Integer重写了equals)。比较的是值
对于equals方法，注意：equals方法不能作用于基本数据类型的变量，equals继承Object类，比较的是是否是同一个对象

　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

String x = "string";     // 放在常量池中
String y = "string";    // 从常量池中查找
String z = new String("string"); // z 为一个引用
System.out.println(x==y); // true
System.out.println(x==z); // false
System.out.println(x.equals(y)); // true
System.out.println(x.equals(z)); // true

hashCode() 的作用是获取哈希码，也称为散列码

13、JDK常用的包

java.lang：这个是系统的基础类；
java.io：这里面是所有输入输出有关的类，比如文件操作等；
java.nio：为了完善 io 包中的功能，提高 io 包中性能而写的一个新包；
java.net：这里面是与网络有关的类；
java.util：这个是系统辅助类，特别是集合类；
java.sql：这个是数据库操作的类。

[

](https://blog.csdn.net/ThinkWon/article/details/104390612)

14、IO流

按照流的流向：输出流和、输入流
按照操作单元：字节流、字符流
按照流的角色：节点流、处理流
InputStream/Reader: 前者是字节输入流、后者是字符输入流
OutputStream/Writer:前者是字节输出流、后者是字符输出流

按操作方式分类结构图：

按操作对象分类结构图：

14.1 BIO,NIO,AIO 有什么区别?

BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。

[

](https://blog.csdn.net/ThinkWon/article/details/104390612)

15、Files的常用方法

Files. exists()：检测文件路径是否存在。
Files. createFile()：创建文件。
Files. createDirectory()：创建文件夹。
Files. delete()：删除一个文件或目录。
Files. copy()：复制文件。
Files. move()：移动文件。
Files. size()：查看文件个数。
Files. read()：读取文件。
Files. write()：写入文件。

[

](https://blog.csdn.net/ThinkWon/article/details/104390612)

16、反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

16.1 反射获取对象的三种方式

public class Student {
    private int id;
    String name;
    protected boolean sex;
    public float score;
}

public class Get {
    //获取反射机制三种方式
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一(通过建立对象)
        Student stu = new Student();
        Class classobj1 = stu.getClass();
        System.out.println(classobj1.getName());
        //方式二（所在通过路径-相对路径）
        Class classobj2 = Class.forName("fanshe.Student");
        System.out.println(classobj2.getName());
        //方式三（通过类名）
        Class classobj3 = Student.class;
        System.out.println(classobj3.getName());
    }
}

17、网络编程

网络编程的面试题可以查看我的这篇文章重学TCP/IP协议和三次握手四次挥手，内容不仅包括TCP/IP协议和三次握手四次挥手的知识，还包括计算机网络体系结构，HTTP协议，get请求和post请求区别，session和cookie的区别等

18、String和StringBuffer、StringBuilder的区别是什么？

如果要操作少量的数据用 = String
单线程操作字符串缓冲区下操作大量数据 = StringBuilder
多线程操作字符串缓冲区下操作大量数据 = StringBuffer

19、包装类

原始类型: boolean，char，byte，short，int，long，float，double
包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

Java基础

1、jdk、jre、jvm区别

2、访问修饰符

3、& 和&&区别

4、final、finally、finalize区别

5、this、super关键字

5.1 、this代表对象自身

5.2、super 指向自己父类对象

6、static关键字

6.1、静态变量

6.2、静态方法

6.3、静态代码块

6.4、静态内部类

6.5、静态导包

7、break、continue、return

8、面向对象、面向过程区别

9、面向对象三大特性

9.1 封装

9.2 继承

9.3 多态

10、抽象类和接口

10.1 抽象类

10.2 接口

11、重写和重载的区别

11.1 重写

11.2 重载

12、== 与equals 区别

13、JDK常用的包

14、IO流

14.1 BIO,NIO,AIO 有什么区别?

15、Files的常用方法

16、反射

16.1 反射获取对象的三种方式

17、网络编程

18、String和StringBuffer、StringBuilder的区别是什么？

19、包装类

20、泛型面试题