庖丁解牛，洞悉 Java 面向对象的精妙架构

import java.util.Random;
import java.util.Scanner;

public class mian {
    public static void main(String[] args) {
        //面向对象，导入一个随机数
        Random r = new Random();
        int data = r.nextInt(10)+1;
        //面向对象，输入一个随机数
        System.out.println(data);

        Scanner sc = new Scanner(System.in);
        // 面向对象，输出一个数
        System.out.println("请输入一个数：");
        int a = sc.nextInt();
        System.out.println(a);
    }
}

public class 类名{
    1.成员变量（代表属性，一般是名词）
    2.成员方法（代表行为，一般是动词）
    3.构造器（后面学习）
    4.代码块（后面学习）
    5.内部类（后面学习）
}

public class Phone{
    //属性（成员变量）
    String brand;
    double price; 
    public void call(){
    }
    public void playGame(){
    }
}

如何得到类的对象：

类名 对象名= new 类名（）;
Phone p = new Phone();

对象.成员变量;
对象.成员方法（...）

public class phone {
    //属性
    String name;
    double price;
    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("发短信");
    }
}

//测试

public class phoneTest {
    public static void main(String[] args) {
        //创建手机对象
        phone p = new phone();
        //给手机对象赋值
        p.name = "小米";
        p.price = 1999;
        //获取手机对象的属性值
        System.out.println(p.name);
        System.out.println(p.price);
        //调用手机对象的方法
        p.call();
        p.send();

    }
}

public class 类名 {
    1.成员变量（代表属性）
    2.成员方法（代表行为）
}

public class Student {
    //属性（成员变量）
    String name;
    int age;
    //行为方法
    public void study(){
        System.out.println("好好学习，天天向上");
    }
    public void doHomework(){
        System.out.println("键盘敲烂，月薪过万");
    }
}

int age;
//这里不写初始化值是因为，这里学生的年龄是一个群体的值，没有一个固定的初始化值。
//如果给age赋值，比如是18岁，那就代表者所有的学生年龄都是18岁。

//类的赋值不是在类里面赋值，而是在创建了对象之后再赋值，这时赋值的时这个特定的对象。
Student stu = new Student();
Stu.name="张三";
Stu.height=187;

//编写女朋友类，创建女朋友类的对象，给女朋友的属性赋值并调用女朋友类中的方法。自己思考女朋友有哪些属性，有哪些行为？
public class girlFriend {
    public static void main(String[] args) {
        //创建女朋友对象
        girl g = new girl();
        //给女朋友对象赋值
        g.name = "小红";
        g.age = 20;
        g.hobby = "唱歌";
        //获取女朋友对象的属性值
        System.out.println(g.name);
        System.out.println(g.age);
        System.out.println(g.hobby);
        //调用女朋友对象的方法
        g.eat();
        g.sleep();
    }
}

//这是一个类
public class girl {
    //成员变量（代表属性）
    String name;
    int age;
    String hobby;
    //成员方法（代表行为）
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

/**需求：定义一个类描述人
属性：姓名、年龄
行为：吃饭、睡觉*/
public class Person{
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭")；
    }
    public void sleep(){
        System.out.println("睡觉")；
    }
}

public class Circle {
    double radius;
    public void draw(){
        System.out.println("根据半径"+radius+"画圆");
    }
}
//人画圆，我们通常人为行为主体是人，其实是圆
//例如：人关门，这个门一定是门自己关的，人只是给了作用力，是门自己关上的。

public class GirlFriend{
    private String name;
    private int age;
    private String gender;
}

public class leiMing {
    private int age;
    //set(赋值)
    public void setAge(int a){
        if(a<0||a>120){
            System.out.println("你给的年龄有误");
            return;
        }
        age = a;
    }
    //get(取值)
    public int getAge(){
        return age;
    }
}

public class GirlFriend{
    private int age;//成员变量:方法的外面，类的里面
    public void method(){
        int age = 10;//局部变量：方法的里面
        System.out.println(age);
    }
}

public class GirlFriend{
    private int age;//成员变量:方法的外面，类的里面
    public void method(){
        int age = 10;//局部变量：方法的里面
        System.out.println(age);
    }
}
//在这里中，最后1个age距离 age=10最近，所以最后一个age用的是10的值
//假如我想用第一个int ，我们可以在System.out.println(this.age)
age前加入：this. 这里就可以打破就近原则，选择另一个变量

class Employee {
    // 定义成员变量
    private String name;
    private int age;

    // 构造方法，用于初始化员工信息
    public Employee(String name, int age) {
        // 这里参数名和成员变量名相同，使用 this 引用成员变量
        this.name = name;
        this.age = age;
    }

    // 设置员工姓名的方法
    public void setName(String name) {
        // 使用 this 引用成员变量
        this.name = name;
    }

