类和对象、private关键字、构造方法

类和对象的关系

类就是一类对象的统称。对象就是这一类具体化的一个实例。
打个比方类就像铸件模具，而对象就是通过模具生产出的一个个实体。
类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

类的定义与实例化

基本语法

// 创建类
class <class_name>{  
    field;//成员属性
    method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

定义一个Student类

public class Student {
    //成员变量
    String name;
    int age;
    //成员方法
    public void study(){
        System.out.println("学习!");
    }
    public void exercise(){
        System.out.println("打篮球");
    }
    public void sleep(){
        System.out.println("早睡早起");
    }
}

注意事项：

1. 成员变量定义在类当中，方法外。
2. 成员方法不要写static关键字。

创建对象

public class Demo3Student {
    public static void main(String[] args) {
        //g根据Student类,创建一个stu对象
        Student stu1 = new Student();
        //使用成员变量,格式
        //对象名.成员变量名
        System.out.println(stu1.name);      //未初始化
        System.out.println(stu1.age);
        System.out.println("=============");
        stu1.name = "张三";
        stu1.age = 18;
        System.out.println(stu1.name);      //初始化后
        System.out.println(stu1.age);
        stu1.study();                       //使用成员方法
        stu1.exercise();
        stu1.sleep();
    }
}

局部变量和成员变量
1.定义的位置不一样
局部变量：方法内部
成员变量：方法外部，直接写在类中

2.作用范围不一样
局部变量：只有方法当中可以使用，除了方法就不能在用
成员变量：这个类都能使用

3.默认值不一样
局部变量：没有默认值，需要手动进行赋值
成员变量：如果没有赋值，会有默认值。

4.内存位置不一样
局部变量：位于栈内存，随着方法进栈诞生，出栈消失
成员变量：位于堆内存，随着对象创建而诞生，对象被回收而消失

private关键字

作用：被 private 修饰的成员变量或者成员方法, 只能在本类中访问，不能被类的调用者使用。对成员变量或方法起到封装的作用。

 public class Person {
    String name;
    private int age;	//被private修饰

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

}

public class Demo04Person {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();

        person.name = "李四";
        person.age = 22;        //属性被private修饰,无法访问
        person.show();
    }
}

这时就需要在类中创建setter、getter方法来设置和获取被private修饰的属性

    public void setAge(int num){
        if(num >= 0 && num <= 120){
            age = num;
        }else{
            System.out.println("数据不正常");	//数据不合理时报错
        }
    }

    public int getAge(){
        System.out.println(age);
        return age;
    }

public class Demo04Person {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();

        System.out.println("=======修改后=======");
        person.name = "李四";
        //直接访问age是错误写法
        //person.age = 22;        //属性被private修饰,无法访问
        person.setAge(22);
        //同理想要获取age属性,也不能直接打印,也需要用到getter方法
        person.show();
        //同理想要获取age属性,也不能直接打印,也需要用到getter方法
        person.getAge();
    }
}

构造方法

构造方法是专门用来创建对象的方法，当我们通过new关键字创建对象时，就是在调用构造方法

格式：

public 类名称(参数类型 参数名称){
方法体
}

注意:

1. 构造方法名称必须和所在类名称一样。
2. 构造方法不要写返回值类型。
3. 构造方法不能return返回值。
4. 如果没有写构造方法,编译器会默认一个构造方法,没有参数也没有方法体。
5. 构造方法也可以进行重载。

示例

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

    public Student(){
        System.out.println("无参构造方法已执行");
    }
    public Student(String name,int age){        //构造方法重载
        System.out.println("有参构造方法已执行");
        this.name = name;
        this.age = age;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

public class Demo01Student {
    public static void main(String[] args) {
        Student stu1 = new Student(); //无参构造
        System.out.println("===================");

        Student stu2 = new Student("张三",18);
        System.out.println("姓名:" + stu2.getName() + "年龄:" + stu2.getAge());
    }
}