J2SE第三章——面向对象(二)

Java 发表评论

5.this

 

this变量的使用:

                  1.用在成员变量前面 (当前对象的sex属性)

                  2.成员方法前 (当前的对象)

                  3.代码冗余:使用this可以调用自身的另外一个构造函数

                  4.this作为返回值

public class Person {

         private int id;

         private String name;

         private boolean sex;

 

         public Person() {

 

         }

 

         public Person(boolean s) {

                   sex = s;

         }

 

         public Person(boolean s,String n) {

                   sex = s;

                   name = n;        

         }

 

         main() {

                   Person p1 = new Person();

         }

}

 

 

public class Person {

         private int id;

         private String name;

         private boolean sex;

         private itn tel;

 

         public Person() {

 

         }

 

         public Person(int id,String name, boolean sex) {

                   this.id = id;

                   this.name = name;

                   this.sex = sex;

 

                   //Person(sex,name);

                   this(sex,name)

                   构造函数内部,如果要访问另外一个构造函数,使用this关键字

 

                   this.eat();

                   就近原则  JVM认为这两个sex都是形参

                   这时 就有必要区分作为形参的sex 和 当前对象的sex属性

                   创建对象,对象内部除了包含有所属类中定义的成员变量外,还包含一个变量

                            命名为this ,this 的值是当前对象的地址

                   换句话说,this就是指向该对象本身

 

                   this变量的使用:

                            1.用在成员变量前面 (当前对象的sex属性)

                            2.成员方法前 (当前的对象)

                            3.代码冗余:使用this可以调用自身的另外一个构造函数

                            4.this作为返回值

 

         }

 

         public Person(boolean sex,String name) {

                   this.sex = sex;

                   this. = name;  

         }

 

         public void eat() {

 

         }

 

         main() {

                   Person p1 = new Person();

         }

}

 

public class Leaf {

         int i = 0;

         Leaf(int i ) {

                   this.i = i;

         }

 

         //方法的返回值类型:返回值的数据类型

         //现在返回的是某个对象的“地址” 那么返回值类型?

         //通过返回值得到的地址,就能找到对应的“对象”

         //所以返回值的类型,就应该是地址标记的对象所属的类型

         Lesf increment() {

                   i++;  //i属于调用该方法的对象leaf

                   return this;  //返回的是this的值,也就是当前对象的地址

         }

 

         void print() {

                   System.out.println(“i = ” + i);

         }

 

         public static void main(String[] args) {

                   Lesf leaf = new Leaf(100);

                   Leaf l1 = leaf.increment();

                   Leaf l2 = leaf.increment();

                   l2.print();

 

                   leaf.increment().increment().print();

         }

}

 

 

 

 

6.static:

         1.成员变量的前面

         2.成员方法的前面

         3.{} 前面

public class Person {

                  private static int id;

          静态成员变量在类加载(运行之前)的时候就开始分配空间(dateSegment)并默认初始化

 

         静态成员变量和具体某个对象没有关系~!(

                   因为静态变量是在加载时初始化的,而对象创建在运行期)

                   也可以说:静态变量是“类层面的变量”  而非静态变量是“对象层面的变量”

 

         既然静态变量属于类,那么可以通过类直接访问静态变量。(因为静态变量和对象无关)

                   推荐使用:“类名.静态成员变量”

 

         private int age;       

         //非静态成员变量什么时候初始化?—–运行创建对象的时候

 

         public void m1() {}

 

         public static void m2() { 

         静态方法:都是属于类层面的  和具体对象无关,通过”类名.静态方法()”访问

 

         }

 

         static {  静态代码块  通常用于资源初始化

 

         }

 

         public static void main(String[] args) {

                   main方法为什么要定义成static 类型的

                            现有的技术储备:加载 – 运行(main) – 创建对象.

                                     在main方法执行前,内存中不存在任何对象,只有类

                                     只能通过类调用main方法,所以main方法要定义成static类型的

                  }

}

 

 

public class Person {

         {System.out.println(“普通代码块”);

         }

 

         static {

                   System.out.println(“静态代码块”);

         }

 

         public Person() {

                   System.out.println(“构造函数”);

         }

 

         public static void main() {

                   Person p = new Person();

         }

}

 

 

—–执行顺序

静态代码块 -> 普通代码块 -> 构造函数

 

