java基础-java面向对象01-day08

1. 一个简单的类

认识类

成员变量 类方法

public class Person {
    //类的成员变量
    int age;
    String name;
    double height;
    double weight;

    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }

    public String introduce(){
        return "名字："+name+ "年龄："+age+"身高："+height+"体重"+weight
    }
}

实例化对象 调用对象的方法

public class Test {

    public static void main(String[] args) {
        //第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
        Person zs = new Person();

        zs.name = "张珊";
        zs.age = 19;
        zs.height = 188.8;
        zs.weight = 75;

        //再次创建对象 不会再加载类
        Person ls = new Person();

        ls.name = "李四";
        ls.age = 20;
        ls.weight = 80;
        ls.height = 188.9;

        System.out.println(zs.name);
        System.out.println(ls.name);

        zs.sleep();
        ls.eat();

        System.out.println(zs.introduce());
    }
}

2. 构造器

无参构造器 有参构造器 什么是this

public class Person {
    String name;
    int age;
    double height;

    public Person(){

    }

    public Person(String name, int age, double height){
        //当形式参数与属性名 重名的时候会出现就进原则
        //在对象的属性赋值的时候加上this
        this.name = name;
        this.age = age;
        this.height = height;
    }
    public Person(String a, int b){
        name = a;
        age = b;
    }

    public void eat(){
        System.out.println("吃饭");
    }

}

new一个对象的 过程 以及构造器的注意点

public class Test {

    public static void main(String[] args) {
        /*
        1. new 关键字实际上是在调用一个方法 这个方法叫做构造方法（构造器）
        2. 系统会默认分一个构造方法
        3. 可以自己显示的编写构造方法

        构造方法与普通方法的区别
        1. 没有返回值的类型
        2. 不能有return语句
        3. 名字必须与类的名字一样

        构造器的作用：
        不是为了创建对象
        调用构造器之前对象就已经创建并且属性有初始值
        构造器的本质是给对象的属性进行赋值操作

        注意点：
        1. 一般不会在空构造器里面进行初始化操作，否则所有的对象的属性就一样
        2. 需要保证每个类空构造器的存在， 逻辑可以什么都不写，

        */
        Person p = new Person();
        System.out.println(p.age);
        System.out.println(p.name);
        System.out.println(p.height);

        Person p2 = new Person("张三", 18, 188.9);

        System.out.println(p2.age);
        System.out.println(p2.name);
        System.out.println(p2.height);

    }

}

1.一般要保证空构造器的存在，且空构造器不进行属性的赋值操作

2. 一般要进行构造器的重载，在重载构造器中进行属性的赋值操作；

3. 重载构造器之后，如果空构造器忘记写，系统就再也不会分默认的空构造器，new Persion()则会报错

4. 当形式参数与类的属性重名，属性的赋值前加上this来修饰

public class Test2 {
    public static void main(String[] args) {
        Person p = new Person();
        p.age = 19;
        p.name = "lili";
        p.height = 188.8;

        Person p2 = new Person("lili", 19, 180.1);
        System.out.println(p2.age);
        System.out.println(p2.height);
        System.out.println(p2.name);

    }
}

3. new对象 内存分析

Person p1 = new Person();

    创建对象的过程：
    1. 在第一次遇到一个类的时候 需要堆这个类进行加载 只加载一次
    2. 创建对象需要在堆中开辟空间
    3. 对象的初始化 属性的赋值都是默认值
    4. new关键字 会调用构造器 执行构造方法 在构造器中对属性进行重新的赋值

4. this详解

public class Person {
    String name;
    int age;
    double height;

    public Person(){
    }

    public Person(String name, int age, double height){
        //当形式参数与属性名 重名的时候会出现就进原则
        //在对象的属性赋值的时候加上this
        this.name = name;
        this.age = age;
        this.height = height;
    }
    public Person(String a, int b){
        name = a;
        age = b;
    }

