[JAVA进阶]一文理解面向对象编程（超详细2w字巨作！）

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;
    }
}

需求：写一个JavaBean类来描述这个班级的学生
属性：姓名、年龄、性别
行为：学习

package staticdemo;

public class Student {
    //属性：姓名，年龄，性别
    //新增：老师的姓名
    private String name;
    private int age;
    private String gender;
    public  static  String teacherName;


    public Student() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    //行为
    public void study(){
        System.out.println(name+"正在学习");
    }
    public void show(){
        System.out.println(name+","+age+","+gender+","+teacherName);
    }
}

package staticdemo;

public class StudentTest {
    public static void main(String[] args) {
        //1.创建第一个学生对象
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(20);
        s1.setGender("男");
        //公共类，但是s2没有创建对象，所以无法访问teacherName，为null
        //public String teacherName;

        //于是我们想了个方法，用static修饰teacherName，但是这样就变成了静态属性，所有对象共享
        //public  static  String teacherName;
        s1.teacherName = "王老师";

        //还可以用类名.属性名来访问
        //Student.teacherName = "王老师";

        s1.study();
        s1.show();

        //2.创建第二个学生对象
        Student s2 = new Student();
        s2.setName("李四");
        s2.setAge(21);
        s2.setGender("女");

        s2.study();
        s2.show();

    }
}

package sta02;

public class ArrayUtil {
    //私有构造方法，防止外部实例化
    private ArrayUtil() {}
    public static String printArray(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append( "[");
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]);
            if (i < arr.length - 1) {
                sb.append(", ");
            }else {
                sb.append("]");
            }
        }
        return sb.toString();
    }
    public static double getArray(double[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];  //累加数组元素
        }
        return sum/arr.length;
    }
}

package sta02;

public class Testdemo {
    public static void main(String[] args) {
        //测试printArray方法
        int[] arr = {1, 2, 3, 4, 5};
        String result = ArrayUtil.printArray(arr);
        System.out.println(result);
        //测试getArray方法
        double[] arr2 = {1.0, 2.0, 3.0, 4.0, 5.0};
        double average = ArrayUtil.getArray(arr2);
        System.out.println(average);
    }
}

package sat03;

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

    public Student() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }


}

package sat03;

import java.util.ArrayList;

public class StudentUtil {
    //私有构造方法，防止外部实例化
    private StudentUtil() {}
    //静态方法
    public static int getMaxScore(ArrayList<Student> list ) {
        //1.定义一个参照物
        int maxAge = list.get(0).getAge();
        //2.遍历集合
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).getAge() > maxAge) {
                maxAge = list.get(i).getAge();
            }
        }
        return maxAge;

    }
}

package sat03;

import java.util.ArrayList;

public class testmax {
    public static void main(String[] args) {
        //1.创建一个集合来存储
        ArrayList<Student> list = new ArrayList<Student>();
        //2.创建3个学生对象
        Student s1 = new Student("Zhangsan", 20, "男");
        Student s2 = new Student("lisi", 23, "男");
        Student s3 = new Student("wangwu", 25, "女");
        //3.将学生对象添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //4.调用方法
        int max=StudentUtil.getMaxScore(list);
        System.out.println(max);
    }
}

public class HelloWorld{
    public static void main (String[] args){
        System.out.println("HelloWorld");
    }
}

public class Student extends Person{}

package st5;

public class Animal {
    public void eat() {
        System.out.println("我会吃饭");
    }
    public void water (){
        System.out.println("我会喝水");
    }
}

package st5;

public class Cat extends Animal {
    public void mice() {
        System.out.println("我会抓老鼠");
    }

}

package st5;

public class Dog extends Animal {
    public void lookhome() {
        System.out.println("我会看家");
    }

}

package st5;

public class Ragdoll extends Cat{

}

package st5;

public class Lihua extends Cat{

}

package st5;

public class Husky extends Dog{
    public void breakhome() {
        System.out.println("我会拆家");
    }
}

package st5;

public class Teddy extends Dog{
    public void Ceng(){
        System.out.println("我喜欢蹭一蹭");
    }
}

package st5;

public class Test {
    public static void main(String[] args) {
        //创建对象并调用方法

        //创建布偶猫的对象
        Ragdoll rd = new Ragdoll();
        System.out.println("我是布偶猫");
        rd.mice();
        rd.water();
        rd.eat();
        System.out.println("-------------------");

        //创建狸花猫的对象
        Lihua lh = new Lihua();
        System.out.println("我是狸花猫");
        lh.mice();
        lh.water();
        lh.eat();
        System.out.println("-------------------");

        //创建泰迪的对象
        Teddy td = new Teddy();
        System.out.println("我是泰迪");
        td.lookhome();
        td.water();
        td.eat();
        td.Ceng();
        System.out.println("-------------------");

        //创建哈士奇的对象
        Husky hs = new Husky();
        System.out.println("我是哈士奇");
        hs.lookhome();
        hs.water();
        hs.eat();
        hs.breakhome();

    }
}

public class Fu{
    String name = "Fu";
}
public class Zi extends Fu{
    String name = "Zi";
    public void ziShow(){
        String name = "ziShow";
        System.out.println(name);
    }
}
//就近原则:谁离我近，我就用谁
//完整版就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上
//run:ziShow

