JavaSe总结-10--面向对象(5)

最新推荐文章于 2022-11-30 08:23:49 发布

不问因果

最新推荐文章于 2022-11-30 08:23:49 发布

阅读量286

点赞数

分类专栏： Java 文章标签： java

Java 专栏收录该内容

76 篇文章 0 订阅

订阅专栏

10.01 运动员和教练案例分析
10.02 运动员和教练案例实现
10.03 运动员和教练案例测试
10.04 类名作为形式参数
10.05 抽象类名作为形式参数
10.06 接口名作为形式参数
10.07 类名作为返回值类型
10.08 抽象类名作为返回值类型
10.09 接口名作为返回值类型
10.10 链式编程
10.11 package关键字的概述及作用
10.12 包的定义及注意事项
10.13 带包的类编译和运行
10.14 不同包下类之间的访问
10.15 import关键字的概述和使用
10.16 四种权限修饰符
10.17 类及其组成所使用的常见修饰符
10.18 内部类概述和访问特点
10.19 内部类分类及成员内部类的使用
10.20 成员内部类的常见修饰符及应用
10.21 成员内部类的面试题
10.22 局部内部类访问局部变量的问题
10.23 匿名内部类的格式和理解
10.24 匿名内部类的方法调用
10.25 匿名内部类在开发中的应用
10.26 匿名内部类的面试题

10.01 运动员和教练案例分析

教练和运动员案例:运动员分乒乓球运动员和篮球运动员，教练分乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。

分析:

10.02 运动员和教练案例实现

  1 //定义一个说英语的接口
  2 interface SpeakEnglish 
  3 {
  4     //说英语
  5     public abstract void speak();
  6 }
  7 
  8 //定义人的抽象类
  9 abstract class Person 
 10 {
 11     private String name;
 12     private int age;
 13     
 14     public Person() {}
 15     
 16     public Person(String name,int age) 
 17     {
 18         this.name = name;
 19         this.age = age;
 20     }
 21     
 22     public String getName() 
 23     {
 24         return name;
 25     }
 26     
 27     public void setName(String name) 
 28     {
 29         this.name = name;
 30     }
 31     
 32     public int getAge() 
 33     {
 34         return age;
 35     }
 36     
 37     public void setAge(int age) 
 38     {
 39         this.age = age;
 40     }
 41     
 42     //睡觉
 43     public void sleep() 
 44     {
 45         System.out.println("人都是要睡觉的");
 46     }
 47     
 48     //吃饭
 49     public abstract void eat();
 50 }
 51 
 52 //定义运动员抽象类
 53 abstract class Player extends Person 
 54 {
 55     public Player() {}
 56     
 57     public Player(String name,int age) 
 58     {
 59         super(name,age);
 60     }
 61     
 62     //学习
 63     public abstract void study();
 64 }
 65 
 66 //定义教练抽象类
 67 abstract class Coach extends Person 
 68 {
 69     public Coach() {}
 70     
 71     public Coach(String name,int age) 
 72     {
 73         super(name,age);
 74     }
 75     
 76     //教学
 77     public abstract void teach();
 78 }
 79 
 80 //定义乒乓球运动员具体类
 81 class PingPangPlayer extends Player implements SpeakEnglish 
 82 {
 83     public PingPangPlayer(){}
 84     
 85     public PingPangPlayer(String name,int age) 
 86     {
 87         super(name,age);
 88     }
 89     
 90     //吃
 91     public void eat() 
 92     {
 93         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
 94     }
 95     
 96     //学习
 97     public void study() 
 98     {
 99         System.out.println("乒乓球运动员学习如何发球和接球");
100     }
101     
102     //说英语
103     public void speak() 
104     {
105         System.out.println("乒乓球运动员说英语");
106     }
107 }
108 
109 //定义篮球运动员具体类
110 class BasketballPlayer extends Player 
111 {
112     public BasketballPlayer(){}
113     
114     public BasketballPlayer(String name,int age) 
115     {
116         super(name,age);
117     }
118     
119     //吃
120     public void eat() 
121     {
122         System.out.println("篮球运动员吃牛肉，喝牛奶");
123     }
124     
125     //学习
126     public void study() 
127     {
128         System.out.println("篮球运动员学习如何运球和投篮");
129     }
130 }
131 
132 //定义乒乓球教练具体类
133 class PingPangCoach extends Coach implements SpeakEnglish 
134 {
135     public PingPangCoach(){}
136     
137     public PingPangCoach(String name,int age) 
138     {
139         super(name,age);
140     }
141     
142     //吃
143     public void eat() 
144     {
145         System.out.println("乒乓球教练吃小白菜，喝大米粥");
146     }
147     
148     //教
149     public void teach() 
150     {
151         System.out.println("乒乓球教练教如何发球和接球");
152     }
153     
154     //说英语
155     public void speak() 
156     {
157         System.out.println("乒乓球教练说英语");
158     }
159 }
160 
161 //定义篮球教练具体类
162 class BasketballCoach extends Coach 
163 {
164     public BasketballCoach(){}
165     
166     public BasketballCoach(String name,int age) 
167     {
168         super(name,age);
169     }
170     
171     //吃
172     public void eat() 
173     {
174         System.out.println("篮球教练吃羊肉，喝羊奶");
175     }
176     
177     //教
178     public void teach() 
179     {
180         System.out.println("篮球教练教如何运球和投篮");
181     }
182 }

