⚾️ 封装

面向对象三大特征之一

什么是封装

封装是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式

怎么隐藏对象的属性

想要隐藏对象的属性，只需要在定义属性的前面加上一个关键字private即可

怎么提供公共的访问方式？

就是在类中写上几个setXXX()和getXXX()即可

🤽‍♀️ private关键字

private关键字是一个修饰符，代表私有的意思，可以修饰成员变量和成员方法和构造方法，提供安全性

private关键字的特点？
被private修饰的成员变量和成员方法只能在本类中使用，不能在其他类中使用

加上private关键字之后的标准代码该如何写？

class Person {
    private String name;  //加private起到封装的作用
    private int age;
    private String sex;
    public void setName(String n) {
        name = n;
    }
    public void setAge(int a)    //变量名不够见命知义
        age = a;
    }
    public void setSex(String s) {
        sex = s;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getSex() {
        return sex;
    }
}

🏆 this关键字

this代表对象的引用，哪个对象调用this所在的方法，this就代表哪个对象

this.name=对象名.name

this关键字有什么用？

它可以解决局部变量隐藏成员变量的问题
可以调用本类中的成员变量和成员方法和构造方法

加上this关键字之后的标准代码如何写呢？

class Person {
    private String name;
    private int age;
    private String sex;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int aage) {
        this.age = aget;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getName() {
        return this.name; //因为只有一个name，所有可以省略this不写
    }
    public int getAge() {
        return this.age;
    }
    public String getSex() {
        return this.sex;
    }
}

🎻 构造方法

方法名和类名相同，和普通方法的格式不一样的特殊的方法

构造方法的定义格式

修饰符 类名(形参,...) {
    执行语句;
}
public Person() {
}

构造方法的作用

用来创建对象 ```java public class Demo2 { public static void main(String[] args) {
```
 Dog dog = new Dog(); //调用Dog()方法创建对象
```
} }

class Dog { public Dog() { } public Dog(int a, int b) { } }


2. 用来对象的属性进行初始化
<a name="pNu5I"></a>
## 构造方法的特点
1. 构造方法没有返回值类型
1. 构造方法没有返回值
可不可以有return关键字？<br />可以有renturn，但一般不写
3. 构造方法的名字一定要和类名相同
普通方法的名字可不可以和类名相同？<br /> 可以的
<a name="yspwO"></a>
## 构造方法的注意事项
1. 如果我们没有手动写构造方法的话，系统会默认带一个无参构造。如果我们手动写了构造方法的话，系统默认带的无参构造就消失了
2. 构造方法也是方法，既然是方法，就会满足方法的重载，也就说一个类中可以写多个构造方法
```java
class Person {
    public Person() {
    }
    public Person(String name) {
    }
    public Person(i nt age) {
    }
    public Person(String name,int age) {
    }
}

一个类中写多个构造方法的作用

可以根据不同的需求来调用不同的构造方法 ```java class Child { String name; int age;

public Child() {}

public Child(String name) {
```
 this.name = name;
```
}

public Child(int age) {
```
 this.age = age;
```
}

public Child(String name, int age) {
```
 this.name = name;
 this.age = age;
```
} }

class Demo { public static void main(String[] args) { //需求：孩子出生时候，没有姓名没有年龄 Child c1 = new Child(); System.out.println(c1.name + “…” + c1.age);//null…0

    //需求：孩子出生时候，有姓名，但是没年龄
    Child c2 = new Child("张三");
    System.out.println(c2.name + "..." + c2.age);//张三...0
    //需求：孩子出生时候，有姓名，有年龄
    Child c3 = new Child("哪吒", 18);
    System.out.println(c3.name + "..." + c3.age);//哪吒...18
}

}


2. 有参的构造方法可以给属性赋值
```java
class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return this.age;
    }
}
class Demo {
    public static void main(String[] args) {
        /*
            Person p = new Person();
            p.setName("tom");
            p.setAge(18);
        */
        Person p = new Person("tom", 18);
    }
}

通过有参构造给属性赋值和通过setXXX给属性的区别

setXXX方式赋值可以使用N多次

有参构造方式赋值只能使用一次

有参构造方式是先天的

setXXX方式是后天的

加上构造方法之后的标准代码怎么写？

class Person {
    private String name;
    private int age;
    public Person() {}
    public Person(String name, int age) {
        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 void eat() {
        System.out.println("吃饭");
    }
}

在我们创建对象的时候，内存中做了哪些事情

class Person {
    String name = "tom";
    int age = 18;
    public Person() {
        name = "jerry";
        age = 19;
    }
}
class Demo {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.name + "..." + p.age);
    }
}

默认初始化
显示初始化
构造方法初始化

五子棋

JavaFX
画棋盘

有舞台(Stage)
舞台上有场景(Scene)
场景中有画板(Pane)
五子棋盘画在画板中

package com_2;
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.layout.Pane;
import javafx.scene.shape.Line;
import javafx.stage.Stage;
public class MyApplication extends Application {
    @Override
    public void start(Stage stage) throws Exception {
        //创建画板对象
        Pane pane = new Pane();
        //创建线条对象
        Line line = new Line(50, 50, 50, 550);
        Line line1 = new Line(50, 50, 550, 50);
        //将线条放到画板上
        /*
            pane.getChildren()：获取到一个容器
            .add(line)：将线条放到容器中
         */
        pane.getChildren().add(line);
        pane.getChildren().add(line1);
        //创建场景对象，并且将画板放到场景中
        Scene scene = new Scene(pane, 600, 600);
        //将场景放到舞台上
        stage.setScene(scene);
        //展示大舞台
        stage.show();
    }
    //程序执行的入口
    public static void main(String[] args) {
        launch(args);
    }
}
/*
class Scene {
    public Scene(A) {
    }
    public Scene(A,B,C) {
    }
}
class Stage {
    public void show() {
    }
}*/

🥅 static关键字

它是一个修饰符，代表静态的意思，它可以修饰成员变量和成员方法，不能修饰构造方法，

static关键字的特点

被static所修饰的成员是随着字节码文件对象的加载而加载，所以是优先于对象存在于内存中
被static所修饰的成员被该类下所有的对象所共享

被static所修饰的成员可以通过类名.直接调用
```
类名.属性名;
类名.方法名();
```

static关键字的注意事项

静态方法中不能有this关键字
静态方法中可以调用静态成员变量和静态成员方法，但是不可以调用非静态的成员变量和调用方法

非静态方法中可以调用静态的成员变量和成员方法，也可以调用非静态的成员变量和成员方法

class Pig {
    String name:
    static int age;
    public static void eat() {
        drink()； 
        sleep()； //编译报错，非静态方法
        System.out.printin(age)；
        System.out.printin(name)；//编译报错,非静态属性
    }
    public static void drink() {
    }
    bublic void sleep() {
    }
}

Java 学习笔记

06-封装