class People{ /* 这就是一个类 用class关键字 类名{
　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　　　　　类体　　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　　　}   来定义一个类
　　　　　　　　*/
}

class People{

　　String name；

　　char sex；

　　int age；


　　// 这里就直接用main主入口进行测试————这个入口就是为了告诉计算机从哪个地方开始执行程序（语句是死的）
　　public static void main（ String[] args ）{

　　　　People person = new People（）；// 创建一个People类的具体执行者（对象）

　　　　person.name = "苍井空";　　　　// 通过 对象.属性名 调用类中的属性

　　　　　　　　　　　　　　　　　　　　　// 当然对于类中的方法的调用也是这么回事儿，即：对象.方法名（）

　　　　person.sex = '女';
　　　　person.age = 18;
　　　　System.out.println( person.name + "性别:" + person.sex + ",今年" + person.age +"岁" ); // + 就是拼接的意思


　　}

}

class Person{

　　String name;　
　　char sex；

　　int sge；// 在这里虽然不严谨，但是意思没变，只是严格来讲需要做一点调整（等到修饰符、还有封装思想会了就知道了），主要是为了理解这个意思


}

class People{

　　String name = "邪公子";
　　String address = "在地球上"；


　　public void eat（）{　　// 这就是一个无参无返回值方法 public是一个权限修饰符 暂时死记这么写就行

　　　　　　　　　　　　　　　//　void 是返回值类型，这是无返回值，eat（）的（）里面就是参数列表........

　　　　System.out.println( "吃了一碗大米饭" );

　　}

　　
　　public static void main( String[] args ){　　// 测试一下


　　　　People person = new People();
　　　　System.out.println( person.eat() );

　　}

}

class Refund{
　　
　　public double money(){

　　　　double price = 11.3;　　　　　　　　　　  // 假如买的这个东西价格为11.3元
　　　　double payMoney = 20.5;　　　　　　　　 // 我支付给店家20.5元

　　　　double refund = payMoney - price;　// 则老板需要给我的钱为refund

　　　　return refund;　　　　　　　　　　　// 这就是老板需要找回我的钱

　　}

　　public static void main( String[] args ){

　　　　System.out.println( "老板需要找回我多少钱：" );
　　　　Refund myMoney = new Refund();
　　　　System.out.println ( myMoney.money() );

　　}

}

class  Cat{

　　public void eatFish（ String name ）{

　　　　System.out.println( name + "猫咪偷吃了鱼" ）;

　　}

　　public static void main( String[] args ){

　　　　Cat smallCat = new Cat();
　　　　System.out.println( smallCat.eatFish( "二郎神" ) );

　　}

}

class BuyDrink{
　　
　　public String drink（ int money ）{

　　　　if( money > 5 ）{

　　　　　　return "红牛"；


　　　　}else{

　　　　　　return "矿泉水";

　　　　}

　　}

　　
　　public static void main( String[] args ){

　　　　BuyDrink buyDrink = new BuyDrink();
　　　　System.out.println( buyDrink.drink( 10 ) );

　　}

}

package cn.xieGongZi.OOPStudy.packingArray;

import java.util.Arrays;

/**
 *  自己封装一种容器————这个容器拥有：1、自动扩容；2、这个容器提供对存储的元素进行增删查改功能

 *  本例子中用这个容器存储的是int类型举例
 */
public class ArrayBox {

    // 给一个数组的初始大小
    private static int[] array = new int[10];  // private是权限修饰符，static是特征修饰符，后续马上就可以接触到了，不懂也没事，甚至不加这两个也可以


    static int index = 0; // 保证这个计数器全局唯一，不加static也行