10.03 运动员和教练案例测试

  1 //定义一个说英语的接口
  2 interface SpeakEnglish 
  3 {
  4     //说英语
  5     public abstract void speak();
  6 }
  7 
  8 //定义人的抽象类
  9 abstract class Person 
 10 {
 11     private String name;
 12     private int age;
 13     
 14     public Person() {}
 15     
 16     public Person(String name,int age) 
 17     {
 18         this.name = name;
 19         this.age = age;
 20     }
 21     
 22     public String getName() 
 23     {
 24         return name;
 25     }
 26     
 27     public void setName(String name) 
 28     {
 29         this.name = name;
 30     }
 31     
 32     public int getAge() 
 33     {
 34         return age;
 35     }
 36     
 37     public void setAge(int age) 
 38     {
 39         this.age = age;
 40     }
 41     
 42     //睡觉
 43     public void sleep() 
 44     {
 45         System.out.println("人都是要睡觉的");
 46     }
 47     
 48     //吃饭
 49     public abstract void eat();
 50 }
 51 
 52 //定义运动员抽象类
 53 abstract class Player extends Person 
 54 {
 55     public Player() {}
 56     
 57     public Player(String name,int age) 
 58     {
 59         super(name,age);
 60     }
 61     
 62     //学习
 63     public abstract void study();
 64 }
 65 
 66 //定义教练抽象类
 67 abstract class Coach extends Person 
 68 {
 69     public Coach() {}
 70     
 71     public Coach(String name,int age) 
 72     {
 73         super(name,age);
 74     }
 75     
 76     //教学
 77     public abstract void teach();
 78 }
 79 
 80 //定义乒乓球运动员具体类
 81 class PingPangPlayer extends Player implements SpeakEnglish 
 82 {
 83     public PingPangPlayer(){}
 84     
 85     public PingPangPlayer(String name,int age) 
 86     {
 87         super(name,age);
 88     }
 89     
 90     //吃
 91     public void eat() 
 92     {
 93         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
 94     }
 95     
 96     //学习
 97     public void study() 
 98     {
 99         System.out.println("乒乓球运动员学习如何发球和接球");
100     }
101     
102     //说英语
103     public void speak() 
104     {
105         System.out.println("乒乓球运动员说英语");
106     }
107 }
108 
109 //定义篮球运动员具体类
110 class BasketballPlayer extends Player 
111 {
112     public BasketballPlayer(){}
113     
114     public BasketballPlayer(String name,int age) 
115     {
116         super(name,age);
117     }
118     
119     //吃
120     public void eat() 
121     {
122         System.out.println("篮球运动员吃牛肉，喝牛奶");
123     }
124     
125     //学习
126     public void study() 
127     {
128         System.out.println("篮球运动员学习如何运球和投篮");
129     }
130 }
131 
132 //定义乒乓球教练具体类
133 class PingPangCoach extends Coach implements SpeakEnglish 
134 {
135     public PingPangCoach(){}
136     
137     public PingPangCoach(String name,int age) 
138     {
139         super(name,age);
140     }
141     
142     //吃
143     public void eat() 
144     {
145         System.out.println("乒乓球教练吃小白菜，喝大米粥");
146     }
147     
148     //教
149     public void teach() 
150     {
151         System.out.println("乒乓球教练教如何发球和接球");
152     }
153     
154     //说英语
155     public void speak() 
156     {
157         System.out.println("乒乓球教练说英语");
158     }
159 }
160 
161 //定义篮球教练具体类
162 class BasketballCoach extends Coach 
163 {
164     public BasketballCoach(){}
165     
166     public BasketballCoach(String name,int age) 
167     {
168         super(name,age);
169     }
170     
171     //吃
172     public void eat() 
173     {
174         System.out.println("篮球教练吃羊肉，喝羊奶");
175     }
176     
177     //教
178     public void teach() 
179     {
180         System.out.println("篮球教练教如何运球和投篮");
181     }
182 }
183 class Demo
184 {
185     public static void main(String[] args)
186     {
187         //测试运动员(乒乓球运动员和篮球运动员)
188         //乒乓球运动员
189         PingPangPlayer ppp = new PingPangPlayer();
190         ppp.setName("王浩");
191         ppp.setAge(33);
192         System.out.println(ppp.getName()+"---"+ppp.getAge());
193         ppp.eat();
194         ppp.sleep();
195         ppp.study();
196         ppp.speak();
197         System.out.println("----------------");
198         
199         //篮球运动员
200         BasketballPlayer bp = new BasketballPlayer();
201         bp.setName("姚明");
202         bp.setAge(34);
203         System.out.println(bp.getName()+"---"+bp.getAge());
204         bp.eat();
205         bp.sleep();
206         bp.study();
207         //bp.speak(); //没有该方法
208     }
209 }

