2023.3.22

@13：static关键字

创建时间上：

静态的属性/静态方法/静态代码块/静态内部类） 早于 对象

一：static修饰变量：

​ 1：随着类的加载一起加载进方法区的静态域中

​ 2：先于对象的存在

​ 3：static修饰的变量是属于这个类的，是通过这个类实例出的对象所共享的。

​ 4：static修饰属性的应用场景：

​ 某些特定的数据想要在内存中共享，只有一块 --》这个情况下，就可以用static修饰的属性

​ 比如说同一类下很多对象的school属性都是一样的，所以school完全可以是静态变量，不用一个一个的赋 值。

二：static修饰方法：

在类加载的同时会将静态的东西（静态的属性/方法/代码块/静态内部类）加载到方法区中的静态域中，这都是

先于对象的创建完成的，而且完全不依托于对象，他是属于类的，没有对象照样可以执行。

在非静态方法中可以调用静态的方法 / 静态的属性 / 非静态的方法 / 非静态的属性。

-> 因为非静态方法的执行是依托于对象的。有了对象才可以执行，而有对象之前早就加载好静态的东西了，所以静态的东西直接用就行。 创建时间上的问题

在静态方法中可以调用静态的方法 / 静态的属性 / 有对象做依靠的非静态的方法和非静态的属性

-> 因为在时间上，在类加载的同时会将静态的东西（静态的属性/方法/代码块/静态内部类）加载到方法区中的静态域中，这都是先于对象的创建完成的，在静态的方法中直接调用非静态的东西，因为非静态的东西是依托于对象的，所以有可能这个对象并没有创建出来。 创建时间上的问题

6.	public class Demo {
7.	    int id;
8.	    static int sid;
9.	
10.	    public void a(){
11.	        System.out.println(id);
12.	        System.out.println(sid);
13.	        System.out.println("------a");
14.	    }
15.	    //1.static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行
16.	    static public void b(){
17.	        //System.out.println(this.id);//4.在静态方法中不能使用this关键字
18.	        //a();//3.在静态方法中不能访问非静态的方法
19.	        //System.out.println(id);//2.在静态方法中不能访问非静态的属性
20.	        System.out.println(sid);
21.	        System.out.println("------b");
22.	    }
23.	
24.	    //这是一个main方法，是程序的入口：
25.	    public static void main(String[] args) {
26.	        //5.非静态的方法可以用对象名.方法名去调用
27.	        Demo d = new Demo();
28.	        d.a();
29.	        //6.静态的方法可以用   对象名.方法名去调用  也可以 用  类名.方法名 （推荐）
30.	        Demo.b();
31.	        d.b();
32.	        
33.	    }
    }

三：代码块

public class Test {
    //属性
    int a;
    static int sa;

    //方法
    public void a() {
        System.out.println("我是非静态方法a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("普通快中的内容----000000");
        }
        //if(){}
        //while(){}
    }

    public static void b() {
        System.out.println("我是静态方法b");
        {
            System.out.println("我是静态方法里面的普通快");
        }
    }

    //构造块
    {
        System.out.println("------这是构造块");
    }

    //静态块
    static {
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println("我是静态变量" + sa);
        b();
    }


    //构造器
    public Test() {
        System.out.println("这是空构造器");
    }

    public Test(int a) {
        this.a = a;
    }


    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test t = new Test();
        t.a();

        Test t2 = new Test();
        t2.a();
    }
}

/*
-----这是静态块
我是静态变量0
我是静态方法b
我是静态方法里面的普通快
------这是构造块
这是空构造器
我是非静态方法a
这是普通块
普通快中的内容----000000
------这是构造块
这是空构造器
我是非静态方法a
这是普通块
普通快中的内容----000000
*/

类的组成部分：1：属性，2：方法，3：构造器，4：代码块，5：内部类

1：属性：静态属性，非静态属性

2：方法：静态方法，非静态方法

