面向对象编程基础-优快云博客

1.什么是面向对象

代码如下:

创建Cat类

package com_imooc.mianxiangduixiang;

/**
 * 创建宠物-猫的类
 */
public class Cat {
    //成员属性:昵称,年龄,体重,品种
    String name;
    int month;
    double weight;
    String species;

    //方法:吃
    public void eat() {
        System.out.println("我是一只小猫,我要吃东西");
    }

    //方法:跑
    public void run() {
        System.out.println("我会跑跑跳跳");
    }

    //方法重载:跑
    public void run(String name) {
        System.out.println(name + "快点跑,老鼠来了");
    }
}

调用Cat类,也就是实例化Cat,使它变成对象

package com_imooc.mianxiangduixiang;

public class CatTest {
    public static void main(String[] vvv){
        //实例化类
        Cat mycat=new Cat();

        mycat.eat();
        mycat.run();

        mycat.run("小花花");
    }
}

1.1 对象实例化(new 关键字)

当我们使用Cat one声明对象的时候,我们只是在栈中开辟了一个为null的对象,此时他没有任何的属性和方法,而new Cat()的时候是在堆中开辟了一个指针为0x0001的空间,他们两个通过"="来传递信息

1.2 构造方法

定义一个Cat类

package com_imooc.mianxiangduixiang;

/**
 * 创建宠物-猫的类
 */
public class Cat {
    //成员属性:昵称,年龄,体重,品种
    String name;
    int month;
    double weight;
    String species;

    //构造方法:无参数
    public Cat() {
        System.out.println("我是没有参数的构造方法");
    }

    //构造方法:有参数
    public Cat(String name, int month, double weight, String species) {
        System.out.println("我是宠物猫" + name);
        System.out.println("今年" + month + "个月");
        System.out.println("体重是" + weight + "kg");
        System.out.println("品种是:" + weight);
    }
}

实例化,并展示构造方法

package com_imooc.mianxiangduixiang;

public class CatTest {
    public static void main(String[] vvv){
        //实例化类
        Cat mycat=new Cat();

        Cat one=new Cat("大花花",12,30,"英短");
    }
}

1.3 this关键字

例子:

package com_imooc.mianxiangduixiang;

/**
 * 创建宠物-猫的类
 */
public class Cat {
    //成员属性:昵称,年龄,体重,品种
    String name;
    int month;
    double weight;
    String species;

    //构造方法:无参数
    public Cat() {
        System.out.println("我是没有参数的构造方法");
    }

    //构造方法:有参数
    public Cat(String name, int month, double weight, String species) {
        this();
        this.name = name;
        this.month = month;
        this.weight = weight;
        this.species = species;
    }

    //方法:吃
    public void eat() {
        System.out.println("我是一只小猫,我要吃东西");
    }

    //方法:跑
    public void run() {
        eat();
        System.out.println("我会跑跑跳跳");
    }

    //方法重载:跑
    public void run(String name) {
        System.out.println(name + "快点跑,老鼠来了");
    }
}

调用:

package com_imooc.mianxiangduixiang;

public class CatTest {
    public static void main(String[] vvv){
        //实例化类
        Cat one=new Cat("大花花",12,30,"英短");

        System.out.println(one.name);
        System.out.println(one.month);
        System.out.println(one.species);
        System.out.println(one.weight);
    }
}

2.封装

简单的例子:

package com_imooc.mianxiangduixiang;

public class FengzhuangCat {
    //成员属性:昵称,年龄,体重,品种
    private String name;
    private int month;
    private double weight;
    private String species;

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

    public void setMonth(int month) {
        this.month = month;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    public void getname() {
        System.out.println("我是一只name是:" + this.name + "的小猫猫");
    }

    public int getMonth() {
        return this.month;
    }

}

实例化调用

package com_imooc.mianxiangduixiang;

public class CatTest {
    public static void main(String[] vvv) {
        //实例化类
        FengzhuangCat one = new FengzhuangCat();
        //设置属性
        one.setName("花花");
        one.setMonth(88);

        one.getname();
        int month = one.getMonth();
        System.out.println("小猫猫的年龄是:"+month);
    }
}

2.1 利用包进行管理类

例如:我在一个项目中有两个Cat的类文件,如图:

最后我们调用的位置:

2.2 static关键字

static所在的方法称之为静态成员,也叫类成员,他有两个特点:

1.类对象共享;

2.类加载时产生,销毁时释放,生命的周期长;

例子:

package com_imooc.mianxiangduixiang;

public class FengzhuangCat {
    //成员属性:昵称,年龄,体重,品种
    private String name;
    private int month;
    private double weight;
    private String species;