    // 功能一：自动扩容功能————就是一个方法(在基础篇中已经弄过了，只是到了这里设计成一个方法了而已
    // 1、考虑传什么条件进去（参数）————你个龟儿得把你原来的数组给我涩，不然我帮谁扩容？
    // 2、考虑返回值是什么————得把扩容之后的数组返回去啊
    public int[] grow( int[] array ) {

        // 扩容二绝技
        // 1、数据拷贝————需要一个新数组（当然直接通过传进来的这个数组也可以操作，只是为了好理解，熟练了就可以直接用当前传进来的数组
        int[] newArray;
        if (index == array.length) {

            newArray = new int[array.length * 2];

            for (int i = 0; i < array.length; i++) {

                newArray[i] = array[i];

            }

            // 2、把数据拷贝并扩容的数组的地址 指回 原数组
            array = newArray;

        }

        // 返回扩容之后的数组
        return array;

    }


    // 功能二：增加元素功能
    // 1、考虑要传什么条件进来————老衲需要知道你要添加的是爪子东西涩
    // 2、考虑返回值是什么————就添加元素，不需要返回值嘛
    public void add( int element ){

        // 扩容————如果没满，在扩容中自然会进行判断
        grow();

        // 把元素添加进去
        array[index] = element;

        // 计数器指向下一个准备添加元素的位置
        index ++;

    }

    // 功能三：删除元素功能
    // 1、考虑传什么条件进去————得告诉老夫要删除哪个位置的元素涩

    // 2、需要返回什么东西————只是删除指定的元素，也不需要返回什么
    public void remove( int removeIndex ){

        // 可以利用删除元素的位置 = 删除元素的后一个位置
        for (int i = removeIndex; i < index - 1; i++) {

            // 利用值覆盖
            array[removeIndex] = array[removeIndex + 1];

        }

        // 把数组的最后一个元素置0————这只是小测试，实际看到的效果不是这样的，可以做优化
        array[index] = 0;
        // 同时让计数器的值 -1，即：让其指向原来位置的上一个位置
        index -- ;
    }

    // 功能四：查询数组元素功能
    public void quary() {

        for (int i = 0; i < array.length; i++) {
            System.out.print( array[i] + " ");
        }
    }

    // 功能五：修改元素
    public void set( int setIndex,int newElement ) {

        if ( setIndex < array.length ){

            array[setIndex] = newElement;

        }
    }


    // 测试
    public static void main(String[] args) {

        ArrayBox arrayBox = new ArrayBox();

        // 扩容数组
        int[] newArray = arrayBox.grow();
        System.out.println(newArray.length);

        System.out.println();

        // 添加元素
        arrayBox.add(9);
        arrayBox.add(5);
        arrayBox.add(2);
        arrayBox.add(3);
        arrayBox.add(8);

        // 打印出来看一下
        System.out.println(Arrays.toString(newArray)); // Arrays是一个工具类，在工具类篇中会做解读，总之：Arrays.toString()方法的作用就是：
                                                      // 把newArray转成人能够看懂的字符串，不然直接输出newArray是一个地址码

        System.out.println();

        // 删除元素
        arrayBox.remove(2);
        System.out.println(Arrays.toString(newArray));
        System.out.println();

        // 查询元素
        arrayBox.quary();
        System.out.println();

        // 修改元素
        arrayBox.set(1,7);
        System.out.println(Arrays.toString(newArray));

    }
}

class OverLoadMethod{
　　
　　public void sleep（）{

　　　　System.out.println( "张三是可以睡觉的" );

　　}

　　public void sleep( String name ){ // 形参name 
　　　　　　　　　　　　　　　　　　　　　　// 形参：就是没有值的参数，这个方法执行完之后，这个形参就没了（不是本身没了，是调用时产生的空间没了）
　　　　System.out.println( name + "也可以睡觉" );

　　}

　　public void sleep( String name,double time ){

　　　　System.out.println( name + "睡了" + time + "小时");

　　}

　　public void sleep( double time ）{

　　　　System.out.println( "李白是不是睡过头了？" );

　　　　if( time > 8 ){

　　　　　　return "true" ;

　　　　}else{

　　　　　　return "false" ;

　　　　}

　　}


　　public static void main( String[] args ){

　　　　OverLoadMethod invokeSleep = new OverLoadMethod();
　　　　
　　　　invokeSleep.sleep();

　　　　invokeSleep.sleep( "邪公子" ); // “邪公子” 就是实参，调用这个方法的时候，把"邪公子"这个值传给了形参

　　　　invokeSleep.sleep( "山口香子",7.5 );

　　　　// ...........后续的不写了

　　}

}

class NewPlayMethod{

　　public void test( int...x ){

　　　　System.out.println("这是一个动态参数列表测试");

　　}

　　public static void main( String[] args ){

　　　　NewPlayMethod p = new NewPlayMethod();
　　　　p.test();　　　　　　/*
　　　　p.test(1);　　　　　　这三种传参都可以
　　　　p.test( 1,2,3,4 );　　*/

　　}

}

class Test{

　　String thisName;

　　public test(){}　　// 这是无参构造

　　public test（ String name ）{ // 这个是有参构造


　　　　thisName = name;

　　}
}

class Test{