System.out.println(name);//从局部位置开始往上找
System.out.println(this.name);//从本类成员位置开始往上找
System.out.println(super.name);//从父类成员位置开始往上找

public class Test{
    public static void main (String [] args){
        Zi z = new Zi();
        z.ziShow();
    }
}

public class Fu{
    String name = "Fu";
}
public class Zi extends Fu{
    String name = "Zi";
    public void ziShow(){
        String name = "ziShow";
        System.out.println(name);//ziShow
        System.out.println(this.name);//Zi
        System.out.println(super.name);//Fu
    }
}

package jicehng;

public class test {
    public static void main(String[] args) {
        //创建一个对象
        Student s = new Student();
        s.lunch();
        /*
        吃面条
        咖啡
        吃米饭
        喝水
         */
    }
}
class Person {
    public void eat(){
        System.out.println("吃米饭");
    }
    public void water(){
        System.out.println("喝水");
    }
}
class Student extends Person {
    public void lunch(){
        this.eat();//就近读取子类吃面条
        this.water();//就近读取子类咖啡

        super.eat();//调用父类吃米饭
        super.water();//调用父类喝水
    }
    public void eat(){
        System.out.println("吃面条");
    }
    public void water(){
        System.out.println("咖啡");
    }
}

package jice;

public class Dog {
    public void eat() {
        System.out.println("Dog is eating.");
    }
    public void drink() {
        System.out.println("Dog is drinking.");
    }
    public void lookhome() {
        System.out.println("Dog is lookhome.");
    }
}

package jice;

public class hashiqi extends Dog {
    public void breakhome() {
        System.out.println("hashiqi is breakhome.");
    }
}

package jice;

public class shapi extends Dog{
    @Override
    public void eat() {
        super.eat();// 调用父类的eat方法
        System.out.println("shapi is eating gouliang.");
    }
}

package jice;

public class chinesedog extends Dog{
    @Override
    public void eat() {
        super.eat();// 调用父类的eat方法
        System.out.println("Chinesedog is eating chinesefood.");
    }
}

package jice;

public class test {
    public static void main(String[] args) {
        hashiqi hashiqi = new hashiqi();
        hashiqi.eat();
        hashiqi.drink();
        hashiqi.lookhome();

        shapi shapi = new shapi();
        shapi.eat();
        shapi.drink();
        shapi.lookhome();

        chinesedog chinesedog = new chinesedog();
        chinesedog.eat();
        chinesedog.drink();
    }
}

package sta08;

public class Person {
    String name;
    int age;

    public Person() {
        System.out.println("父类的无参构造方法");
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

package sta08;

public class Student extends Person {
    public Student() {
        //子类构造方法中隐藏的super()去访问父类的无参构造
        super();
        System.out.println("子类的无参构造方法");
    }
}

package sta08;

public class test {
    public static void main(String[] args) {
        //创建学生对象
        Student stu = new Student();
    }
}

package sta09;

public class Employee {
    //1.类名见名知意
    //2.属性私有
    //3.构造方法（空参 带全部参数的构造）
    //4.get/set

    private String id;
    private String name;
    private double salary;

    public Employee() {
    }
    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //方法
    public void work() {
        System.out.println("员工在工作");
    }
    public void eat(){
        System.out.println("员工在吃饭吃米饭");
    }

}

package sta09;

public class Manager  extends Employee{

    private double bonus;
    public Manager() {

    }
    //带全部参数的构造
    public Manager(String id, String name, double salary,double bonus) {
        super(id, name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    //重写父类的方法
    @Override
    public void work() {
        System.out.println("经理在管理其他人");
    }
}

package sta09;

public class Cook extends Employee{

    public Cook() {
    }

    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }

    @Override
    public void work() {
        System.out.println("厨师在烹饪");
    }
}

package sta09;

public class Test {
    public static void main(String[] args) {
        //创建一个经理对象
        Manager manager = new Manager("001","小明",100000,50000);
        System.out.println(manager.getId()+","+manager.getName()+
                ","+manager.getSalary()+","+manager.getBonus());
        manager.work();
        manager.eat();
        //创建一个厨师对象
        Cook cook = new Cook("002","小红",80000);
        System.out.println(cook.getId()+","+cook.getName()+
                ","+cook.getSalary());
        cook.work();
        cook.eat();

    }
}

package sta01;

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

    public Person() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }
    public void show() {
        System.out.println(name + " " + age);
    }


}

package sta01;

public class Student extends Person {
    @Override
    public void show() {
        System.out.println("学生信息为："+getName()+" "+getAge());
    }

}

package sta01;

public class Teacher extends Person {
    @Override
    public void show() {
        System.out.println("教师信息为："+getName()+" "+getAge());
    }
}

package sta01;

public class Administrator extends Person {
    @Override
    public void show() {
        System.out.println("管理员信息为："+getName()+" "+getAge());
    }
}

package sta01;

public class test {
    public static void main(String[] args) {
        //创建三个学生对象
        Student s1 = new Student();
        s1.setName("小明");
        s1.setAge(23);
        Student s2 = new Student();
        s2.setName("小红");
        s2.setAge(23);
        Student s3 = new Student();
        s3.setName("小刚");
        s3.setAge(23);
        //创建一个老师对象
        Teacher t1 = new Teacher();
        t1.setName("王老师");
        t1.setAge(45);
        //创建一个管理员对象
        Administrator a1 = new Administrator();
        a1.setName("李管理员");
        a1.setAge(23);
        //传递方法
        register(s1);
        register(s2);
        register(s3);
        register(t1);
        register(a1);

    }
    //这个方法能接受老师，也能接受学生,还能接受管理员
    public static void register(Person p) {
        p.show();

    }
}

package sta02;

public class test {
    public static void main(String[] args) {
        //创建对象（多态方式）
        Animal animal = new Dog();
        //成员变量
        //编译看左边，运行看左边
        //编译看左边：java编译器在编译代码时，会检查左边的父类中有没有这个变量，如果有就通过编译，否则就会报错。
        //运行看左边：在运行时，实际上是在执行父类中的变量，因为子类中没有这个变量，所以会输出父类中的变量值。

        System.out.println(animal.name);//动物

        //成员方法
        //编译看左边，运行看右边
        //编译看左边：java编译器在编译代码时，会检查左边的父类中有没有这个方法，如果有就通过编译，否则就会报错。
        //运行看右边：在运行时，实际上是在执行子类中的方法，因为子类中重写了这个方法，所以会输出子类中的方法值。

        animal.show();//Dog-----show方法
        
        //理解
        //Animal animal = new Dog();
        //现在用animal类型的，所以默认都会从父类Animal中找

        //成员变量：在子类的对象中，从父类的成员位置查找，无论是否有重写，都只看左边（父类）
        //成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法覆盖掉，只保留子类的方法，
        //所以在运行时，调用的是子类的方法，所以看右边（子类）
    }
}
class Animal {
    String name="动物";