    public void eat(){
        System.out.println("吃饭");
    }

}

this:

public class Person {
    String name;
    int age;
    double height;

    public Person(){
    }

    public Person(String name, int age, double height){
        //当形式参数与属性名 重名的时候会出现就进原则
        //在对象的属性赋值的时候加上this
        this(name, age);      //同一个类中 构造器可以用this调用 但是要写在第一行    

        this.height = height;
    }
    public Person(String a, int b){
        name = a;
        age = b;
    }

    public void eat(){
        System.out.println("吃饭");
    }

}

5. static如何详解

public class Test4 {

    int id;
    int sid;

    public static void main(String[] args) {
        Test4 t1 = new Test4();
        t1.id = 10;
        t1.sid = 10;

        Test4 t2 = new Test4();
        t2.id = 20;
        t2.sid = 20;

        Test4 t3 = new Test4();
        t3.id = 30;
        t3.sid = 30;

        System.out.println(t1.id);
        System.out.println(t2.id);
        System.out.println(t3.id);

        System.out.println(t1.sid);
        System.out.println(t2.sid);
        System.out.println(t3.sid);

        //System.out.println(Test4.sid);
    }
}

sid加上 static 之后

static总结：

1. 加载类的时候会将静态的内容也加载到方法区
2. 静态域中的内容先于对象的存在
3. 静态的内容被所有类的对象共享
4. 访问方式 类名.属性名

使用场景：

特定的数据 所有的对象共享

public class JavaLearningStudent {
    String name;
    int age;
    static String school;

    public static void main(String[] args) {
        JavaLearningStudent.school = "xx大学";
        JavaLearningStudent s1 = new JavaLearningStudent();
        s1.name = "张三";
        s1.age = 19;

        JavaLearningStudent s2 = new JavaLearningStudent();
        s2.name = "李四";
        s2.age = 20;

        //s2.school = "new大学";
        System.out.println(s2.school);

    }
}

属性的分类：

1. 类属性
2. 对象属性

静态方法：

package com.msb2;

/**
 * @Auther: jack.chen
 * @Date: 2023/9/8 - 09 - 08 - 21:50
 * @Description: com.msb2
 * @version: 1.0
 */
public class Demo {
    int id;
    static int sid;

    public void a(){
        System.out.println(id);
        System.out.println(sid);
        System.out.println("----a");
    }

    static public void b(){
        //静态方法中不能访问this
        //System.out.println(id); 静态方法不能访问非静态的属性
        //a();静态方法不能访问非静态的方法
        System.out.println(sid);
        System.out.println("----b");
    }

    public static void main(String[] args) {
        Demo d = new Demo();

        d.a();

        Demo.b(); //静态方法可以用类.方法名 直接调用
        b(); //同一个类方法直接调用
    }
}

6. 什么是代码块

package com.msb2;

/**
 * @Auther: jack.chen
 * @Date: 2023/9/8 - 09 - 08 - 22:01
 * @Description: com.msb2
 * @version: 1.0
 */
public class TestBlock {
    int a;
    static int sa;

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

    public TestBlock(int a){
        this.a = a;

    }

    public void a(){
        System.out.println("====a");
    }

    static public void sa(){
        System.out.println("===sa");
    }

    // 这个是静态块
    static {
        System.out.println("---静态块");

        System.out.println(sa); //静态块能够访问静态属性
    }

    public static void main(String[] args) {
        TestBlock t = new TestBlock();
        t.a();
        sa();

    }
}

代码块的执行顺序：

先执行静态块 只在类的加载时候执行一次（实战项目中 创建工厂 数据库的初始化信息放入静态块 用于全局的初始还操作）

再执行构造器

7. import导包

解决重名的问题 找到对应的类

1. 包的名字全部小写
2. 包一般都是公司域名 倒着写 com.jd com.huawei com.baidu
3. 加上模块的名字
   
   com.huawei.aiservice com.huawei.login
4. 包声明一般在类的第一行