    {

        System.out.println( "这就是一个普通快" );

    }

    static {

        System.out.println( "这是一个静态块" );

    }
　　
}

class Demo{

　　public static void main( String[] args ){
　　　　
　　　　Test test = new Test(); // 可以提前玩一下，然后琢磨琢磨，在这里直接运行程序，会输出什么结果？为什么结果是那样的？
　　}
}

public class Test{
　　
　　String name;

　　public void play(){

　　　　System.out.println( "玩个毛线" );

　　}

　　// 玩一下 在当前类的一个构造中 调用 另一个构造


　　public test(){

　　　　System.out.println( "这是我自己定义的无参构造“ ）；

　　}

　　public test( String name ){

　　　　this();　　// 在这里我调用本类中的无参构造————也就是：后续要是创建本类的有参对象，进入到这里时会先去调用无参构造的执行语句
　　　　System.out.println( name + "调用了有参构造" );

　　}


　　

　　public static void main( String[] args ){

　　　　System.out.println（ this.name );
　　　　System.out.println( this.play() );


　　　　Test demo = new Test( "邪公子" );

　　}

}

public class Animal{
　　　　
　　String name;
　　String age;

　　public void eat(){

　　　　System.out.println( “动物可以吃饭" );

　　}
}

public class Person extend Animal{

　　　// 在这个类里面，就具有了Animal类的所有属性和方法，只需要new一个person类的对象，就可以进行调用

}

public class Person extend Animal{

　　　// 在这个类里面，就具有了Animal类的所有属性和方法，只需要new一个person类的对象，就可以进行调用

　　// 人类还可以学习啊、可以说话啊
　　public void study(){

　　　　System.out.println( "人类还可以学习" );

　　}

　　public void talk(){

　　　　System.out.println( “人类还可以说话" ）；

　　}


　　public static void main（ String[] args ）{

　　　　Person p = new Person();

　　　　p.name = "印度阿三";  　　// 以下这几种，子类Person都具有

　　　　p.age = 100;
　　　　p.eat();　　　　　　　　　/*  怎么确定通过对象 调用的是方法还是属性？
　　　　p.study();　　　　　　　　　　　　　　　调用的是属性的话，只有属性名，没有（）这个括号
　　　　　　　　　　　　　　　　　　　　　　　　　调用的是方法的话，有方法名和()这个括号
　　　　p.talk();　　　　　　　　*/

　　}

}

public class Animal{

　　public void sleep(){

　　　　System.out.println( "这是动物的睡觉方法" );

　　}

　　public void eat( String name ){

　　　　System.out.println( name + "吃了一堆翔”）；

　　}

}

public class Person extends Animal{

　　pubilc void sleep(){

　　　　System.out.println( "这是人类的睡觉方法" ）;

　　}

　　public void eat（ String name，double time ){

　　　　System.out.println( name + "吃了“ + time "小时的大米饭" ）；

　　}

}

public class Animal{

}

class Person extends Animal(

　　public static void main( String[] args ){

　　　　Person p = new Person();
　　　　
　　　　// 若：在这里利用对象调用（ p. )，可以调到方法吗？
　　　　// 是可以的，可以调到Object类中的方法————因为Animal类默认继承了Object类，
　　　　// 而Person类又继承了Animal类，所以Person类也继承了Object类————这也是多继承的一种实现方式（继承的传递）

　　}

)

class Demo1{

　　//这里面有很多很多方法

}

class Demo2{

　　private Demo1 instance = new Demo1(); 　　// Demo1这个类的对象不就包含进Demo2类中来了吗

　　　　　　　　　　　　　　　　　　　　　　　　　　// private是权限修饰符，后续会做说明

　　// ........

}

public final class Test{

}

class Test{

　　public static void main( String[] args ){

　　　　private final int age；　　// 当然在这里直接赋值更可以


　　　　age = 18;

　　}

}

class Test{

　　public static void main( String[] args ){
　　　　
　　　　public final void demo(){

　　　　　　System.out.println( "你打我啊" );

　　　　}

　　}

}

package case8;

/**
 * 面试题： 对象创建 各初始化模块执行的先后顺序

 */
public class Demo {

