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