运行结果:

王浩---33
乒乓球运动员吃大白菜，喝小米粥
人都是要睡觉的
乒乓球运动员学习如何发球和接球
乒乓球运动员说英语
----------------
姚明---34
篮球运动员吃牛肉，喝牛奶
人都是要睡觉的
篮球运动员学习如何运球和投篮

10.04 类名作为形式参数

形式参数和返回值问题

形式参数:基本类型、引用类型(类、抽象类、接口)

返回值类型:基本类型、引用类型(类、抽象类、接口)

例:

 1 class Student
 2 {
 3     public void study()
 4     {
 5         System.out.println("好好学习");
 6     }
 7 }
 8 class StudentTest
 9 {
10     //形式参数是一个类
11     public void method(Student s)
12     {
13         s.study();
14     }
15 }
16 class Demo
17 {
18     public static void main(String[] args)
19     {
20         StudentTest st = new StudentTest();
21         Student s = new Student();
22 //需要的是该类的对象
23         st.method(s);
24     }
25 }

运行结果:

好好学习

10.05 抽象类名作为形式参数

例:

 1 abstract class Person
 2 {
 3     public abstract void study();
 4 }
 5 
 6 class Student extends Person
 7 {
 8     public void study()
 9     {
10         System.out.println("好好学习");
11     }
12 }
13 class PersonTest
14 {
15     //形式参数是一个抽象类
16     public void method(Person p)
17     {
18         p.study();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         PersonTest pt = new PersonTest();
26         Person p = new Student();
27         //需要该抽象类的子类对象
28         pt.method(p);
29     }
30 }

运行结果:

好好学习

10.06 接口名作为形式参数

例:

 1 interface Love
 2 {
 3     public abstract void love();
 4 }
 5 class Teacher implements Love
 6 {
 7     public void love()
 8     {
 9         System.out.println("老师爱学生");
10     }
11 }
12 class LoveTest
13 {
14     //形式参数是一个接口
15     public void method(Love l)
16     {
17         l.love();
18     }
19 }
20 class Demo
21 {
22     public static void main(String[] args)
23     {
24         LoveTest lt = new LoveTest();
25         Love l = new Teacher();
26         //需要该接口的实现类对象
27         lt.method(l);
28     }
29 }

运行结果:

老师爱学生

10.07 类名作为返回值类型