    public static int price;

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

    public void setMonth(int month) {
        this.month = month;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    public void getname() {
        //调用静态的方法
        eat();
        System.out.println("我是一只name是:" + this.name + "的小猫猫,我的售价是:" + price);
    }

    public int getMonth() {
        return this.month;
    }

    //静态方法里面不能调用非静态的方法和变量
    public static void eat() {
        System.out.println("我的售价是" + price);
    }

    public static void run() {
        FengzhuangCat one=new FengzhuangCat();
        one.name="二黑";
        one.getname();
    }
}

调用:

package com_imooc.mianxiangduixiang;

public class CatTest {
    public static void main(String[] vvv) {
        //1.静态方法和属性的调用
        FengzhuangCat one=new FengzhuangCat();
        //调用静态方法的时候直接使用类名调用
        FengzhuangCat.price=100;
        one.setName("白白");
        one.getname();

        FengzhuangCat two=new FengzhuangCat();
        two.setName("黄黄");
        two.getname();

        //2.静态方法中调用实例化的对象
        FengzhuangCat.run();
    }
}

结果:

代码块

例如:

package com_imooc.mianxiangduixiang;

public class FengzhuangCat {
    //成员属性:昵称,年龄,体重,品种
    private String name;
    private int month;
    private double weight;
    private String species;

    public static int price;

    //构造代码块(每次实例化一次便输出一次)
    {
        System.out.println("我是构造代码块");
    }

    //静态代码块(不管实例化几次,只会输出一次)
    static {
        System.out.println("我是静态代码块");
    }

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

    public void getname() {
        //普通代码块
        {
            System.out.println("我是普通的代码块");
        }
        System.out.println("我是一只name是:" + this.name + "的小猫猫,我的售价是:" + price);
    }

}

实例化:

package com_imooc.mianxiangduixiang;

public class CatTest {
    public static void main(String[] vvv) {
        FengzhuangCat one=new FengzhuangCat();
        //调用静态方法的时候直接使用类名调用
        FengzhuangCat.price=100;
        one.setName("白白");
        one.getname();
    }
}

结果:

2.3 综合案例

Student.java(学生类)

package com_imooc.mianxiangduixiang.fenzhuangtest;

public class Student {

    //属性:学号,姓名,性别,年龄
    private String name;
    private int no;
    private int year;
    private String sex;
    //把类作为一个属性
    private Tie mytie;

    //没有参数新new一个,防止报错
    public Tie getMytie() {
        if (this.mytie == null) {
            this.mytie = new Tie();
        }
        return mytie;
    }

    public void setMytie(Tie mytie) {
        this.mytie = mytie;
    }


    public Student() {
    }

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

    //构造方法
    public Student(String name, int no, int year, String sex, Tie mytie) {
        this.name = name;
        this.no = no;
        this.year = year;
        this.sex = sex;
        this.mytie = mytie;
    }

    public String toString() {
        return "学生信息如下:" +
                "名字:'" + name + '\'' +
                ", 学号:" + no +
                ", 年纪:" + year +
                ", 性别:'" + sex + '\'' +
                ", 专业:" + mytie.getName() + '\'' +
                ", 学制:" + mytie.getYear() + '\'' +
                ", 编号:" + mytie.getBianhao() + '\'' +
                '}';
    }

    public String toString(Tie myTie) {
        return "学生信息如下:" +
                "名字:'" + name + '\'' +
                ", 学号:" + no +
                ", 年纪:" + year +
                ", 性别:'" + sex + '\'' +
                ", 专业:" + myTie.getName() + '\'' +
                ", 学制:" + myTie.getYear() + '\'' +
                ", 编号:" + myTie.getBianhao() + '\'' +
                '}';
    }

}

Tie.java(专业类)

package com_imooc.mianxiangduixiang.fenzhuangtest;

public class Tie {
    //属性:学科名称,学科编号,学习年限,学生个数的统计
    private String name;
    private String bianhao;
    private int year;
    private int count = 0;

    public Tie() {
    }


    //构造函数
    public Tie(String name, String bianhao, int year) {
        this.name = name;
        this.bianhao = bianhao;
        this.year = year;
    }

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

    public void setBianhao(String bianhao) {
        this.bianhao = bianhao;
    }

    public void setYear(int year) {
        this.year = year;
    }

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