    public static void main( String[] args ) {
        Son son = new Son(); // 问：输出结果为多少？
    }

}

// 爷爷类
class YeYe{
    {
        System.out.println( "爷爷动态代码块" );
    }
    static {
        System.out.println( "爷爷静态代码块" );
    }

    public YeYe() {
        System.out.println( "爷爷构造器" );
    }
}
// 父类
class Father extends YeYe{

    {
        System.out.println( "父类动态代码块" );
    }
    static {
        System.out.println( "父类静态代码块" );
    }

    public Father() {
        System.out.println( "父类构造器" );
    }
}

// 子类
class Son extends Father{

    {
        System.out.println( "Son动态代码块" );
    }
    static {
        System.out.println( "Son静态代码块" );
    }

    public Son() {
        System.out.println( "Son构造器" );
    }
}

public abstract class Demo{  // 修饰类本身 ———— 即：抽象类


　　public abstract void test();  // 修饰方法 ———— 即：抽象方法

　　// 注意：抽象方法 和 用native修饰的方法不一样，二者在表面上看起来很像 ———— 但是执行过程那是两码事：就像看起来清纯的人私底下可能整得有点多

　　// 举个例子：就像在基础篇中提到的数组扩容的第二种方式，它在底层中是这样的

　　public static native void arraycopy( Object src,  int  srcPos,Object dest, int destPos,int length );

}

abstract class Test1{

　　public abstract void sleep();

}

abstract class Test2 extends Test1{

　　public abstract void study();

}

//以上这样操作是可行的

abstract class Test3{

　　public abstract void eat();

}

public class Test4 extends Test3{

　　public void eat（）{
　　　　System.out.println( "天王盖地虎" );

　　}

}

interface Demo{　　// 这就是声明了一个接口


}

interface Demo{

　　public static fianl String NAME= "邪公子"; // 这样定义就是对的 另：public static final不写也行，默认也是这个（ 开发也不会写 ）