public static void main(String[] args) {

                  静态方法中直接访问非静态方法,一定出错

                  因为:静态(变量、方法、代码块)是属于“类层面”的,和具体对象无关

                  或者说,无论内存中存不存在对象,静态的一定存在

}

public class Cat {

         private static int sid = 0;

         private String name;

         int id;

 

         Cat(String name) {

                   this.name = name;

                   id = sid++;

         }

 

         public void info() {

                   System.out.println

                            (“My name is ” + name + “,No.” + id);

         }

 

         public static void main(String[] args) {

                   Cat.sid = 100;           //类名访问静态变量

                   Cat mimi = new Cat(“mimi”);

                   mimi.sid = 2000;      //对象访问静态变量

                   Cat pipi = new Cat(“pipi”);

                   mimi.info();

                   pipi.info();

         }

}

 

 

7.继承

         代码冗余  可能发生在(方法内部、类的内部),冗余代码往外踢,遵循“对等原则”

 

         通过继承,子类自动拥有了父类的成员(成员变量和成员方法)

         java只支持单继承,不允许多继承(extends)。接口可以(interface)

public class Person {

         private int id;

         private String name;

         private boolean sex;

 

         public void eat() {

                   System.out.println(“Person is eating”);

         }

}

 

public class Teacher extends Person{

        

         private int gl;  //教龄

         private String zc;  //职称

 

         public void teach() {

                   System.out.println(“Teacher is teaching”);

         }

 

}

 

 

public class Student extends Person {

 

         private String school;

         public void study() {

                   System.out.println(“Student is studying”);

         }

}

解决了代码冗余问题,简洁明了,但是高耦合,Teacher类和 Student类太过依赖 Person类

 

 

 

8.package

         操作一:

         1.在磁盘”e:\a”作为开发目录,存储源文件

         2.”e:\a”新建两个java源文件,Test.java和 Person.java

public class Person {

         public static int id = 100;

}

 

public class Test {

         public static void main(String[] args) {

                   Person p = new Person();

         }

}

         编译Test.java就同时得到两个字节码文件,Test.class和 Person.class

 

         操作二:

         1.Test类中可能会用到很多其他的类,为了方便管理 ,我们往往将这些类分类管理

         约定:没有配置classpath,当前的目录结构是”e:\a”

         2.Person.class存储在”e:\a\p”       //相对路径 p        

                  

                   在Person.java源文件的首行使用关键字package

 

         3.Teacher.class存储在”e:\a\t”       //相对路径 t

         4.Student.class存储在”e:\a\s”      //相对路径 s

                   路径:

                            相对路径:相对当前上下文

                            绝对路径:磁盘文件结构:盘符,如:”e:\a”

package t;

public  class Teacher {

         public static int id = 200;

}

 

 

package s;

 

public class Student {

         public static int id = 300;

}

         5.这样做编译后,出错:

                   “错误:无法访问Person类”

         6.正确的编译顺序:

                   先编译被依赖的(Test 依赖于 Person,先编译 Person)

 

                   JDK5.0之后,java源文件有可能会影响到.class的运行,先把Person.java源文件移除掉

 

                   接着把编译后得到的Person.class字节码文件,转移到p文件夹内

                   接着编译Test.java,依旧报错

         7.

                   “错误:找不到符号”

 

                   JVM 首先在当前上下文中寻找Person.class提示找不到符号

 

                   解决方法: 告诉JVM 到p文件夹下加载Person.class 

                   语法:在Person前加上 p.

 

class Test {

         public static void main(String[] args) {

                   p.Person pp = new p.Person();       

         }

}

         8. 再次编译Test.java不出错,运行成功

 

         操作三:

         想把Student放的更深一点,s下的s1,s1下的s2,s2下的s3内

package s.s1.s2.s3;  //磁盘目录/文件夹=====包

 

         public class Test {

                  public static void main(String[] args) {

                            s.s1.s2.s3.Student s = new s.s1.s2.s3.Student();   //全路径类名 -> 反射

                   }

         }

         每次都要书写全路径类名,过于繁琐,于是使用 import 关键字

                   imports.s1.s2.s3.Student;

 

                   imports.s1.s2.s3.Student是相对路径,相对于当前上下文以及classpath

                            所以可以把包的父路径配置到classpath之中去

public class Test {