    public void show(){
        System.out.println("Animal-----show方法");
    }
}
class Dog extends Animal{
    String name="狗";
    @Override
    public void show(){
        System.out.println("Dog-----show方法");
    }
}

Person p = new Student () ;
p.work() ; //业务逻辑发生改变时，后续代码无需修改
//假如，我想将Student改为Teacher,只需要把new Student () 改为new Teacher () 就可以了

Person p = new Student () ;//自动类型转换
Student s = (Student)p;//强制类型转换

// 定义父类：动物
abstract class Animal {
    public void eat() {
        System.out.println("动物在进食");
    }
    
    // 抽象方法，由子类实现
    public abstract void makeSound();
}

// 子类：狗（有特有方法guardHouse）
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗在汪汪叫");
    }
    
    // 狗特有的方法：看家
    public void guardHouse() {
        System.out.println("狗在看家护院");
    }
}

// 子类：猫
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫在喵喵叫");
    }
}

// 测试类
public class PolymorphismLimitationDemo {
    public static void main(String[] args) {
        // 多态：父类引用指向子类对象
        Animal dog = new Dog();
        Animal cat = new Cat();
        
        // 调用父类方法（正常工作）
        dog.eat();
        dog.makeSound();
        
        // 尝试调用子类特有方法（编译错误！）
        // dog.guardHouse(); 
        // 错误: 找不到符号
        // 符号: 方法 guardHouse()
        // 位置: 类型为Animal的变量dog
    }
}

public class PolymorphismCastingDemo {
    public static void main(String[] args) {
        // 多态引用
        Animal dog = new Dog();
        
        // 1. 安全的强制类型转换
        if (dog instanceof Dog) {
            Dog realDog = (Dog) dog; // 强制类型转换
            realDog.guardHouse(); // 访问子类特有方法
        }
        //instanceof的用法
        //他返回的是boolean值，左侧是要检查的对象引用，右侧是类名、接口名或是数组类型
        
        // 2. 不安全的强制类型转换（会抛出异常）
        // Cat cat = (Cat) dog; // 运行时抛出ClassCastException
        // cat.makeSound();
        //所以使用instanceof验证
        
        // 3. 类型转换最佳实践
        useDogFeatures(dog);
    }
    
    // 最佳实践：封装类型转换逻辑
    public static void useDogFeatures(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.guardHouse();
            dog.makeSound();
        } else {
            System.out.println("这不是一只狗，无法执行看家功能");
        }
    }
}

package sta03;

public class Animal {
    private int age;
    private String color;

    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return color
     */
    public String getColor() {
        return color;
    }

    /**
     * 设置
     * @param color
     */
    public void setColor(String color) {
        this.color = color;
    }

    public void eat(String something) {
        System.out.println("动物在吃："+something);

    }
}

package sta03;

public class Dog extends Animal{
    //空参构造
    //带上全部参数的构造


    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    //行为
    //eat（String something）(something是吃的东西)
    //看家lookHome()
    @Override
    public void eat(String something) {
        System.out.println(getAge()+"岁的"+getColor()+"颜色的狗两只前腿死死抱住"+something+"猛吃");
    }
    public void lookHome(){
        System.out.println("狗在看家");
    }
}

package sta03;

public class Cat extends Animal {