                　　　　　　　　　　　　　　　　　// 同时注意静态常量的命名规范 ———— 是全大写的英文单词 通过 _ 做解释

　　// 一般都是这么写的
　　String SPEAK= "这种写法才是正常开发写法“;　　// 这个写法有些人也叫“特殊接口 ———— 即：常量接口（ 全是常量 ）” ———— 这个在开发中很有用，为什么？
　　　　　　　　　　　　　　　　　　　　　　　　　　// 假如：需要做判断，那个值输入的是常量又是字符串的时候，那么为了以防万一别人手贱多打了一个空格

　　　　　　　　　　　　　　　　　　　　　　　　　　// 或者：那人手残输错了一个字母，那就可以用到这个知识点预防了

}

interface Demo{

　　public abstract void eat(); // 这样定义就是对的，另：public abstract这个不要也行，默认也是这个（开发中也是没写这两个修饰符）

　　// 一般都是这么写的
　　void sleep();

}

interface Demo1{ // 定义一个接口

　　void eat();

}

class Demo2 implements Demo1{ // 实现接口，这里只是实现了一个，实现多个接口的话，直接在implements后面接上需要实现的其他接口就行，多个用 , 隔开
　　　　　　　　　　　　　　　　　　// 如：implements Demo1，Demo2，Demo3
　　
　　// 重写接口中的方法（ 具体化 ）
　　public void eat(){

　　　　System.out.println( "你吃了个西北风" );

　　}

}

interface A{
    void a();
}

interface B{
    void b();
}

interface C extends B,A {
    void c();
}

class X implements C { // 这里X就实现了C一个类，但重写了3个抽象方法之后，X类就有3个自己的方法了,同时得出答案：是支持多继承的( 因为C继承了A、B )。

 　　　　　　　　　　　　　// 另外：@Override是重写的意思，这是注解，暂时先不管
    @Override
    public void a() {
        
    }
    @Override
    public void b() {

    }
    @Override
    public void c() {
    }
}

package cn.xieGongZi.OOPStudy.InterfaceStudy.InterfaceExtend;

// 常量接口
// 车的品牌
interface Brand{

    // 静态常量 ———— 要是有另外品牌的车，则直接在这里面加入相应的内容，最后去后面Shop类中加入相应的if语句就可以了
    String BRAND_HAVEL = "havel";
    String BRAND_BYD = "byd";
    String BRAND_CHANGAN = "changAn";

}

// 车类
abstract class Car {

    private String name;

    public abstract void run();

    public Car() {
    }

    public Car( String name ) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

package cn.xieGongZi.OOPStudy.InterfaceStudy.InterfaceExtend;

// 车类的实现类
// 比亚迪车
public class Byd extends Car{

    public Byd( String name ) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println( this.getName() + "行驶了");
    }
}

// 哈佛车
class Havel extends Car{

    public Havel( String name ) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println( this.getName() + "行驶了" );
    }
}

// 长安车
class ChangAn extends Car{

    public ChangAn( String name ) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println( this.getName() + "行驶了" );
    }
}


// 销售车的类
class Shop{

    public static Car salesCar( String name ){

        if ( name.equals( Brand.BRAND_BYD ) ){ // 使用静态常量，原因：要是使用字符串的话，万一手贱多打了一个空格，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　// 或者直接多打了一个符号，那比较结果不就不同了吗，所以直接使用“静态常量”不是很保险吗
                                                                     // 这也就是常量接口的好处

            return new Byd("比亚迪-汉");

        }

        if ( name.equals( Brand.BRAND_HAVEL ) ){

            return new Havel("哈佛-h6");

        }

        if ( name.equals( Brand.BRAND_CHANGAN ) ){

            return new ChangAn("长安-乱扯一个");

        }

        return null;
    }
}

// 测试类
class Test{

    public static void main( String[] args ) {

        Car car = Shop.salesCar( Brand.BRAND_BYD );
        car.run();

        Car car2 = Shop.salesCar( Brand.BRAND_HAVEL );
        car2.run();

        Car car3 = Shop.salesCar( Brand.BRAND_CHANGAN );
        car3.run();
    }
}

interface Demo{

　　void eat();

}

interface Demo1{

　　void sleep();

}

interface Demo2 extends Demo,Demo1{  // 在接口中这种是可以得吃的

　　// 另外要写的代码


}

// 父类
package cn.xieGongZi.test;

public class Animal {

    private String name ;
    private String sex;

　　 public Animal(){}

　　 public Animal( String name,String sex ){

　　　　this.name = name;
　　　　this.sex = sex;
　　 }

    public void eat() {
        System.out.println("动物的吃饭方法");
    }

    public void sleep() {
        System.out.println("动物的睡觉方法");
    }
}


// 子类
package cn.xieGongZi.test;

public class Person extends Animal{

　　 public Person{
　　 }
　　
    public void talk() {
        System.out.println("人类的说话能力");
    }