例:

 1 class Student
 2 {
 3     public void study()
 4     {
 5         System.out.println("好好学习");
 6     }
 7 }
 8 class StudentTest
 9 {
10     //返回值是一个类
11     public Student getStudent()
12     {
13         //真实返回的是该类的对象
14         return new Student();
15     }
16 }
17 class Demo
18 {
19     public static void main(String[] args)
20     {
21         StudentTest st = new StudentTest();
22         Student s = st.getStudent();
23         s.study();
24     }
25 }

10.08 抽象类名作为返回值类型

例:

 1 abstract class Person
 2 {
 3     public abstract void study();
 4 }
 5 class Student extends Person
 6 {
 7     public void study()
 8     {
 9         System.out.println("好好学习");
10     }
11 }
12 class PersonTest
13 {
14     //返回值是一个抽象类
15     public Person getPerson()
16     {
17         //真实返回的是抽象类的子类对象
18         return new Student();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         PersonTest pt = new PersonTest();
26         Person p = pt.getPerson();
27         p.study();
28     }
29 }

10.09 接口名作为返回值类型

例:

 1 interface Love
 2 {
 3     public abstract void love();
 4 }
 5 class Teacher implements Love
 6 {
 7     public void love()
 8     {
 9         System.out.println("老师爱学生");
10     }
11 }
12 class LoveTest
13 {
14     //返回值是一个接口
15     public Love getLove()
16     {
17         //真实返回的是该接口的实现类对象
18         return new Teacher();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         LoveTest lt = new LoveTest();
26         Love l = lt.getLove();
27         l.love();
28     }
29 }

10.10 链式编程

例:

 1 class Student
 2 {
 3     public void study()
 4     {
 5         System.out.println("好好学习");
 6     }
 7 }
 8 class StudentTest
 9 {
10     public Student getStudent()
11     {
12         return new Student();
13     }
14 }
15 class Demo
16 {
17     public static void main(String[] args)
18     {
19         //链式编程，每次调用方法完毕后返回的是一个对象
20         new StudentTest().getStudent().study();
21     }
22 }

10.11 package关键字的概述及作用

包的概述:其实就是文件夹

作用:对类进行分类管理

包的划分:

例:学生的增加，删除，修改，查询和老师的增加，删除，修改，查询

基本的划分:

按照功能分

cn.itcast.add(AddStudent,AddTeacher)

cn.itcast.delete(DeleteStudent,DeleteTeacher)

cn.itcast.update(UpdateStudent,UpdateTeacher)

cn.itcast.find(FindStudent,FindTeacher)

按照模块分

cn.itcast.teacher(AddTeacher,DeleteTeacher,UpdateTeacher,FindTeacher)

cn.itcast.student(AddStudent,DeleteStudent,UpdateStudent,FindStudent)

10.12 包的定义及注意事项

定义包的格式:package 包名; 多级包用.分开即可

注意事项:

1.package语句必须是程序的第一条可执行的代码

2.package语句在一个java文件中只能有一个

3.如果没有package，默认表示无包名

10.13 带包的类编译和运行

手动式

1:javac编译当前类文件

2:手动建立包对应的文件夹

3:把1步骤的class文件放到2步骤的最终文件夹下

4:通过java命令执行。

注意:需要带包名称执行

例:

1 package cn.itcast;
2 class Demo
3 {
4     public static void main(String[] args)
5     {
6         System.out.println("hello world");
7     }
8 }

运行:

自动式

1:javac编译的时候带上-d即可

例:javac -d . HelloWorld.java (-d后面跟的是目录, .表示当前目录)

2:通过java命令执行。需要带包名称执行。

10.14 不同包下类之间的访问

例:

定义两个类:Demo,Test。

Demo:测试方法(main)

Test:求和方法(sum)

运行步骤如下:

10.15 import关键字的概述和使用

导包概述:不同包下的类之间的访问，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。

导包格式:import 包名;

注意:这种方式导入是到类的名称。虽然可以最后写*，但是不建议。使用哪个类就导入哪个类。

例:

面试题:package,import,class有没有顺序关系?

有，package>import>class

package:只能有一个

import:可以有多个

class:可以有多个，建议只写一个

10.16 四种权限修饰符

10.17 类及其组成所使用的常见修饰符

权限修饰符:public、protected、默认的、private

状态修饰符:static、final

抽象修饰符:abstract

1.类:默认，public、final、abstract。其中使用public居多