    public Cat() {
    }
    public Cat (int age, String color) {
        super(age, color);
    }
    @Override
    public void eat(String something) {
        System.out.println(getAge()+"岁的"+getColor()+"颜色的猫眯着眼睛吃"+something);
    }
    public void catchMouse(){
        System.out.println("猫在抓老鼠");
    }


}

package sta03;

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


    public Person() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    //饲养狗

    public void keepPet(Dog dog, String something) {
        System.out.println("年龄为"+age+"岁的"+name+"在养一只"+dog.getColor()+"颜色的狗"+dog.getAge()+"岁的狗");
        dog.eat(something);

    }

    //饲养猫
    public void keepPet(Cat cat, String something) {
        System.out.println("年龄为"+age+"岁的"+name+"在养一只"+cat.getColor()+"颜色的猫"+cat.getAge()+"岁的猫");
        cat.eat(something);
    }
}

package sta03;

public class test {
    public static void main(String[] args) {
        //创建对象并调用方法
        Dog dog = new Dog(2, "黑色");
        Person person1 = new Person("小明", 18);
        person1.keepPet(dog, "骨头");

        Person person2 = new Person("小红", 20);
        Cat cat = new Cat(3, "白色");
        person2.keepPet(cat, "鱼");

    }
}

package com.ensichen.domain;

public class Student {
    私有化成员变量
    构造方法
    成员方法
}

public class test {
    public static void main(String [] args ){
        com.ensichen.domain.Student s = new com.ensichen.domain.Student();
    }
}

import com.ensichen.domain.Student;//导包
public static void main(String [] args){
    Student s = new Student () ;
}

public class test {
    public static void main(String[] args) {
        //1.使用同一个包中的类时，不需要导包
        //创建对象
        Student s = new Student();
        s.setName("张三");
        s.setAge(20);
        System.out.println(s.getName()+":"+s.getAge());
    }    
}    

public class test {
    public static void main(String[] args) {
        //2.使用java.lang包下的类时，不需要导包
        String a = "abc";
        System.out.println(a);
        //我们要找String字符串到底定义在哪个包中，我们可以按住Ctrl键点击String，
        // 或者选中String，然后按Ctrl键+鼠标左键，或者Ctrl+B就可以跳转到String的源码中
    }    
}    

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

    public stu() {
        System.out.println("开始创建对象了");
    }

    public stu(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("开始创建对象了");
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "stu{name = " + name + ", age = " + age + "}";
    }
}

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

    {
        System.out.println("开始创建对象了");
    }
    public stu() {
       
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "stu{name = " + name + ", age = " + age + "}";
    }
}

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

    {
        System.out.println("开始创建对象了");
    }
    public stu() {
       System.out.println("空参构造器");
    }

    public stu(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造器");

    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "stu{name = " + name + ", age = " + age + "}";
    }
}

public class teest {
    public static void main(String[] args) {

           stu s1 = new stu();
           stu s2 = new stu("zhnagsan", 20);

    }
}

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

    static {
        System.out.println("静态代码块执行了");
    }
    public stu() {
       System.out.println("空参构造器");
    }

    public stu(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造器");

    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "stu{name = " + name + ", age = " + age + "}";
    }
}

public class teest {
    public static void main(String[] args) {
           stu s1 = new stu();
           stu s2 = new stu("zhnagsan", 20);

    }
}

package demo01;

public abstract class Person {
    public abstract void sayHello();

}

package demo01;

public class test {
    public static void main(String[] args) {
        // 抽象类不能被实例化，只能被继承
        Person person = new Person();
    }
}

package demo01;
public abstract class Person {
    //抽象类不一定有抽象方法
    public void sayHello(){
        System.out.println("Hello");
    }
}

package demo01;
public  abstract class Person {
    //有抽象方法一定是抽象类
    public  abstract void  sayHello();
}

package sta02;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public void drink(){
        System.out.println("动物喝水");
    }

    public abstract void eat();
}

package sta02;

public class Frog extends Animal{
    public Frog() {
    }
    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

}

package sta02;

public class Dog extends Animal{
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
}

package sta02;

public class Sheep extends Animal {
    public Sheep() {
    }
    public Sheep(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("羊在吃草");
    }
}

package sta02;

public class test {
    public static void main(String[] args) {
        Frog frog = new Frog("小绿", 1);
        System.out.println(frog.getName() + " " + frog.getAge());
        frog.eat();
        frog.drink();

        Dog dog = new Dog("小蓝", 2);
        System.out.println(dog.getName() + " " + dog.getAge());
        dog.eat();
        dog.drink();

        Sheep sheep = new Sheep("小红", 3);
        System.out.println(sheep.getName() + " " + sheep.getAge());
        sheep.eat();
        sheep.drink();

    }
}

package demo01;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat() ;
}

package demo01;

public class frog extends Animal{
    public frog() {

    }
    public frog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
    public void swimming() {
        System.out.println("青蛙在游泳");
    }
}

package demo01;

public class dog extends Animal{
    public dog() {

    }
    public dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
    public void dig() {
        System.out.println("狗在刨地");
    }
}

package demo01;

public class rabbit extends Animal{
    public rabbit() {

    }
    public rabbit(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }

}

package demo01;