3：构造器：有参构造器，无参构造器（时时刻刻写着无参构造器，当你写着有参构造器时编译器不会自动加无参构造器）

4：代码块：普通快，构造快，静态块，同步块（多线程）

5：内部类：静态内部类，非静态内部类

代码块：

普通快：写在方法（可以是静态方法也可以是非静态方法）里面的代码块。

构造块：写在方法外面类里面的非静态代码块。

静态块：写在方法外面类里面的非静态代码块。

代码的执行顺序：

最先执行静态块（只在类加载的时候执行一次，所以一般以后实战写项目：创建工厂，数据库的初始化信息都放入静态块。一般用于执行一些全局性的初始化操作）然后再执行构造块（不常用），再执行构造器，再执行方法中的普通快。需要注意的是一个类中的静态块只执行一次，但是构造快每new一个对象的时候都要执行一次，并且其执行顺序在构造器执行之前。

@14：包

为了解决重名问题，解决权限问题

包名的定义：

1：全部小写

2：中间用 . 隔开

3：一般都是公司域名倒着写 ： com.jd

4：加上模块名字：

com.jd.login com.jd.register

5：不能使用系统中的关键字：nul,con,com1—com9…

6：同一个包下的类相互之间直接用就行

在Java中的导包没有包含和被包含的关系，都是平级关系。

​

@15：封装

封装最大的好处：提高代码的安全性

将某些东西进行隐藏，然后提供相应的方式进行获取。

即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们在方法中可以加入 限制条件。

通过getter setter方法对属性进行修改，之前是直接获取到属性然后修改属性，现在为什么这么麻烦呢？

因为这个getter setter方法是我们自己写的，我们想让属性被外面访问，我们就写一个getter方法setter方法，不想让外面访问我们就不写，而且如果外面对属性的操作我们不满意我们可以在setter,getter方法里修改成我们满意的。掌握权一直在我们手里，而不是客户手里。比如说下面的 setAge(int age) 方法，如果你传的age大于18，我不满意，我就直接i给你改成18.

总结一下就是：你不可以随随便便的访问我的属性，你必须得先过我的 “方法” 这一关。

public class Student {
    //属性：
    private int age;
    private String name;
    private String sex;

    //加入对应的setter和getter方法：
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
		if(age > 18) {
			this.age = 18;
		}else {
			this.age = age;
		}
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        if ("男".equals(sex) || "女".equals(sex)) {//sex是男 或者 是 女
            this.sex = sex;
        } else {
            this.sex = "男";
        }
    }

    //加入构造器：
    public Student() {

    }

    public Student(int age, String name, String sex) {
        this.age = age;
        this.name = name;
        // 注意：如果set方法里面做了修改，这个构造方法也要跟着修改。
        // 这里如果不修改的化sex传一个乱码，属性就会是这个乱码，而调用setSex则不会。
        //this.sex = sex;
        this.setSex(sex); 
    }
}

我们程序设计追求“高内聚，低耦合”。

➢高内聚:类的内部数据操作细节自己完成，不允许外部干涉;

➢低耦合:仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提

高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露

的暴露出来。这就是封装性的设计思想。

@16：继承

继承最大的好处就是：提高代码的复用性。

Person：属性：age，name，height -----> 这些属性都是private修饰的，被封装好的。

​ 方法：eat( )，sleep（）

Student：属性：sno

​ 方法：study( )

Student 继承自Person , 那么Student里面就有：age，name，height ，sno，eat( )，sleep（）,study( )

注意：

1：父类中private修饰的属性，其实子类也是继承过来的，只是由于封装的特性，不可以在子类中直接的调用，但是可以通过setter getter接口间接调用。

2：一个父类可以有无数的子类，但是一个子类只能有一个直接父类，但是他可以间接的继承自其他的父类，比如说当其他的孙子类或是重孙子类。

3：所有的类都直接或者间接的继承自Object。

继承的内存分析：

protected关键字