    // 获取员工姓名的方法
    public String getName() {
        return this.name;
    }

    // 设置员工年龄的方法
    public void setAge(int age) {
        // 使用 this 引用成员变量
        this.age = age;
    }

    // 获取员工年龄的方法
    public int getAge() {
        return this.age;
    }

    // 显示员工信息的方法
    public void displayInfo() {
        System.out.println("姓名: " + this.name + ", 年龄: " + this.age);
    }
}

public class ThisKeywordVariableExample {
    public static void main(String[] args) {
        // 创建一个 Employee 对象
        Employee employee = new Employee("李四", 25);
        // 调用 displayInfo 方法显示员工信息
        employee.displayInfo();

        // 调用 setName 和 setAge 方法修改员工信息
        employee.setName("王五");
        employee.setAge(30);
        // 再次调用 displayInfo 方法显示修改后的员工信息
        employee.displayInfo();
    }
}

private String name;
private int age;

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

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

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

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

public void displayInfo() {
    System.out.println("姓名: " + this.name + ", 年龄: " + this.age);
}

public class Student{
    修饰符 类名（参数）{
        方法体;
    }
}

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

    //如果我们自己没有写构造方法
    // 那么编译器会自动生成一个无参构造方法

    public Student() {
        System.out.println("无参构造方法");
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age; //有参构造方法
    }
    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;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        //创建类的对象
        //调用的空参构造
        //Student s1 = new Student();
        Student s = new Student(name:"张三", age:20);
        System.out.println(s.getName());
        System.out.println(s.getAge());

    }
}

public class Student{
    private String name;
    private int age;
    
    public Student(){
     ...//空参构造方法
    }
    
    public Student (String name, int age){
    ....//带全部参数构造方法
    }
}

举例子：
根据一个登录界面写一个JavaBean类
public class User {
    //属性
    private String username;
    private String password;
    private String email;
    private String gender;
    private int age;

    //构造方法
    //无参构造
    public User() {
    }
    //有参构造
    public User(String username, String password, String email, String gender, int age) {
        this.username = username;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }

    //方法
    //set和get方法
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

我们再写一个javabean中会遇到一个问题：
这样写纯体力活啊！没事的没事的！我们有快捷键：
    
方法一：
    
alt+insert 或 alt+insert+Fn
alt+insert 第一个是构造函数，点击无选择生成的是空参 ，全选ok生成的是有参数的构造函数
alt+insert 点击setter和geteer，全选生成的是set和get
    
方法二：
    
下载插件pdg,下载完成后点击空白处就会出现。然后点击Ptg To JavaBean

Student s = new Student();

举例：
public class Student{
    String name;
    int age;
    
    public void study(){
        System.out.println("好好学习")
    }
}

public class TestStudent{
    public static void main(String [] args){
        Student s= new Student();
        System.out.println(s);
        System.out.println(s.name+"...."+s.age);
        s.name = "阿强";
        s.age = 23;
        System.out.println(s.name+"..."+s.age);
        s.study();
    }
}

Student.class

TestStudent.class

s

举例：
public class Student{
    String name;
    int age;
    
    public void study(){
        System.out.println("好好学习");
    }
}

public class TestStudent{
    public static void main(String [] args){
        Student s= new Student();
        System.out.println(s);
        s.name = "阿强";
        s.age = 23;
        System.out.println(s.name+"..."+s.age);
        s.study();
        
        Student s2= new Student();
        System.out.println(s2);
        s2.name = "阿珍";
        s2.age = 24;
        System.out.println(s2.name+"..."+s2.age);
        s2.study();
    }
}

Student@1b6d3586  
阿强...23  
好好学习  
Student@4554617c  
阿珍...24  
好好学习  

举例：
public class Student{
    String name;
    int age;
    
    public void study(){
        System.out.println("好好学习");
    }
}

public class TestStudent{
    public static void main(String [] args){
        Student s= new Student();
        s.name = "阿强";
    
        Student s2= s;
        s2.name = "阿珍";
        System.out.println(s.name+"..."+s2.name);
    }
}

public class Student{
    private int age;
    public void method(){
        int age=10;
        System.out.println(age);//10
        System.out.println(this.age);//成员变量的值 0
    }
}

public class Student{
    private int age;
    public void method(){
        int age=10;
        System.out.println(age);//10
        System.out.println(this.age);//成员变量的值 0
    }
}

public class StudentTest{
    public static void main (String[] args){
        Student s = new Student();
        s.method();
    }
}

method()

java复制aload_0         // 将this引用压入操作数栈（对应堆地址0x7a3f）
getfield #2    // 根据字段偏移量读取堆中age值（#2为字段符号引用）

public class Test{
    public static void main (String [] args){
        int a = 10;
    }
}

public class TestStudent{
    public static void main(String[] args){
        Student s=new Student;
    }
}