         public static void main(String[] args) {

                   System.out.println(” “);

         }

}

System:系统内置类,D:jdk1.7.0_60\jre\lib\rt.jar;   

                  rt.jar是压缩文件的一种,压缩多个类        (java特有)

                  .rar  .zip压缩格式

                  rt-> java-> lang ->System.class

         java中lang包的类,JVM 会自动加载,不需要import的导入

 

“D:jdk1.7.0_60\jre\lib\rt.jar”在安装JDK环境的时候,自动配置都classpath里了。

import 包名.类名;          import 包名.*;

 

9.权限控制

 

子类继承父类,那么子类就会“自动拥有”父类的成员。

                  现在考虑的是:子类能不能“直接访问”从父类继承的成员?

 

成员变量定义前可以使用四种修饰关键字:

private int id;

default int id;

protected int id;

public int id;

        

成员变量位置:类内部         同一个包不同类内(含继承)     不同包不同类(含继承)    不同包不同类(没有继承)

private                                 Y                                  N                                                     N                                                              N

default                                 Y                                   Y                                                      N                                                             N

protected                                     Y                                  Y                                                    Y                                                             N

public                                    Y                                  Y                                                    Y                                                              Y

private : 类层面的

default : 包层面的

protected : 子类层面

public : 所有

 

类内部定义了”private”修饰的成员,那么现在测试的是同一个类的内部是不是可以直接访问该变量?

        

 

10.重写

子类继承父类的方法,如果对继承的方法的实现“不满意”,

那么在子类中可以重新定义继承方法的具体实现:重写

 

重载:一个类中的若干方法,如果满足:方法名相同,形参不同

重写:子类“重写”父类继承的方法

         注意                                               public                 void                   eat           ()                         {}

                                                        修饰符              返回值             方法名             形参列表        方法体

                                                        ——————————————————-

                   父类中的方法                                               相              相                          相              不

                   子类重写的方法                                          同              同                                 同              同

 

重写方法必须和被重写方法具有相同方法名称,参数列表和返回类型

 

权限修饰符:从严格到宽松的顺序:private  default   protected  public

                  子类的权限修饰,不能比父类的严格

—–父类—–

public class Person {

         public void eat() {

                   System.out.println(“Person is eating”);

         }

}

 

—–子类——

public class Teacher extends Person {

         public void eat() {

                   System.out.println(“Teacher is eating”);

         }

         09

 

         public void teach() {

                   System.out.println(“Teacher is teaching”);

         }

}

—–子类——

public class Student extends Person {

         public void eat() {

                   System.out.println(“Student is eating”);

         }

 

         public void study() {

                   System.out.println(“Student is studying”);

         }

}

 

 

 

11.super

 

创建一个对象,堆内存分配空间,包含所属类中定义的成员变量+this(本身的地址)+super(父对象的地址)

 

子类的构造函数必须调用父类的构造函数

如果调用super,必须写在子类构造方法的第一行

使用this(argument_list)调用本类的另外构造方法

如果子类的构造方法中没有显示的调用父类的构造方法,则系统默认调用父类无参的构造函数

如果子类的构造方法中既没有显示调用父类构造方法,而父类中又没有无参的构造函数,则出错

同一个构造函数中,如果同时出现this和super,this优先

 

class FatherClass {

         public int value;

 

         public void f() {

                   value = 100;

                   System.out.println(“FatherClass.value=” + value);

         }

}

 

class ChildClass extends FatherClass {

         public int value;

 

         public ChildClass() {

                   super();

         }

 

         public void f() {

                   super.f();

                   value = 200;

                   System.out.println(“ChildClass.value” + value);

                   System.out.println(value);

                   System.out.println(super.value);

         }

}

 

public class Test {

         public static void main(String[] args) {

                   ChildClass cc = new ChildClass();

                   cc.f();

         }

}

 

super:

                  super.成员变量

                  super.成员方法

                  super() 调用父类的无参构造方法

                  return super

 

class Person {

                  public in id;

}

 

class Teacher extends Person {

                  public int age; 

         }

         public Teacher() {

                   //子类构造函数的第一行“一定”是调用父类的构造函数(先创建父对象)

                   //通过关键字super来调用父类构造函数

                   //系统默认调用父类无参构造函数super()

 

                   super();

         }                

}

 

class Test {

         main() {

                   Teacher t = new Teacher();

         }

}

 