    public String getBianhao() {
        return this.bianhao;
    }

    public int getYear() {
        return this.year;
    }

    public String info() {
        String info = "专业名称:" + this.name + "\n编号:" + this.bianhao + "\n学习年限:" + this.year;
        return info;
    }

    public void add_student(Student stu) {
        if (stu != null) {
            count++;
        }
    }

    public int getCount() {
        return this.count;
    }

}

Main.java

package com_imooc.mianxiangduixiang.fenzhuangtest;


public class fenzhaung {
    public static void main(String[] vvv) {
        Tie one = new Tie("计算机与科学应用", "j0001", 4);
        System.out.println(one.info());

        //第一个学生(实例化的对象作为参数传递)
        Student st1 = new Student("王二狗", 123, 15, "女");
        System.out.println("*************************");
        System.out.println(st1.toString(one));

        //第二个学生(实例化的对象作为参数传递)
        Student st2 = new Student("李二炮", 124, 16, "男", one);
        System.out.println("*************************");
        System.out.println(st2.toString());

        //统计学生的个数
        System.out.println("*************************");
        one.add_student(st1);
        one.add_student(st2);
        System.out.println(one.getCount());
    }
}

3.继承

例子:

父类 animal.java

package com_imooc.mianxiangduixiang.jicheng;

public class animal {
    private String name;    //名字
    private int month;  //月份
    private String species; //品种

    public String getName() {
        return name;
    }

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

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String getSpecies() {
        return species;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    //吃东西
    public void eat() {
        System.out.println(name + "在吃东西");
    }

}

子类 cat.java

package com_imooc.mianxiangduixiang.jicheng;

public class cat extends animal {
    private double weight; //体重

    public cat() {
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public void info() {
        System.out.println(getName() + "是一只" + getSpecies() + "小猫");
    }

}

子类 dog.java

package com_imooc.mianxiangduixiang.jicheng;

public class dog extends animal {
    private String sex; //性别

    public dog() {
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    //睡觉的方法
    public void sleep() {
        System.out.println("他是一个叫" + getName() + "的小狗,他在睡觉;他已经" + getMonth() + "个月了");
    }


}

test.java

package com_imooc.mianxiangduixiang.jicheng;

public class test {
    public static void main(String[] vvv) {
        //实现猫的实例对象
        cat cc=new cat();
        cc.setName("花花");
        cc.setSpecies("英国短毛");
        cc.info();
        cc.eat();

        System.out.println("*********************************");
        //实现狗的实例对象
        dog dd=new dog();
        dd.setName("小黑");
        dd.setMonth(20);
        dd.sleep();
        dd.eat();
    }
}

3.1 方法重写

在刚才的例子中,我们的父类animal中有eat这个方法,如果子类比如dog类中也想要写一个属于自己专属的eat方法,那么这个过程叫做方法重写;

所以,我们在重写了dog类:

package com_imooc.mianxiangduixiang.jicheng;

public class dog extends animal {
    private String sex; //性别

    public dog() {
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    //睡觉的方法
    public void sleep() {
        System.out.println("他是一个叫" + getName() + "的小狗,他在睡觉;他已经" + getMonth() + "个月了");
    }

    public void eat() {
        System.out.println(getName() + "她怀孕了,孕吐中");
    }

}

最后我们只要实例化dog类,完后调用eat()方法,系统便会调用dog类中重写的方法.

结果展示:

3.2 super关键字

super代表对父类对象的引用

例如:

animal类

package com_imooc.mianxiangduixiang.jicheng;

public class animal {
    private String name;    //名字
    private int month;  //月份
    private String species; //品种

    public animal() {
        System.out.println("我是父类的构造方法");
    }

    public animal(String name) {
        System.out.println("我是父类带有参数的方法" + name);
    }

    public String getName() {
        return name;
    }

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

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String getSpecies() {
        return species;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    //吃东西
    public void eat() {
        System.out.println(name + "在吃东西");
    }

}

dog类

package com_imooc.mianxiangduixiang.jicheng;

public class dog extends animal {
    private String sex; //性别