    public void study() {
        System.out.println("人类的学习能力");
    }
}



// 测试类

package cn.xieGongZi.test;

class Test{

    public static void main( String[] args ) {
        Animal animal = new Person();

        // 在这里我想要通过这个animal对象引用 去 调用Person类中的特有方法

       //     但是：在这里只能调用Animal类中的方法、属性( 需要父类提供get和【 set方法 】 ———— 重点为了表达这个知识，所以省掉了
      // 　　  在IDEA编辑器中可以通过alt+insert键选择getter和setter之后全选，然后生成 ）


    // 因此可以通过向下转型（ 向下转型 是因为Animal是父类，Person是子类，所以父 ———— > 子 ，就是向下转，其他的几个名字意思也是这么个逻辑
        if ( animal instanceof Person ) {

            Person person = (Person)animal;
            person.study();
            person.talk();
　　　　　　　person.eat();　　// 余下这两个都可以调到
　　　　　　　person.sleep()

        }
    }
}

// 主人
public class Master { // 假设还有Animal动物类，然后Dog和Cat继承了Animal

    /* 

　　　　这两个方法重载，可以使用多态优化为一个方法
    // 接收一个 Dog 类型的参数

    public void  feed( Dog obj  ){
        obj.eat();
    }

    // 接收一个 Cat 类型的参数

    public void  feed( Cat obj  ){
        obj.eat();
    }

    */


　　　// 优化
    // 接收一个 Animal 类型的参数
    public void  feed( Animal obj  ){ // Animal obj = cat = new Cat(); Dog是同样的道理
        obj.eat();
    }

    public static void main( String[] args ) {

        Dog dog = new Dog();
        Cat cat = new Cat();
        Master master = new Master();
        master.feed(  cat  ); // 这里可以传  cat 和  dog对象 均可。
    }

}

// 主人
public class Master {

    // 接收一个 Animal 类型的参数
    public void  feed( Animal obj  ){
        obj.eat();
    }

    // 返回值为父类类型
    public  Animal  kill(){

        Random random = new Random(); // 这是生成一个随机数，Math工具类中的方法，在工具类中会说明
        int num = random.nextInt(2);

        if( num == 0 ){ // 杀个狗
            Dog dog = new Dog();
            return dog;　　// 这种返回回去Animal是父类，也接收得了


        }else{ // 杀个猫
            Cat cat = new Cat();
            return cat;　　// 同样的Animal照样可以接收
        }
    }
  
}

    public static void main(String[] args) {

        Animal[] arr = new Animal[4];


        arr[0] = new Cat();
        arr[1] = new Dog();
        arr[2] = new Cat();
        arr[3] = new Dog();

        for( Animal an : arr){
            an.eat();
        }
    }

package cn.xieGongZi.OOPStudy.InterfaceStudy.flagInterface;

// 创建一个能飞的接口————用来给别人做标记的
public interface CanFly {

}


package cn.xieGongZi.OOPStudy.InterfaceStudy.flagInterface;

// 鸟儿类，标志一下，它可以飞（即：实现CanFly接口）
public class Bird implements CanFly{

    public void birdFly() {
        System.out.println("小鸟儿飞.....");
    }
}



package cn.xieGongZi.OOPStudy.InterfaceStudy.flagInterface;

// 飞机类，也标志一下，也可以飞
public class Plane implements CanFly{

    public void planeFly(){
        System.out.println("飞机飞.....");
    }
}



package cn.xieGongZi.OOPStudy.InterfaceStudy.flagInterface;

// 猪类，这玩意儿能飞？————能飞的猪是啥子猪————飞猪？
public class Pig {

    public void eat() {
        System.out.println("一天就知道吃吃吃....");
    }
}

// 测试类
class Test{