—————————————

 

public class Person {

         protected int id;

 

        

         如果没有t显示声明构造函数,那么系统自动提供“无参构造函数”

         如果显示定义了构造函数,那么系统将不再提供“无参构造函数

 

         class Person(int id) {

                   this.id = id;

         }

}

 

class SuperClass {

         private int n;

 

         /*

         SuperClass() {

         System.out.println(“SuperClass()”);

         }

         */

 

         SuperClass(int n) {

                   System.out.println(“SuperClass(“+n+”)”);       //300

                   this.n = n;

         }

}

 

class SubClass extends SuperClass {

         private int n;

 

         SubClass(int n) {

                   //super();

                   System.out.println(“Subclass(” + n + “)”);

                   this.n = n;

         }

 

         SubClass() {

                   super(300);

                   System.out.println(“SubClass()”);

         }

}

 

public class TestSuperSub {

         public static void main(String arg[]) {

                   //SubClass sc1 = new SubClass();

                   Subclass sc2 = new Subclass(400);

         }

}

 

 

class A {

        protected void print(String s) {

                 Systme.out.println(s);

        }

        A() {

                 print(“A()”);

                 public void f() {

                           print(“A:f()”);

                 }

        }

 

        class B extends A {

                 B() {

                           print(“B()”);      // 把B()存储内存单元的地址作为实参,传给形参变量

                 }

                 public void f() {

                                    // 重写

                 }

 

                 public static void main(String[] args) {

                           B b = new B();

                 }

        }

 }

 

 输出结果:

        A()  //;

        B()  //;

 

class Person {

         private String name;

         private String location;

 

         public Person(String name) {

                   this.name = name;

                   this.location = “beijing”;

         }

 

         public Person(String name,String location) {

                   this.name = name;

                   this.location = location;

         }

 

         public String info() {

                   return “name:” + name + “location:” + location;

         }

}

 

class Student extends Person {

         private String school;

 

         public Student(String name,String school) {

                   !!!super(); 同一个构造函数同属出现this和super,this优先

                   this(name,”beijing”,school);

         }

 

         public Student(String name,String location,String school) {

                   super(name,location);     //调用super,创建父类对象

                   this.school = school;

         }

 

         public String info() {

                   return super.info() + “school” + school;

         }

}

 

public class Test {

         public static void main() {

                   Person p1 = new Person(“A”);

                   Perosn p2 = new Person(“B”,”shanghai”);

                   Student s1 = new Student(“C”,”S1″);

                   System.out.println(p1.info());

         }

}

 

 

12.Object

 

        定义类:如果一个类没有显示的声明他的父类,那么约定继承自“Object”

        所以也可以说:Object 是所有类的公共父类

 JDK 的安装目录下,有一个src.zip(默认源文件包)

        Object 类中定义的11的成员方法,这11个方法有2个是 protected 修饰,其余都是

                 public 修饰,所以所有类都能继承这11个方法,并且能直接使用

                 1.反射      1个         .getclass

                 2.垃圾回收      1个         finalize

                 3.克隆      1个         clone

                 4.相等      1个         equals + hashCode

                 5.线程      5个           wait notify

                 6.字符串         1个         toString

 

        12.1  .toString()

                 + 如果”+”两侧的操作数有一个是字符串,就表示”连接”操作(即把另一个

                           操作数也变成字符串,然后执行字符串连接操作)

class Person {}

 

                 public class Test{

                           public static void main(String[] args) {

                                    //先把int 型的100转换成“100”

                                    //原因:int 基本类型对应一个引用类型Integer

                                    //Integer 继承了Object 提供的toString()方法,并且重写了toString方法

                                    //把int 整数转化成字符串类型

                                    System.out.println(100+”200″);300

 

                                    Person p = new Person();

                                    System.out.println(p);

                                    //对象作为println()方法的参数,观察输出结果:Person@7d206f0

                                    //其实是p.toString()的返回值,作为println()方法的参数输出

                                    //也就是:输出的是对象的toString()的返回值

                                    //即“Person@7d206f0”是Object的toString()方法的默认返回值

                                    //Object 类的 toString()

                                    //return getClass().getName()+”@”+Integer.toHexString(hashCode());     

 

 

                                    // y = f(x)

                                    //x = f-1(y)

                                    //哈希函数,单向不可逆

                                    //已知x通过hash函数可以得到与之对应的唯一的y

                                    }

                 }

 

 

         12.2.  equals()