public class test {
    public static void main(String[] args) {
        dog dog = new dog("小黑", 2);
        System.out.println(dog.getName() + "," + dog.getAge());
        dog.eat();
        dog.dig();
        frog f = new frog("小绿", 1);
        System.out.println(f.getName() + "," + f.getAge());
        f.eat();
        f.swimming();
        rabbit r = new rabbit("小红", 3);
        System.out.println(r.getName() + "," + r.getAge());
        r.eat();

    }
}

package demo02;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat() ;
}

package demo02;

public interface swim {
    public abstract void swimming();
}

package demo02;

public class Dog extends Animal implements swim{
    public Dog() {

    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void swimming() {
        System.out.println("狗会游泳");
    }
}

package demo02;

public class Frog extends Animal implements swim{
    public Frog() {

    }
    public Frog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("青蛙吃虫子");
    }

    @Override
    public void swimming() {
        System.out.println("青蛙会游泳");

    }
}

package demo02;
public class Rabbit extends Animal {
    public Rabbit() {
    }
    public Rabbit(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("兔子吃胡萝卜");
    }
}

package demo02;
public class test {
    public static void main(String[] args) {
        Dog dog = new Dog("小黑", 2);
        System.out.println(dog.getName()+" "+dog.getAge());
        dog.eat();
        dog.swimming();

        Frog f = new Frog("小绿", 1);
        System.out.println(f.getName()+" "+f.getAge());
        f.eat();
        f.swimming();

        Rabbit r = new Rabbit("小紫", 3);
        System.out.println(r.getName()+" "+r.getAge());
        r.eat();
    }
}

// 说英语的接口
public interface SpeakEnglish {
    void speakEnglish();
}

// 抽象类 - 人
public abstract class Person {
    private String name;
    private int age;

    public Person(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 abstract void doActivity();
}

// 抽象类 - 运动员，继承 Person
public abstract class Athlete extends Person {
    public Athlete(String name, int age) {
        super(name, age);
    }

    // 抽象方法，运动员的 “学习打球” 行为，子类具体实现
    public abstract void learnPlayBall();
}

// 抽象类 - 教练，继承 Person
public abstract class Coach extends Person {
    public Coach(String name, int age) {
        super(name, age);
    }

    // 抽象方法，教练的 “教打球” 行为，子类具体实现
    public abstract void teachPlayBall();
}

// 乒乓球运动员，继承 Athlete 并实现 SpeakEnglish 接口
public class PingPongAthlete extends Athlete implements SpeakEnglish {
    public PingPongAthlete(String name, int age) {
        super(name, age);
    }

    // 实现运动员 “学习打球” 抽象方法
    @Override
    public void learnPlayBall() {
        System.out.println(getName() + "（乒乓球运动员，年龄" + getAge() + "）正在学习打乒乓球");
    }

    // 实现说英语接口方法
    @Override
    public void speakEnglish() {
        System.out.println(getName() + "（乒乓球运动员）正在说英语交流");
    }

    // 实现 Person 类的抽象方法
    @Override
    public void doActivity() {
        learnPlayBall();
    }
}

// 篮球运动员，继承 Athlete
public class BasketballAthlete extends Athlete {
    public BasketballAthlete(String name, int age) {
        super(name, age);
    }

    // 实现运动员 “学习打球” 抽象方法
    @Override
    public void learnPlayBall() {
        System.out.println(getName() + "（篮球运动员，年龄" + getAge() + "）正在学习打篮球");
    }

    // 实现 Person 类的抽象方法
    @Override
    public void doActivity() {
        learnPlayBall();
    }
}

// 乒乓球教练，继承 Coach 并实现 SpeakEnglish 接口
public class PingPongCoach extends Coach implements SpeakEnglish {
    public PingPongCoach(String name, int age) {
        super(name, age);
    }

    // 实现教练 “教打球” 抽象方法
    @Override
    public void teachPlayBall() {
        System.out.println(getName() + "（乒乓球教练，年龄" + getAge() + "）正在教打乒乓球");
    }

    // 实现说英语接口方法
    @Override
    public void speakEnglish() {
        System.out.println(getName() + "（乒乓球教练）正在说英语交流");
    }

    // 实现 Person 类的抽象方法
    @Override
    public void doActivity() {
        teachPlayBall();
    }
}

// 篮球教练，继承 Coach
public class BasketballCoach extends Coach {
    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    // 实现教练 “教打球” 抽象方法
    @Override
    public void teachPlayBall() {
        System.out.println(getName() + "（篮球教练，年龄" + getAge() + "）正在教打篮球");
    }

    // 实现 Person 类的抽象方法
    @Override
    public void doActivity() {
        teachPlayBall();
    }
}

// 测试类，验证各个类功能
public class Test {
    public static void main(String[] args) {
        // 测试乒乓球运动员
        PingPongAthlete pingPongAthlete = new PingPongAthlete("小张", 20);
        pingPongAthlete.doActivity();
        pingPongAthlete.speakEnglish();

        // 测试篮球运动员
        BasketballAthlete basketballAthlete = new BasketballAthlete("小李", 22);
        basketballAthlete.doActivity();

        // 测试乒乓球教练
        PingPongCoach pingPongCoach = new PingPongCoach("王教练", 40);
        pingPongCoach.doActivity();
        pingPongCoach.speakEnglish();

        // 测试篮球教练
        BasketballCoach basketballCoach = new BasketballCoach("赵教练", 45);
        basketballCoach.doActivity();
    }
}

// 接口定义
interface DefaultMethodInterface {
    // 默认方法（带方法体）
    default void defaultMethod() {
        System.out.println("这是接口中的默认方法");
    }

