java_day03下午

#3.1(下午) 面向对象

3.1.1 什么是类

//类定义的格式
public class classname{
    //成员变量;
    //成员方法;
}

//一个demo
 public class Student{
        //成员变量
        String nmae;
        int age;
        //成员方法
        //学习方法
        public void study(){
            System.out.println("学习");
        }
        public void eat(){
            System.out.println("吃饭");
        }
    }

注意事项
1. 成员变量直接定义在类里，在方法外边
2. 成员方法不要写static

3.1.2 如何使用类

1. 导包
    指出包的位置
    ```java
    import 包名称.类名称
    ```
2. 创建
    ```java
    类名称 对象名 = new 类名称();
    Student stu = new Student();
    ```
3. 使用
   ```java
   使用成员变量：对象名.成员变量名
   成员方法类似
   ````

一个demo

//定义类
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    //学习方法
    public void study() {
        System.out.println(name+"学习");
    }

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

//运行程序

// 导包 同一个包可省略
public class Demo10student {
    public static void main(String[] args) {
        //创建
        Student stu = new Student();
        //使用成员
        stu.name = "韩鹏博";
        stu.age = 22;
        //使用成员方法
        stu.study();
        stu.eat();
    }
}

3.2 局部变量和成员变量

1. 定义的位置不一样
   * 局部变量：在方法内部
   * 成员变量：在方法外部，直接写在类里面
2. 作用范围不一样
   * 局部变量：只有方法当中才可以使用
   * 成员变量：整个类都可以通用

因为成员变量new出来的对象在堆区里面，而普通的在栈区
3. 默认值不一样
* 局部变量没有默认值，如果想使用必须手动赋值
* 成员变量有默认值
4. 生命周期不一样，体现在内存位置

3.3 封装

找个人帮你做事，不管他怎么做，做好结果给你就好了

3.3.1 private

1. private是一个权限修饰符，代表最小权限
2. 可以修饰成员变量和成员方法
3. 被private修饰的成员方法只能在本类中访问

// private的使用格式
private 数据类型 变量名;

// private修饰的一个demo
public class Student{
    //这样两个成员变量就不能被访问了
    private Sting name;
    private int age;
    // 需要getxx() setxx()
    public void setName(String n){
      name = n;
    }
    public void setAge(int n){
      age = n;
    }
    public String getName(){
      return name;
    }
    public String getAge(){
      return Age;
    }
}

3.3.2 this

this代表所在类的当前对象的引用(地址)，即对象自己的引用

this.成员变量名
//一个demo
public class Phone {
    private String brand;
    private double price;
    private String color;
    public void call(String name){
        System.out.println("打电话给"+name);
    }
    public void sendMessage(){
        System.out.println("群发短信");
    }

    public String getBrand() {
        return brand;
    }

    public double getPrice() {
        return price;
    }

    public String getColor() {
        return color;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

3.3.3 构造方法

构造方法是用来创建对象的方法，我们通过new创建对象时 其实就是调用构造方法

格式
public 类名称(参数类型 参数名称){
方法体；
}
注意事项：

1. 构造方法的名称必须和所在类的名称完全一样
2. 构造方法不需要返回值，连void都不写
3. 如果没有构造方法，那么系统会自己生成一个，什么都不做
4. 不能return
5. 如果写了至少一个构造方法 那么编译器就不自动生成了
6. 如果你写了一个代参的，那么本身那个就没有了 所以需要重载
   一个demo

/*
构造方法是用来创建对象的方法，我们通过new创建对象时 其实就是调用构造方法

格式
public 类名称(参数类型 参数名称){
    方法体；
}
注意事项：
1. 构造方法的名称必须和所在类的名称完全一样
2. 构造方法不需要返回值，连void都不写
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //成员方法
    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

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

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

一个标准的类由以下四个组成
1. 所有的属性都使用private
2. 为每一个成员变量都写一对 get set
3. 编写一个全参的构造方法
4. 编写一个无参的构造方法