class Mao {

                   String name;

                   String color;

 

                   Mao(String name,String color) {

                            this.name = name;

                            this.color = color;

                   }

         }

 

         public class Test {

                   public static void main(String[] args) {

                            Integer i1 = new Integer(1);

                            Integer i2 = new Integer(1);

                            Integer i3 = i2;

 

                            /*

                                     public Integer(int value) {

                                               this.value = value;

                                     }

 

                                     public boolean equals(Object obj) {

                                               if (obj instanceof Integer) {

                                                        return value == ((Integer)obj).intvalue();

                                               }

                                               return false;

                                     }

 

                                     public int intvalue {

                                               return value;

                                     }

                            */

 

                            System.out.println(i1==i2);               //false

                            System.out.println(i3==i2);               //true

 

                            System.out.println(i1.equals(i2));

                            //根据分析,i1和i2是分别指向两个对象

                            //而equals默认比较就是比较i1和i2的值,所以比较结果是false

                            //但是运行结果是true

                            //只能是Integer类重写了Object类的equals()

 

                            //构建Integer对象时,两个实参(基本类型int)的“==”比较

 

 

                   }

         }

 

                   生活中有这样一种描述:“相等” “相同” “一样的”

                   java语法:

                            1.==         值的比较

                                     基本数据类型:int i= 10;      int j = 20; boolean  flag=i==j;

                                               //flag= false;

                            2.equals

                                     当进行两个对象是否“相同”的比较判断时,使用Object类提供的equals方法

 

                                      1.equals()方法应用的情形:

                                               用于两个对象是否“相同”的情景

                                     2.语法:

                                               obj1.equals(obj2);

                                     3.方法的返回值:

                                               如果obj1和obj2“相同”返回true,不同返回false;

                                     4.何为“相同”何为“不同”

                                               结合具体业务情况

                                     5.如果不指定“相同”的条件,JVM怎么判断?

                                               Object父类中的equals方法已经对两个对象“相同”做了默认设置

 

                                               publicboolean equals(Object obj) {

                                                        return(this == obj);

                                               }

 

                                               所以:默认比较的还是两个对象的地址

 

 

                                     6.当需求涉及到自定义类的对象进行相同比较时,一般都需要重写equals方法

 

 

 

 

13.对象转化

 

 

需求场景:继承 子类  父类

         1. 子类类型的变量去指向子类

                   Teacher t =new Teacher();

 

         2.父类类型的变量指向子类(推荐使用)

                   Person p1 =new Teacher();

                   Person p2 =new Student();

 

         3.问题:父变量指向子类对象有什么特殊的地方 ?

                   3.1 父变量可以访问子类从父类继承而来的方法和属性

                   3.2 父变量不可以访问子类新增的成员

 

         4. 向上转型 (父变量指向子类对象)

 

         5. instanceof (操作符)

                   左侧:变量

                   右侧:类名

                   引用型变量instanceof 类名

                   含义:引用型变量是不是类或者其子类的对象(实例)?

 

                   Person p1 =new Person();

                   Person p2 = newTeacher();

                   System.out.println(p1instanceof Preson);    //变量p1指向的对象是不是Person类型的对象? true

                   System.out.println(p1instanceof Teacher);    //

 

class Person {

         String name;

 

         public void eat() {

                   System.out.println(“Person is eating”);

         }

}

 

class Tescher extends Person {

         String zc;

 

         public void teach() {

                   System.out.println(“Teacher is teaching”);

         }

}

 

class Student extends Person {

         String xh;

 

         public void study() {

                   System.out.println(“Student is studying”);

         }

}

 

public class Test {

         public static void main(String[] args) {

                   Teacher t = new Teacher();

                   Student s = new Student();

 

                   Person p1 = new Teacher();

                   Person p2 = new Student();

         }

}

 

//重写Cat 的 equals()

class Cat {

         private String name;

         private String color;

 

         public Cat(String name,String color) {

                   this.name = name;

                   this.color = color;

         }

}

 

 