    // 抽象方法（需实现类实现）
    void abstractMethod();
}

// 实现类
class DefaultMethodImpl implements DefaultMethodInterface {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }

    // 可选：重写默认方法
    @Override
    public void defaultMethod() {
        System.out.println("重写默认方法");
    }
}

// 测试类
public class DefaultMethodDemo {
    public static void main(String[] args) {
        DefaultMethodImpl obj = new DefaultMethodImpl();
        obj.defaultMethod();      // 调用默认方法
        obj.abstractMethod();     // 调用抽象方法
    }
}

// 接口定义
interface StaticMethodInterface {
    // 静态方法（带方法体）
    static void staticMethod() {
        System.out.println("这是接口中的静态方法");
    }

    // 抽象方法
    void abstractMethod();
}

// 实现类
class StaticMethodImpl implements StaticMethodInterface {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }
}

// 测试类
public class StaticMethodDemo {
    public static void main(String[] args) {
        StaticMethodImpl obj = new StaticMethodImpl();
        obj.abstractMethod();             // 调用抽象方法
        StaticMethodInterface.staticMethod(); // 只能通过接口名调用静态方法
    }
}

// JDK9+ 接口（需 Java 9 及以上版本）
interface PrivateInstanceMethodInterface {
    // 默认方法（调用私有实例方法）
    default void defaultMethod() {
        System.out.println("默认方法逻辑");
        privateMethod(); // 调用私有实例方法
    }

    // 私有实例方法（JDK9 特性）
    private void privateMethod() {
        System.out.println("这是接口中的私有实例方法");
    }
}

// 实现类
class PrivateInstanceMethodImpl implements PrivateInstanceMethodInterface {
    // 无需实现私有方法，它们对实现类不可见
}

// 测试类
public class PrivateInstanceMethodDemo {
    public static void main(String[] args) {
        PrivateInstanceMethodImpl obj = new PrivateInstanceMethodImpl();
        obj.defaultMethod(); // 调用默认方法（间接调用私有方法）
    }
}

// JDK9+ 接口
interface PrivateStaticMethodInterface {
    // 默认方法（调用私有静态方法）
    default void defaultMethod() {
        System.out.println("默认方法逻辑");
        privateStaticMethod(); // 调用私有静态方法
    }

    // 静态方法（调用私有静态方法）
    static void staticMethod() {
        System.out.println("静态方法逻辑");
        privateStaticMethod(); // 静态方法只能调用静态私有方法
    }

    // 私有静态方法（JDK9 特性）
    private static void privateStaticMethod() {
        System.out.println("这是接口中的私有静态方法");
    }
}

// 实现类
class PrivateStaticMethodImpl implements PrivateStaticMethodInterface {
    // 无需实现私有方法
}

// 测试类
public class PrivateStaticMethodDemo {
    public static void main(String[] args) {
        PrivateStaticMethodImpl obj = new PrivateStaticMethodImpl();
        obj.defaultMethod();                  // 调用默认方法
        PrivateStaticMethodInterface.staticMethod(); // 调用静态方法
    }
}

public class Car{
    String carName;
    int carAge;
    int carColor;
    String engineName;
    int engineAge;
}

public class Car{//外部类
    String carName;
    int carAge;
    int carColor;
    clss Engine{//内部类
        String engineName;
        int engineAge;
    }
}

package demo03;

public class Car {
    String name;
    String color;
    int age;
    public void show() {
        System.out.println(this.name);
        Engine engine = new Engine();
        System.out.println(engine.engineType);
    }
    class Engine{
        String engineType;
        int engineYears;

        public void show(){
            System.out.println("发动机型号："+engineType);//可以访问外部类的属性
            System.out.println("车的名称"+name);//可以访问外部类的私有属性,加上private后，内部类也可以访问
        }
    }

}

package demo03;

public class test {
    public static void main(String[] args) {
        Car car = new Car();
        car.name = "奔驰";
        car.color = "黑色";
        car.age = 1;

        car.show();
    }
}

public class Car{//外部类
    String carName;
    int carAge;
    int carColor;
    clss Engine{//成员内部类
        String engineName;
        int engineAge;
    }
}

public class BodyAndOrgans {
    public static void main(String[] args) {
        // 创建一个人的身体
        Body person = new Body("张三");
        
        // 通过身体获取心脏（方式一）
        Body.Heart heart = person.getHeart();
        heart.pumpBlood();
        
        // 直接创建肺（方式二）
        Body.Lung leftLung = person.new Lung("左肺");
        leftLung.breathe();
        
        // 身体运动，间接调用内部类方法
        person.exercise();
    }
}

class Body {
    private String name;
    private int oxygenLevel = 100; // 氧气水平 - 私有变量
    
    public Body(String name) {
        this.name = name;
        System.out.println(name + "的身体已创建");
    }
    