    public dog() {
        System.out.println("我是dog的无参构造方法");
    }
    public dog(String sex,String name,int month) {
//        this();
        super(name);
        this.sex=sex;
        super.setName(name);
        super.setMonth(month);
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    //睡觉的方法
    public void sleep() {
        eat();
        System.out.println("他是一个叫" + getName() + "的小狗,他在睡觉;他已经" + getMonth() + "个月了");
    }

    public void eat() {
        System.out.println(getName() + "她怀孕了,孕吐中");
    }

}

package com_imooc.mianxiangduixiang.jicheng;

public class test {
    public static void main(String[] vvv) {
        //实现猫的实例对象
        cat cc=new cat();
        cc.setName("花花");
        cc.setSpecies("英国短毛");
        cc.info();
        cc.eat();

        System.out.println("*********************************");
        //实现狗的实例对象
        dog dd=new dog();
        dd.setName("小黑");
        dd.setMonth(20);
        dd.sleep();
        dd.eat();

        System.out.println("*********************************");
        dog ee=new dog("母","小白",500);
        ee.sleep();
    }
}

1.假如我们在dog类中使用eat()方法,得到的结果是:

说明eat()方法用的是本类(也就是dog类自己的)方法,如果说我们希望使用父类animal类的eat()方法,那么必须使用关键字super,如:

2.其次,在我们使用构造方法dog的时候,我们想通过继承使用animal的带参数构造方法

我们只需要在dog类中的构造方法中,使用super就可以,如图:

最后,我们可以看出super很像我们之前的this,这里作出了比较:

有一点需要注意的是,在dog类中的有参构造方法中,this()(代表直接调用本类中无参构造方法)和super()不能同时存在.

3.3 Object类

我们列举equals和tostring类来进行说明:

package com_imooc.mianxiangduixiang.jicheng;

public class obiect_test {
    public static void main(String[] vvv) {
        animal one = new animal();
        animal two = new animal();
        animal three = one;

        //1.equals
        //继承于object的equals,指向的指针是否相同
        boolean rel = one.equals(two);
        boolean rel1 = one.equals(three);
        System.out.println("one和two的引用比较" + rel);
        System.out.println("one和two的'=='比较" + (one == two));
        System.out.println("==============================================");

        System.out.println("one和three的引用比较" + rel1);
        System.out.println("one和three的'=='比较" + (one == three));

        System.out.println("==============================================");
        String a = new String("hello");
        String b = new String("hello");
        //方法重写后代表字符的比较
        boolean rel2 = a.equals(b);
        System.out.println("a和b的引用比较" + rel2);
        System.out.println("a和b的'=='比较" + (b == a));

        //2.tostring(输出的内容:'包的位置'@'内存指针')
        System.out.println("one的tostring方法"+one.toString());
        System.out.println("a的tostring方法"+a.toString());
    }
}

3.4 final关键字

4.多态

用一句话来概括下，多态就是同一操作（方法）作用于不同的对象时，可以有不同的解释，产生不同的执行结果。这句话看似简单，实则颇有深意。下面我们来深入理解一多态的意义及如何使用多态。

建立animal.java

package com_imooc.mianxiangduixiang.duotai;

public class animal {

    public animal() {
    }

    //吃东西
    public void eat() {
        System.out.println("动物都在吃东西");
    }

    public void run(){
        System.out.println("任何动物都会跑");
    }

}

dog.java

package com_imooc.mianxiangduixiang.duotai;

public class dog extends animal {

    public dog(){
    }

    //睡觉的方法
    public void sleep() {
        System.out.println("他是一个小狗,他在睡觉");
    }

    public void eat() {

        System.out.println("狗吃肉");
    }

}

cat.java

package com_imooc.mianxiangduixiang.duotai;

public class cat extends animal {

    public cat() {
    }

    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void paly() {
        System.out.println("猫去玩线球");
    }
}

master.java

package com_imooc.mianxiangduixiang.duotai;

public class master {
    //主人喂了猫以后,猫去玩线球
    //主人喂了狗以后,狗去睡觉觉

    public void feed(cat c){
        c.eat();
        c.paly();
    }

    public void feed(dog d){
        d.eat();
        d.sleep();
    }
}

当我们调用的时候是这样的,

但是这里有一个问题,如果以后要是想编写更多的动物,每次我们都需要在 master.java中重载feed()方法,显然这是不便捷的,当然我们可以使用类的类型转化,先解决feed()的编写问题.

此时,我们只是需要修改master.java,利用instanceof对类的判断,便可以减少了很多的代码量;

package com_imooc.mianxiangduixiang.duotai;

public class master {
    //主人喂了猫以后,猫去玩线球
    //主人喂了狗以后,狗去睡觉觉

