Java基础知识（2022版）

小灰灰 2023-10-06 22:51 52阅读 0赞

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

**目录**

一、基本程序设计结构

1、 final关键字

2、static关键字

3、i++例题

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

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

6、构造函数的一些特性

7、类加载问题

--------------------

### 一、基本程序设计结构 ###

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

![0d00d4d176814136aa5fea8fcd88b80c.png][]

#### 1、 final关键字 ####

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

![ce9f5f5784404a92b02abaebb8790c8c.png][]

#### 2、static关键字 ####

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

![563b8ae8609e4eb7b76da117fed72791.png][]

#### 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修饰的

![ed7366d94cd74670acef77bb9e3c8b78.png][]

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

![015af5edd53249d7b51031a969343d79.png][]

![aa8a2d016c58414882195acf0b59778e.png][]

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

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

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

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

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

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

#### 6、构造函数的一些特性 ####

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

![d6cc735065684efcb6f0e49c937f1421.png][]

![05a3d05d621c48a1ad541934f063c960.png][]  
 **例一：**

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);
        }
    }

![c4f375adb04e45a5b5ea693160bf4608.png][]

**例二：**

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

![1759aab208ce474b822c3396c5fb430d.png][]

#### 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");
        }
    
    }

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

![4fa71038326348babd80392b3f56fa78.png][]

#### 8、Java四种访问控制符public、protected、default、 privat ####

（1）public：可以被所有其他类所访问。

（2）private：只能被自己类访问和修改。

（3）protected：自身，子类及同一个包中类可以访问。

（4）default：同一包中的类可以访问，声明时没有加修饰符。

![c5b194dca8854adf8d7519debde4e256.png][]

[0d00d4d176814136aa5fea8fcd88b80c.png]: https://img-blog.csdnimg.cn/0d00d4d176814136aa5fea8fcd88b80c.png
[ce9f5f5784404a92b02abaebb8790c8c.png]: https://img-blog.csdnimg.cn/ce9f5f5784404a92b02abaebb8790c8c.png
[563b8ae8609e4eb7b76da117fed72791.png]: https://img-blog.csdnimg.cn/563b8ae8609e4eb7b76da117fed72791.png
[ed7366d94cd74670acef77bb9e3c8b78.png]: https://img-blog.csdnimg.cn/ed7366d94cd74670acef77bb9e3c8b78.png
[015af5edd53249d7b51031a969343d79.png]: https://img-blog.csdnimg.cn/015af5edd53249d7b51031a969343d79.png
[aa8a2d016c58414882195acf0b59778e.png]: https://img-blog.csdnimg.cn/aa8a2d016c58414882195acf0b59778e.png
[Link 1]: https://so.csdn.net/so/search?q=%E9%9D%A2%E5%90%91%E8%BF%87%E7%A8%8B&spm=1001.2101.3001.7020
[Link 2]: https://so.csdn.net/so/search?q=%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1&spm=1001.2101.3001.7020
[d6cc735065684efcb6f0e49c937f1421.png]: https://img-blog.csdnimg.cn/d6cc735065684efcb6f0e49c937f1421.png
[05a3d05d621c48a1ad541934f063c960.png]: https://img-blog.csdnimg.cn/05a3d05d621c48a1ad541934f063c960.png
[c4f375adb04e45a5b5ea693160bf4608.png]: https://img-blog.csdnimg.cn/c4f375adb04e45a5b5ea693160bf4608.png
[1759aab208ce474b822c3396c5fb430d.png]: https://img-blog.csdnimg.cn/1759aab208ce474b822c3396c5fb430d.png
[4fa71038326348babd80392b3f56fa78.png]: https://img-blog.csdnimg.cn/4fa71038326348babd80392b3f56fa78.png
[c5b194dca8854adf8d7519debde4e256.png]: https://img-blog.csdnimg.cn/c5b194dca8854adf8d7519debde4e256.png