2.成员变量:四种权限修饰符均可，final、static。其中使用private居多

3.构造方法:四种权限修饰符均可，其他不可以。其中使用public居多

4.成员方法:四种权限修饰符均可，fianl、static、abstract。其中使用public居多

10.18 内部类概述和访问特点

把类定义在其他类的内部，这个类就被称为内部类。

例:在类A中定义了一个类B，类B就是内部类。

内部类的访问特点:

内部类可以直接访问外部类的成员，包括私有。

外部类要访问内部类的成员，必须创建对象。

例:

 1 class Outer
 2 {
 3     private int num = 10;
 4 //内部类
 5     class Inner
 6     {
 7         public void show()
 8         {
 9             //内部类可以直接访问外部类的成员，包括私有
10             System.out.println("show run..."+num);
11         }
12     }
13     public void method()
14     {
15         //外部类要访问内部类的方法必须创建内部类的对象
16         Inner in = new Inner();
17         in.show();
18     }
19 }

10.19 内部类分类及成员内部类的使用

按照内部类在类中定义的位置不同，可以分为如下两种格式:

在成员位置称为成员内部类

在局部位置称为局部内部类

例:

 1 class Outer
 2 {
 3     //成员内部类
 4     class Inner
 5     {
 6     }
 7     public void method()
 8     {
 9         //局部内部类
10         class Inner
11         {
12         }
13     }
14 }

外界创建成员内部类对象的格式:

外部类名.内部类名对象名 = 外部类对象.内部类对象;

例:

 1 class Outer
 2 {
 3     private int num = 10;
 4     //成员内部类
 5     class Inner
 6     {
 7         public void show()
 8         {
 9             System.out.println(num);
10         }
11     }
12 }
13 class Demo
14 {
15     public static void main(String[] args)
16     {
17         //访问Inner类的show()方法
18 　　　　 //外部类名.内部类名 对象名 = 外部类对象.内部类对象;
19         Outer.Inner oi = new Outer().new Inner();
20         oi.show();
21     }
22 }

10.20 成员内部类的常见修饰符及应用

成员内部类的常见修饰符

1.private 为了保证数据的安全性

例:

 1 class Outer
 2 {
 3     //成员内部类，私有
 4     private class Inner
 5     {
 6         public void show()
 7         {
 8             System.out.println("满足条件输出");
 9         }
10     }
11     public void method(int num)
12     {
13         if(num > 0)
14         {
15             Inner i = new Inner();
16             i.show();
17         }
18     }
19 }
20 class Demo
21 {
22     public static void main(String[] args)
23     {
24         Outer o = new Outer();
25         o.method(-8);
26     }
27 }

上例中，只有当method方法传入的参数大于0时，才可以创建内部类的对象调用方法，否则不创建

2.static 为了让数据访问更方便

被静态修饰的成员内部类只能访问外部类的静态成员
内部类被静态修饰后的方法可以有静态方法也可以有非静态方法

例:

 1 class Outer
 2 {
 3     private static int num = 10;
 4     //成员内部类，静态
 5     public static class Inner
 6     {
 7         //静态方法
 8         public static void show1()
 9         {
10             System.out.println(num);
11         }
12         //非静态方法
13         public void show2()
14         {
15             System.out.println(num);
16         }
17     }
18 }
19 class Demo
20 {
21     public static void main(String[] args)
22     {
23         //成员内部类被静态修饰后的访问方式:
24         //外部类名.内部类名 对象名 = new 外部类名.内部类名();
25         Outer.Inner oi = new Outer.Inner();
26         oi.show1();
27         oi.show2();
28 
29         //静态方法show1()的另一种调用方式
30         Outer.Inner.show1();
31     }
32 }

10.21 成员内部类的面试题

分别输出30、20、10

 1 class Outer
 2 {
 3     public int num = 10;
 4     class Inner
 5     {
 6         public int num = 20;
 7         public void show()
 8         {
 9             int num = 30;
10             System.out.println(num);//30
11             System.out.println(this.num);//20
12             System.out.println(new Outer().num);//10
13             System.out.println(Outer.this.num);//10
14         }
15     }
16 }
17 class Demo
18 {
19     public static void main(String[] args)
20     {
21         Outer.Inner oi = new Outer().new Inner();
22         oi.show();
23     }
24 }