    // 成员内部类：心脏
    public class Heart {
        public void pumpBlood() {
            System.out.println(name + "的心脏正在输送血液，使用氧气水平：" + oxygenLevel);
            // 直接访问外部类的私有变量
            oxygenLevel -= 10;
        }
    }
    
    // 成员内部类：肺
    public class Lung {
        private String position;
        
        public Lung(String position) {
            this.position = position;
        }
        
        public void breathe() {
            System.out.println(name + "的" + position + "正在呼吸，增加氧气水平");
            // 直接访问外部类的私有变量和方法
            oxygenLevel += 20;
            Body.this.checkOxygenLevel(); // 显式调用外部类方法
        }
    }
    
    // 外部类方法：运动
    public void exercise() {
        System.out.println(name + "开始运动...");
        Heart heart = new Heart(); // 内部类可以在外部类方法中直接创建
        heart.pumpBlood();
        
        Lung rightLung = new Lung("右肺");
        rightLung.breathe();
    }
    
    // 外部类私有方法：检查氧气水平
    private void checkOxygenLevel() {
        System.out.println("当前氧气水平：" + oxygenLevel);
    }
    
    // 对外提供心脏对象（方式一）
    public Heart getHeart() {
        return new Heart();
    }
}    

public class Car {//外部类
   String carName;
   int carAge;
   int carColor;
   static class Engine {//静态内部类
       String engineName;
       int engineAge;
   }
}

public class StaticInnerClassDemo {
    public static void main(String[] args) {
        // 创建静态内部类对象（无需先创建外部类对象）
        OuterClass.InnerClass inner = new OuterClass.InnerClass();
        
        // 调用内部类方法
        inner.printOuterStaticField();  // 访问外部类静态变量
        inner.accessOuterNonStaticField();  // 通过创建外部类对象访问非静态成员
        
        // 调用静态内部类的静态方法
        OuterClass.InnerClass.printMessage();
    }
}

class OuterClass {
    // 外部类的静态变量
    public static String staticField = "外部类静态字段";
    
    // 外部类的非静态变量
    private String nonStaticField = "外部类非静态字段";
    
    // 外部类的静态方法
    public static void staticMethod() {
        System.out.println("外部类静态方法被调用");
    }
    
    // 外部类的非静态方法
    private void nonStaticMethod() {
        System.out.println("外部类非静态方法被调用");
    }
    
    // 静态内部类（属于成员内部类的一种）
    static class InnerClass {
        // 静态内部类的静态变量
        public static String innerStaticField = "内部类静态字段";
        
        // 静态内部类的非静态变量
        private int innerNonStaticField = 100;
        
        // 访问外部类静态成员
        public void printOuterStaticField() {
            System.out.println("访问外部类静态字段: " + staticField);
            staticMethod();
        }
        
        // 访问外部类非静态成员（需先创建外部类对象）
        public void accessOuterNonStaticField() {
            OuterClass outer = new OuterClass();
            System.out.println("通过对象访问外部类非静态字段: " + outer.nonStaticField);
            outer.nonStaticMethod();
        }
        
        // 静态内部类的静态方法
        public static void printMessage() {
            System.out.println("静态内部类的静态方法被调用");
            System.out.println("访问内部静态字段: " + innerStaticField);
            System.out.println("访问外部静态字段: " + staticField);
            staticMethod();
        }
    }
}    

public class StaticInnerClassDemo {
    public static void main(String[] args) {
        // 创建静态内部类对象（无需先创建外部类对象）
        OuterClass.InnerClass inner = new OuterClass.InnerClass();
        
        // 调用内部类方法
        inner.printOuterStaticField();  // 访问外部类静态变量
        inner.accessOuterNonStaticField();  // 通过创建外部类对象访问非静态成员
        
        // 调用静态内部类的静态方法
        OuterClass.InnerClass.printMessage();
    }
}

class OuterClass {
    // 外部类的静态变量
    public static String staticField = "外部类静态字段";
    
    // 外部类的非静态变量
    private String nonStaticField = "外部类非静态字段";
    
    // 外部类的静态方法
    public static void staticMethod() {
        System.out.println("外部类静态方法被调用");
    }
    
    // 外部类的非静态方法
    private void nonStaticMethod() {
        System.out.println("外部类非静态方法被调用");
    }
    
    // 静态内部类（属于成员内部类的一种）
    static class InnerClass {
        // 静态内部类的静态变量
        public static String innerStaticField = "内部类静态字段";
        
        // 静态内部类的非静态变量
        private int innerNonStaticField = 100;
        
        // 访问外部类静态成员
        public void printOuterStaticField() {
            System.out.println("访问外部类静态字段: " + staticField);
            staticMethod();
        }
        
        // 访问外部类非静态成员（需先创建外部类对象）
        public void accessOuterNonStaticField() {
            OuterClass outer = new OuterClass();
            System.out.println("通过对象访问外部类非静态字段: " + outer.nonStaticField);
            outer.nonStaticMethod();
        }
        
        // 静态内部类的静态方法
        public static void printMessage() {
            System.out.println("静态内部类的静态方法被调用");
            System.out.println("访问内部静态字段: " + innerStaticField);
            System.out.println("访问外部静态字段: " + staticField);
            staticMethod();
        }
    }
}    