    public void fly( Object obj ){　　// 这里采用Object类只是为了能够让什么类型对象都可以传进来，测试嘛

        if ( obj instanceof CanFly ){  // 这里标志接口的好处不就来了吗，在这里就可以用这个标志来判断了涩 ———— 这里涉及到了多态的思想

            System.out.println( obj + "这玩意儿可以飞" );

        }else {

            throw new RuntimeException("这玩意儿尼玛不能飞啊"); // 这个是自定义异常，暂时先不考虑，后续在java高级篇中会做详细说明
        }
    }


    public static void main(String[] args) {

        Test test = new Test();
//        test.fly( new Bird() );
//        test.fly( new Plane() );     // 这两个玩意儿都可以，但是重点不在这里，注意：这里传的对象是子类对象，多态隐式玩法

        test.fly( new Pig() );  // 在这里我new一个Bird、Plane都可以飞，但是Pig这玩意儿也可以传到fly()方法里面去

　　　　　　　　　　　　　　　　　　　// 所以如果不用标志接口整一下,表明哪些东西是可以飞的，那不得啥玩意儿都可以进去执行了
    }
}

package cn.xieGongZi.OOPStudy.studyClass.InnerClassStudy;

public class Persion {

    private String name = "魔族";
    private int age = 30000;

    public void eat() {

        System.out.println( "这是人类的吃饭方法" );

    }

    class Teacher {

        private String sex = "女";
        private String phone = "123456";

        public void sleep() {

            System.out.println( "这是老师的睡觉方法" );
            eat();
            System.out.println( "这里调用了外部类的name属性：" + name );
            System.out.println( "这里调用了外部类的age属性: " + age );

        }

    }

    public static void main( String[] args ) {

        System.out.println( "这是外部类的调用" );
        Persion p = new Persion();
        System.out.println( p.age );
        System.out.println( p.name );
        p.eat();
        System.out.println();

        System.out.println("=========成员内部类的调用如下：==============");
        Teacher teacher = p.new Teacher(); // 创建内部类的对象
        System.out.println( teacher.sex );
        System.out.println( teacher.phone );
        teacher.sleep();

    }

}

package cn.xieGongZi.OOPStudy.studyClass.InnerClassStudy.part;

public class Animal {

    private String name = "动物的名字";
    private int age = 100;

    public void eat() {
 
        System.out.println( "动物的吃饭方法" );

        class Pig{

            String name = "猪的名字";

            public void sleep() {

                System.out.println(); // 换行 为了好看效果

                System.out.println( "这里面就是局部内部类的方法了：" );

                System.out.println( "猪的睡觉方式" );

                System.out.println( "这里调用了外部类的name属性： " + Animal.this.name );
                System.out.println( "这里调用了外部类的age属性: " + Animal.this.age );

            }

        }

        Pig pig = new Pig();                // 想要访问局部内部类的属性和方法
        System.out.println( pig.name );     // 直接在局部内部类所放的方法中  直接创建这个局部内部类的对象
        pig.sleep();                        // 有了这个对象就可以调用这个局部内部类的属性和方法了


    }

    public static void main( String[] args ) {

        System.out.println( "外部类的调用如下：" );
        Animal animal = new Animal();
        System.out.println( animal.name );
        System.out.println( animal.age );
        
        animal.eat(); // 这个方法中创建了局部内部类的对象 以及调用了它的属性和方法

    }

}

package cn.xieGongZi.OOPStudy.studyClass.InnerClassStudy.anonymous;

public interface Animal {

    void sleep();


    Animal animal = new Animal() {　　// 这里是为了方便，所以就直接写在这个接口里面了，这个实现类可以放在需要的地方写都可以（ 都是同样的道理 ）


        private char sex = '男';

        @Override　　// 这是注解，就是重写的意思，在注解知识中会做详细说明
        public void sleep() {

            System.out.println( "接口和抽象类的子类实现" );

        }

    };

}

class Test{

    public static void main( String[] args ) {

        Animal.animal.sleep(); // 对成员匿名内部类的调用
        
    }

}