    public void feed(animal a) {
        if (a instanceof dog) {
            dog d = (dog) a;
            d.eat();
            d.sleep();
        } else if (a instanceof cat) {
            cat c = (cat) a;
            c.eat();
            c.paly();
        }
    }
}

但是这里只是简化的我们的代码.并没有实现真正的多态,所以我们需要方法重写来实现我们类的多态;

首先,先修改animal.java

package com_imooc.mianxiangduixiang.duotai;

public class animal{

    public animal() {
    }

    //吃东西
    public void eat() {
        System.out.println("动物都在吃东西");
    }

    public void run(){
        System.out.println("任何动物都会跑");
    }

    public void info() {

    }
}

dog.java

package com_imooc.mianxiangduixiang.duotai;

public class dog extends animal {

    public dog() {
    }

    //睡觉的方法
    public void sleep() {
        System.out.println("他是一个小狗,他在睡觉");
    }

    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void info() {
        eat();
        sleep();
    }
}

cat.java

package com_imooc.mianxiangduixiang.duotai;

public class cat extends animal {

    public cat() {
    }

    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void paly() {
        System.out.println("猫去玩线球");
    }

    @Override
    public void info() {
        eat();
        paly();
    }
}

master.java

package com_imooc.mianxiangduixiang.duotai;

public class master {
    //主人喂了猫以后,猫去玩线球
    //主人喂了狗以后,狗去睡觉觉

    /**
     * 方案三,通过传入的类型,完后调用本类中info的方法
     * @param a
     */
    public void feed(animal a) {
        a.info();
    }

}

最后调用不变,我们就可以知道,只要是后期添加类中,继承animal类,并重写info()的方法,那么就轻松的实现了多态.

4.1 抽象类和抽象方法

在面向对象的概念中，所有的对象都是通过类来描述的，但并不是说所有的类都是用来描述对象的，当一个类中没有包含足够的信息以描绘一个具体的对象时，这样的类就是抽象类。

抽象类的意义在于:

（1）为其子类提供一个公共的类型（父类引用指向子类对象）；
（2）封装子类中的重复内容（成员变量和方法）;
（3）将父类设计成抽象类后，既可借由父子继承关系限制子类的设计随意性，在一定程度上避免了无意义父类的实例化。

创建抽象类 animals.java

package com_imooc.mianxiangduixiang.duotai;

//抽象类
public abstract class animals {

    //抽象方法体(在子类中,必须重写抽象类中的方法体,否则会报错)
    public abstract void info();

    public abstract void eat();

}

利用 abs_cat.java来继承animals.java

package com_imooc.mianxiangduixiang.duotai;

public class abs_cat extends animals {

    public abs_cat() {
    }

    public void paly() {
        System.out.println("猫去玩线球");
    }

    @Override
    public void info() {
        eat();
        paly();
    }

    @Override
    public void eat() {

        System.out.println("猫吃鱼");
    }
}

在上面的例子可以看出,我们的抽象类和抽象方法的写法,值得主意的是我们的子类在继承抽象类后,必须重写父类的抽象方法,从而达到了限制子类的设计随意性的目的.

4.2 接口

  我们在实际开发过程中，如果想要创建某些公共代码，使得它们可以被某个接口的所有不同实现所共用，那么接口内部的嵌套类会显得很方便。也就是说，在接口中可以含有内部类。在这里，向大家展示接口中放置普通成员内部类和抽象成员内部类的情况。

接口实现需要用到关键字interface

接口类 Inet.java

package com_imooc.mianxiangduixiang.duotai.jiekou;

public interface Inet {
    void network();
}

接口类 Iphoto.java

package com_imooc.mianxiangduixiang.duotai.jiekou;

/**
 * 具有拍照能力的接口
 */
public interface Iphoto {
    /**
     * 可以当做---接口的抽象方法
     * 接口抽象方法可以不用写abstract关键字
     * 当类要实现接口的时候,是需要实现全部的抽象方法
     */
    public void photo();

    /**
     * 接口中常量不需要在定义public static final
     */
    int price = 100;

    /**
     * 可以当作---接口的静态方法(默认方法)
     * 也可以写成: public static void guangquan(){}
     */
    public default void guangquan() {
        System.out.println("我是一个小光圈");
    }

    public static void a() {
        System.out.println("我是小a");
    }
}

调用类 camera.java

package com_imooc.mianxiangduixiang.duotai.jiekou;

/**
 * 多接口的调用
 */
public class camera implements Iphoto,Inet{

