Java基础知识（2022版）

叫我老伯

已于 2022-06-04 21:40:00 修改

阅读量700

点赞数 4

分类专栏： Java基础文章标签： java 后端类加载

于 2022-06-04 21:34:28 首次发布

本文链接：https://blog.csdn.net/weixin_51309915/article/details/125124996

版权

Java基础专栏收录该内容

10 篇文章 2 订阅

订阅专栏

java基础之基本程序设计结构&&对象与类

4、为什么字符串是不可变的（源码解析）（设计者设计成不可变）

5、什么是面向对象编程？和面向过程编程有什么区别？优缺点是什么？

6、构造函数的一些特性

7、类加载问题

一、基本程序设计结构

所有的java程序都是从main方法开始
.java -> .class .class程序才能使用Java命令来运行
计算机使用的存储都是二进制01010101（规定某几个二进制代表特定内容）

1、 final关键字

修饰类不可以被继承
修饰方法不可以重写
修饰变量不可重新赋值
并发防止指令重拍

2、static关键字

归类所有
所有的对象实例共享他

3、i++例题

i++：是运算完后再+1

++i：是先+1再运算

例一：

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

运算结果：100 102

例二：

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

解：

i++的值是100 而此时的i 为101 ，而此时把100赋值给i --->此时i=100

下一条就是101

4、为什么字符串是不可变的（源码解析）（设计者设计成不可变）

final修饰的类，不可被继承
final修饰的char数组，一旦被赋值，不可被重新赋值
整个类内不存在任何一个对数组内容做修饰的方法，并且还是private修饰的

比如：substring，这个方法new了一个新的string

5、什么是面向对象编程？和面向过程编程有什么区别？优缺点是什么？用自己的话说一说

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。（更看重的就是一个过程）

面向对象：当需要实现一个功能的时候不关心具体的步骤，而是找一个已经具备该功能的人来帮我们做事。
面向过程：强调过程
面向对象：强调对象，这里的对象泛指现实中一切事物

面向过程：
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源；
缺点：没有面向对象易维护、易复用、易扩展

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

两者都是软件开发思想，先有面向过程，后有面向对象。在大型项目中，针对面向过程的不足推出了面向对象开发思想。
b.、编程思路不同：面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。
c.、封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势是明显。

6、构造函数的一些特性

要和类名一样
可以重载（有参无参）
如果没有定义构造函数的话，会自动生成一个无参的构造函数
没有返回值连void都没有
单例，构造函数要私有化

例一：

public class test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        String str = "";
        for (int i = 0; i <10 ; i++) {
       // 每次都会new新的对象
            str = "" + i;
            list.add(str);
        }
        System.out.println(list);
    }
}

例二：

public class test {
    public static void main(String[] args) {
        List<StudentA> listStu = new ArrayList<>();
        StudentA a = new StudentA();
        for (int i = 0; i < 10; i++) {
//         StudentA a = new StudentA();
            a.setName("" + i);
            listStu.add(a);
        }
        System.out.println(listStu);
    }
}

输出的全是9

7、类加载问题

1 类加载从上往下执行，依次执行静态的初始化语句和初始化块，而且类加载优先于对象创建。（静态初始化语句和初始化块只加载一次）
2 创建本类的对象时:从上往下执行一次非静态的初始化语向和初始化块，最后执行构造函数。
3 创建另一个类对象时：先加载另一个类的静态语句和静态初始化块（同样也只是第一次才会加载他的静态语句和初始化块，同样也只加载一次）。然后再加载其他类的非静态的初始化语向和初始化块，最后执行构造函数。
4 静态语句初始化时可以创建类对象。
5 静态方法可以只加载而不调用，不调用不执行。

public class InitializeDemo {
    private static int k = 1;
    private static InitializeDemo t1 = new InitializeDemo("t1");
    private static InitializeDemo t2 = new InitializeDemo("t2");
    private static int i = print("i");
    private static int n = 99;
    {
        print("初始化块");
        j = 100;
    }
    public InitializeDemo(String str){
        System.out.println((k++) + ":" + str + "    i=" + i + "    n=" +n);
        ++i;
        ++n;
    }
    static {
        print("静态块");
        n = 100;
    }
    private int j = print("j");
    public static int print(String str){
        System.out.println((k++) + ":" + str + "    i=" + i + "    n=" +n);
        ++n;
        return ++i;
    }
    public static void main(String[] args) {
        InitializeDemo test = new InitializeDemo("test");
    }

}

类加载原因-从上往下执行静态的初始化语句，块，（一次）。涉及到构造函数的时候从上往下执行非静态的初始化语句，块。最后执行构造函数。静态方法每次调用才会执行