Java基础知识（2022版）

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

目录

一、基本程序设计结构

1、 final关键字

2、static关键字

3、i++例题

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

}

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

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

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

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

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

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