public boolean equals(Object obj) {

         //首先确定obj的类型

         if (!obj instanceof Cat) {

                   return false;

         }

 

         //比较c1和c2的name属性,color属性是否相同

         //问题:this能不能访问到name属性—-能,name属性属于调用equals()方法的对象,即c1

         //问题:obj能不能访问到name属性—-不能,父变量obj指向子类对象c2,而name属性是子类对象c2新增的

        

         //问题:父变量怎么去访问子类新增的成员?

         //答:(向下转型)强制类型转换,把父变量转换为子类变量(大的给小的)

 

         Cat c = (Cat) obj;

         //this.name.equals(obj.name);

 

         return this.name.equals(c.name);

 

}

 

main() {

         Cat c1 = new  Cat(“A”,”A”);

         Cat c2 = new  Cat(“A”,”A”);

 

         System.out.println(c1.equals(c2));

}

 

 

14. 多态(访问并继承的方法)

//父类:

class Person {

         public void eat() {

                   System.out.println(“Person is eating…”);

         }

}

 

                   //子类1

class Teacher extends Perosn {

         public void eat() {

                   System.out.println(“Teacher is eating…”);

         }

}-

 

 

                   //子类2

class Student extends Person {

         public void eat() {

                   System.out.println(“Student is eating…”);

         }

}

 

         //测试类 父变量指向子类对象,然后通过父变量访问子类从父类继承并重写的方法

         //问题:方法在父类中有,每个子类对中也有,那么通过父类访问这个方法,这个方法到底是谁的?

 

public class Test {

         private static void main(String[] args) {

                   Person p1 = new Teacher();

                   p1.eat();  //Teacher is eating…

 

                   Person p2 = new Student();

                   p2.eat();  //Student is eating…

         }

}

 

前提条件:

                  1. 存在继承关系

                  2. 子类重写了从父类继承的方法

                  3. 父变量指向子类对象

 

结论:

                  多态(动态绑定)通过父类调用方法:那么这个方法是:子类重写后的方法

                            那么父变量具体指向哪个子类对象,这个方法就是该子类的对象

                   动态:父变量理论上可以指向任何一个子类对象,比如:p=new Student();p=new Teacher();

                   绑定:访问的方法,和父变量当前指向的那个子类对象“绑定”

 

15.抽象方法/类

 

多态的效果:父变量访问方法,方法是父变量当前指向的那个子类对象重写后的方法

问题:父类中的方法的方法体无论如何都执行不了

自然想到:父类方法的方法体既然不能被访问到,那么它就没有实现的必要

====> 结论:在多态环境下,父类被子类重写的方法,只有“定义”的必要,没有“实现”的必要

                   只要{}存在,方法就是实现了。即使{}里面什么都没有,这叫空实现

                   方法定义:权限   返回值类型  方法名()

                                      public    void       eat()

                   但问题又来了:这违背了我们之前掌握的理论:方法遵循“定义”“赋值/实现”“访问”

====> 解决方法:在方法的定义中假如关键字“abstract”(抽象的)

 

         结论:

                   抽象方法,只有定义,没有实现。称为“抽象方法”

                   抽象类:包含抽象方法,一定要“定义”成抽象类 ===>即使没有包含抽象方法,这个类一样可以定义成抽象类

 

 

特性:

                  抽象方法必须必重写(完善实现)

                  抽象类“天生”就是被继承的

                  抽象类不能被直接实现=====>不能被实例化

 

 

16.final

         默认名称全大写

 

         1.修饰变量 不变的变量,即变量值不能更改

         2.修饰方法(不能被重写)

         3.修饰类(不能被继承);

 

class Person {

         private String name;                  // 变量,属性 attribute   property

        

         public Person(String name) {

                   this.name = name;

         }

 

         // 取值方法  getter或者setter方法命名约定:set/get + attribute首字母大写

         public String getName() {         // get方法后缀首字母变小写后得到的单词:property

                   return name;

         }

 

         // 赋值

         public void setName(String name) {

                   this.name = name;

         }

}

class Test {

         public static void main(String[] args) {

                   Person p = new Person(“zs”);

                  

                   // 获取对象的private属性值

                   System.out.println(p.name);  // error 封装

                   System.out.println(p.getName());  // zs

 

                   // 重新给name属性赋值

                   p.setName(“ls”);

         }

}

 

 

重写@Override

         @Override

         public void eat() {

                   // TODO Auto-generated method stub

                   super.eat();

         }

发表评论

邮箱地址不会被公开。 必填项已用*标注

昵称 *