Java核心知识：面向对象

类是具有一定共性事物的集合，有两部分组成：

• 成员变量：描述状态信息
• 成员方法：描述能够做什么

类定义和使用

定义一个类注意：

1.成员变量直接写在类当中，在方法外面

2.成员方法不要写static关键字

类使用：

1.导包，就是支出需要使用的类在什么位置，在一个文件夹里不需要导

2.创建对象：类名 对象名 = new 类名()

3.使用对象：对象名.成员变量；对象名.成员方法()

注意：成员变量没有赋值，则会有默认值

/*
类的定义和使用
 */
public class Demo01Class {
    public static void main(String[] args) {
        // 1.创建对象
        Student stu = new Student();

        // 使用成员变量
        System.out.println(stu.name);  // null
        System.out.println(stu.age);  // 0

        //改变成员变量
        stu.name = "小明";
        stu.age = 8;
        System.out.println(stu.name);  // 小明
        System.out.println(stu.age);  // 8

        //使用成员方法
        stu.study();
        stu.eat();

    }


}

class Student {
    String name;
    int age;

    public void study () {
        System.out.println("学习");
    }

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

权限修饰符

四种权限修饰符：public > protected > default > private

访问控制如下

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

private私有

使用private关键字修饰成员变量，则就成为了私有属性。私有属性在本类中仍然可以随意访问，但是超出本类范围就不能直接访问了。可以通过两个额外的成员方法读取（get）和设置（set）成员变量。

在定义设置私有属性的方法时，就可以对这个属性做校验和拦截，比如，年龄只能在0-200之间。

示例：

public class Demo00Person {
    String name;
    private int age;

    public void show() {
        System.out.println("我是" + name + "，年龄：" + age);
    }

    public int getAge() {
        return age;
    }

    public void setAge(int num) {
        if (num > 0 && num <200) {
            age = num;
        } else {
            System.out.println("年龄不合理");
        }

    }
}

public class Demo02Private {
    public static void main(String[] args) {
        Demo00Person person = new Demo00Person();
        person.show();  // 我是null，年龄：0

        // 姓名可以直接赋值
        person.name = "小明";
        // age不能直接赋值，和获取，需要通过set和get方法
        person.setAge(-1);  // 年龄不合理
        person.setAge(20);
        person.show();

    }
}

注意：

1.对于get方法，不能有参数，返回值必须和成员变量的类型对应

2.对于set方法，不能有返回值，参数类型必须和成员变量的类型对应

3.对于基本类型中的boolean值，get方法一定要写成isXxx形式，set方法不变

好处：阻止不合理和属性设置，提高数据安全性

this关键字

当方法的局部变量和类的成员变量名字重合，根据就近原则，优先使用局部变量，如果想在方法里使用成员变量，就要使用this，代表对象本身。哪个对象调用，this就代表谁。

示例：

public class Demo00Person2 {
    String name;
    int age;

    public void call(String name) {
        // 成员变量有个name，方法的局部变量也有个name，那么下面加this的就是成员变量，不加的是局部变量
        System.out.println(this.name + "打电话给" + name);
    }
}

public class Demo03This {
    public static void main(String[] args) {
        Demo00Person2 person = new Demo00Person2();
        person.name = "aa";

        person.call("bb");

    }
}

构造方法

即创建对象的方法，当使用new来创建对象时，就调用了构造方法。

1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样；

2.构造方法不要写返回值类型，也没有void

3.构造方法不能return一个具体的值

4.如果没有编写任何构造方法，编译器默认有个构造方法，没有参数和方法，什么也没做

5.一旦编写了至少一个构造方法，编译器不再提供构造方法

6.构造方法可以重载

示例：

public class Student2 {
    private String name;
    private int age;

    public Student2() {
        System.out.println("无参构造方法");
    }

    public Student2(String name, int age) {
        System.out.println("有参构造方法");
        this.name = name;
        this.age = age;
    }
}

/*
构造方法使用
 */
public class Demo03Init {
    public static void main(String[] args) {
        Student2 stu1 = new Student2();
        Student2 stu2 = new Student2("小明", 8);
    }
}

static静态

使用static关键字，则修饰的内容不再属于对象自己，而属于类，所有本类的对象共享这一属性或方法。

1.静态属性

如下，定义一个学生类，共享一个班级。并定义一个学号计算器，每new一个对象，写好自动加1。

package base7_class;

public class Student3 {
    private int id;
    private String name;
    private int age;
    static String classRoom;
    private static int idCount;  // 计数器，每当创建一个对象，就idCount++

    public Student3() {
        this.id = ++idCount;
    }

    public Student3(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCount;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package base7_class;

public class Demo05Static {
    public static void main(String[] args) {
        Student3 stu1 = new Student3("小明", 8);
        System.out.println(stu1.getId());  // 1
        stu1.classRoom = "01";
        System.out.println(stu1.classRoom);

        Student3 stu2 = new Student3("小明", 8);
        System.out.println(stu2.getId());  // 2
        System.out.println(stu1.classRoom);  // 所有成员共享，与stu1相同

    }
}

2.静态方法

被static修饰的方法称为静态方法，调用时不需要通过对象调用，可以通过类直接调用。

package base7_class;

public class Student4 {
    public void method() {
        System.out.println("成员方法");
    }

    public static void staticMethod() {
        System.out.println("静态方法");
    }
}

package base7_class;

public class Demo06StaticMethod {
    public static void main(String[] args) {
        Student4 student4 = new Student4();

        student4.method();

        // 访问静态方法
        student4.staticMethod();  // 不推荐使用
        Student4.staticMethod();  // 推荐使用
    }
}

注意：

1.静态属性和方法推荐使用类直接调用。

2.静态不能直接访问非静态，因为在内存中先有的静态内容，再有的非静态内容

3.静态方法不能使用this

package base7_class;

public class Demo07StaticMethod {
    int num;
    static int staticNum;

    public void method() {
        System.out.println("成员方法");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(staticNum);
    }

    public static void staticMethod() {
        System.out.println("静态方法");
        // 成员方法可以访问静态变量
        System.out.println(staticNum);
        // 成员方法不可以访问成员变量
        // System.out.println(num);
        // 静态方法中不能使用this
        // System.out.println(this);  // 错误写法
    }

}

3.静态代码块

使用static修饰的代码。静态代码块总是优先执行，且只在第一次使用类时执行唯一的一次。

package base7_class;

public class Student5 {
    static {
        System.out.println("静态代码执行");
    }

    public Student5() {
        System.out.println("构造方法执行");
    }
}

package base7_class;

public class Demo08StaticCode {
    public static void main(String[] args) {
        // 第一次new时，使用了类和构造方法，静态代码块和构造方法都执行，且静态代码先执行
        Student5 student = new Student5();

        // 第二次new对象，静态代码不再执行
        Student5 student2 = new Student5();
    }
}