格式：
    new 类名或者接口名（）{
        重写方法;
    }

package demo04;

public interface swim {
    public abstract void swim();
}

package demo04;

public class test {
    public static void main(String[] args) {
        new swim() {
            @Override
            public void swim() {
                System.out.println("重写了游泳的方法");
            }
        };
    }
}

创建静态内部类对象的格式：`外部类.内部类名 对象名 = new 外部类名.内部类名（）；`

调用非静态方法的格式：先创建对象，用对象调用

调用静态方法的格式：`外部类名.内部类名.方法名（）；`

注意事项：

1.静态内部类也是成员内部类中的一种

2.静态内部类只能访问外部类中的静态变量和静态方法 ，如果想要访问非静态的需要创建对象。

创建静态内部类对象的格式：

`外部类名.内部类名 对象名 = new 外部类名.内部类名(); `

调用静态方法的格式：

`外部类名.内部类名.方法名();`

```java
public class StaticInnerClassDemo {
    public static void main(String[] args) {
        // 创建静态内部类对象（无需先创建外部类对象）
        OuterClass.InnerClass inner = new OuterClass.InnerClass();
        
        // 调用内部类方法
        inner.printOuterStaticField();  // 访问外部类静态变量
        inner.accessOuterNonStaticField();  // 通过创建外部类对象访问非静态成员
        
        // 调用静态内部类的静态方法
        OuterClass.InnerClass.printMessage();
    }
}

class OuterClass {
    // 外部类的静态变量
    public static String staticField = "外部类静态字段";
    
    // 外部类的非静态变量
    private String nonStaticField = "外部类非静态字段";
    
    // 外部类的静态方法
    public static void staticMethod() {
        System.out.println("外部类静态方法被调用");
    }
    
    // 外部类的非静态方法
    private void nonStaticMethod() {
        System.out.println("外部类非静态方法被调用");
    }
    
    // 静态内部类（属于成员内部类的一种）
    static class InnerClass {
        // 静态内部类的静态变量
        public static String innerStaticField = "内部类静态字段";
        
        // 静态内部类的非静态变量
        private int innerNonStaticField = 100;
        
        // 访问外部类静态成员
        public void printOuterStaticField() {
            System.out.println("访问外部类静态字段: " + staticField);
            staticMethod();
        }
        
        // 访问外部类非静态成员（需先创建外部类对象）
        public void accessOuterNonStaticField() {
            OuterClass outer = new OuterClass();
            System.out.println("通过对象访问外部类非静态字段: " + outer.nonStaticField);
            outer.nonStaticMethod();
        }
        
        // 静态内部类的静态方法
        public static void printMessage() {
            System.out.println("静态内部类的静态方法被调用");
            System.out.println("访问内部静态字段: " + innerStaticField);
            System.out.println("访问外部静态字段: " + staticField);
            staticMethod();
        }
    }
}    

public class StaticInnerClassDemo {
    public static void main(String[] args) {
        // 创建静态内部类对象（无需先创建外部类对象）
        OuterClass.InnerClass inner = new OuterClass.InnerClass();
        
        // 调用内部类方法
        inner.printOuterStaticField();  // 访问外部类静态变量
        inner.accessOuterNonStaticField();  // 通过创建外部类对象访问非静态成员
        
        // 调用静态内部类的静态方法
        OuterClass.InnerClass.printMessage();
    }
}

class OuterClass {
    // 外部类的静态变量
    public static String staticField = "外部类静态字段";
    
    // 外部类的非静态变量
    private String nonStaticField = "外部类非静态字段";
    
    // 外部类的静态方法
    public static void staticMethod() {
        System.out.println("外部类静态方法被调用");
    }
    
    // 外部类的非静态方法
    private void nonStaticMethod() {
        System.out.println("外部类非静态方法被调用");
    }
    
    // 静态内部类（属于成员内部类的一种）
    static class InnerClass {
        // 静态内部类的静态变量
        public static String innerStaticField = "内部类静态字段";
        
        // 静态内部类的非静态变量
        private int innerNonStaticField = 100;
        
        // 访问外部类静态成员
        public void printOuterStaticField() {
            System.out.println("访问外部类静态字段: " + staticField);
            staticMethod();
        }
        
        // 访问外部类非静态成员（需先创建外部类对象）
        public void accessOuterNonStaticField() {
            OuterClass outer = new OuterClass();
            System.out.println("通过对象访问外部类非静态字段: " + outer.nonStaticField);
            outer.nonStaticMethod();
        }
        
        // 静态内部类的静态方法
        public static void printMessage() {
            System.out.println("静态内部类的静态方法被调用");
            System.out.println("访问内部静态字段: " + innerStaticField);
            System.out.println("访问外部静态字段: " + staticField);
            staticMethod();
        }
    }
}    

格式：
    new 类名或者接口名（）{
        重写方法;
    }

package demo04;

public interface swim {
    public abstract void swim();
}

package demo04;

public class test {
    public static void main(String[] args) {
        new swim() {
            @Override
            public void swim() {
                System.out.println("重写了游泳的方法");
            }
        };
    }
}