10.22 局部内部类访问局部变量的问题

1.可以直接访问外部类的成员

2.在局部位置可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

例:

 1 class Outer
 2 {
 3     private int num = 10;
 4     public void method()
 5     {
 6         //局部内部类
 7         class Inner
 8         {
 9             public void show()
10             {
11                 //可以直接访问外部类的成员
12                 System.out.println(num);
13             }
14         }
15         //在局部位置创建内部类对象
16         Inner i = new Inner();
17         //通过对象调用内部类方法
18         i.show();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         Outer o = new Outer();
26         o.method();
27     }
28 }

局部内部类访问局部变量的注意事项:

例:

 1 class Outer
 2 {
 3     public void method()
 4     {
 5         //局部变量
 6         final int num = 20;
 7         //局部内部类
 8         class Inner
 9         {
10             public void show()
11             {
12                 //局部内部类访问局部变量，该局部变量必须被声明为最终类型
13                 System.out.println(num);
14             }
15         }
16 
17         Inner i = new Inner();
18         i.show();
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         Outer o = new Outer();
26         o.method();
27     }
28 }

因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

10.23 匿名内部类的格式和理解

匿名内部类就是内部类的简化写法。

前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

格式:new 类名或者接口名() {重写方法;}

本质:是一个继承了该类或者实现了该接口的子类匿名对象

例:

10.24 匿名内部类的方法调用

例:

 1 interface Inter
 2 {
 3     public abstract void show1();
 4     public abstract void show2();
 5 }
 6 class Outer
 7 {
 8     public void method()
 9     {
10         /* 一个方法的调用
11         new Inter()
12         {
13             public void show1()
14             {
15                 System.out.println("show1");
16             }
17         }.show1();
18         */
19         //两个方法的调用
20         Inter i = new Inter()
21         {
22             public void show1()
23             {
24                 System.out.println("show1");
25             }
26             public void show2()
27             {
28                 System.out.println("show2");
29             }
30         };
31         i.show1();
32         i.show2();
33     }
34 }
35 class Demo
36 {
37     public static void main(String[] args)
38     {
39         Outer o = new Outer();
40         o.method();
41     }
42 }

10.25 匿名内部类在开发中的应用

例:

 1 interface Person
 2 {
 3     public abstract void study();
 4 }
 5 class PersonDemo
 6 {
 7     public void method(Person p)
 8     {
 9         p.study();
10     }
11 }
12 class Demo
13 {
14     public static void main(String[] args)
15     {
16         PersonDemo pd = new PersonDemo();
17         pd.method(new Person()
18         {
19             public void study()
20             {
21                 System.out.println("好好学习");
22             }
23         });
24     }
25 }

当函数参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递

10.26 匿名内部类的面试题

按照要求，补齐代码，要求在控制台输出”HelloWorld”

 1 interface Inter 
 2 { 
 3     void show(); 
 4 }
 5 class Outer 
 6 { 
 7     //补齐代码 
 8 }
 9 class Demo
10 {
11     public static void main(String[] args)
12     {
13         Outer.method().show();
14     }
15 }

补齐代码:

 1 /*
 2 分析:
 3 1:Outer.method()可以看出method()是Outer中的一个静态方法
 4 2:Outer.method().show()可以看出method()方法的返回值是一个对象。
 5 又由于接口Inter中有一个show()方法,所以method()方法的返回值类型是一个接口。
 6 */
 7 interface Inter 
 8 { 
 9     void show(); 
10 }
11 class Outer 
12 { 
13     //补齐代码 
14     public static Inter method()
15     {
16         return new Inter()
17         {
18             public void show()
19             {
20                 System.out.println("helloworld");
21             }
22         };
23     }
24 }
25 class Demo
26 {
27     public static void main(String[] args)
28     {
29         Outer.method().show();
30     }
31 }

不问因果

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSe总结-10--面向对象(5)

10.01 运动员和教练案例分析教练和运动员案例:运动员分乒乓球运动员和篮球运动员，教练分乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。分析:10.02 运动员和教练案例实现 1 //定义一个说英语的接口 2 interface SpeakEnglish 3 { 4 //说英语 5 public a
复制链接

扫一扫

专栏目录