    /**
     * 调用接口中的默认方法default,需要加super
     * 但是调用接口的静态方法不需要
     */
    public void ls(){
        Iphoto.super.guangquan();
        Iphoto.a();
    }

    @Override
    public void photo() {
        System.out.println("相机也是可以拍照的");
    }

    @Override
    public void network() {
        System.out.println("相机不能上网,但是有些是可以的");
    }
}

调用类 phone.java

package com_imooc.mianxiangduixiang.duotai.jiekou;

public class phone implements Iphoto {

    public void game(){
        System.out.println("手机也可以玩游戏的");
    }

    //引入接口后,需要重写方法
    @Override
    public void photo() {
        System.out.println("手机是可以拍照的");
    }
}

main文件

package com_imooc.mianxiangduixiang.duotai.jiekou;

public class jiekou_test {
    public static void main(String[] vvv) {
        //接口可以描述不同的类,具有相似的行为特征
        phone p=new phone();
        p.photo();
        p.game();

        System.out.println("=============================");
        camera c=new camera();
        c.photo();
        c.network();

        System.out.println("=============================");
        Iphoto i=new phone();
        i.photo();
        System.out.println(i.price);
    }
}

4.3 内部类

如:

4.3.1 成员内部类

people.java

package com_imooc.mianxiangduixiang.duotai.neibulei;

//外部类
public class people {
    int age;

    public people(int age) {
        this.age = age;
    }

    public people() {
    }

    public void getinfo() {
        System.out.println("我是一个年龄为:" + age + "的老头");
    }

    //定义内部类的输出
    public heart getheart() {
        return new heart();
    }

    //成员内部类
    class heart {
        //调用外部类的参数
        public String beat() {
            return people.this.age + "心在跳动";
        }
    }
}

调用的test.java

package com_imooc.mianxiangduixiang.duotai.neibulei;

public class neibu_test {
    public static void main(String[] args) {
        people p=new people(55);
        p.getinfo();

        //1.内部类的调用
        people.heart h=new people().new heart();
        System.out.println(h.beat());

        //2.内部类的调用
        people.heart h1=p.getheart();
        System.out.println(h1.beat());
    }
}

4.3.2 静态内部类

person.java

package com_imooc.mianxiangduixiang.duotai.neibulei;

//外部类
public class person {
    int age;

    public person(int age) {
        this.age = age;
    }

    public person() {
    }

    public void getinfo() {
        System.out.println("我是一个年龄为:" + age + "的老头");
    }

    //定义内部类的输出
    public heart getheart() {
        return new heart();
    }

    //定义静态方法
    public static void eat() {
        System.out.println("人是要吃饭的");
    }

    //定义普通方法
    public void sleep() {
        System.out.println("人是要睡觉的");
    }

    //成员内部类
    static class heart {
        //调用外部类的参数
        public String beat() {
            return new person().age + "心在跳动";
        }

        //内部调用外部的静态方法
        public String eat() {
            person.eat();
            return new person().age + "心在跳动";
        }

        //内部调用外部的普通方法
        public void sleep() {
            new person().sleep();
        }

        static void info() {
            System.out.println("我是内部类的静态方法");
        }
    }
}

静态内部类的调用

package com_imooc.mianxiangduixiang.duotai.neibulei;

public class neibu_test {
    public static void main(String[] args) {
        /**
         * 静态内部类的调用
         */
        person p1=new person();
        p1.sleep();

        //1.内部静态类的调用
        person.heart j=new person.heart();
        System.out.println(j.eat());

        //2.内部静态类的调用
        System.out.println(new person.heart().eat());

        //3.调用内部静态类的静态方法
        person.heart.info();


    }
}

4.3.3 方法内部类

package com_imooc.mianxiangduixiang.duotai.neibulei;

public class fangfa {
    int age;

    public Object getheart(){
        //方法内部类
         class heart {
            //调用外部类的参数
            public String beat() {
                return new jingtai().age + "心在跳动";
            }

            //内部调用外部的静态方法
            public String eat() {
                jingtai.eat();
                return new jingtai().age + "心在跳动";
            }

            //内部调用外部的普通方法
            public void sleep() {
                new jingtai().sleep();
            }

            public String info() {
                return "我是方法体中的内部类";
            }
        }
        return new heart().info();
    }

}

package com_imooc.mianxiangduixiang.duotai.neibulei;

public class neibu_test {
    public static void main(String[] args) {
        /**
         * 方法体中的内部类
         */
        fangfa f = new fangfa();
        f.age=888;
        f.getheart();

    }
}