###10.01_面向对象(package关键字的概述及作用)(了解)
* A:为什么要有包
* 将字节码(.class)进行分类存放
* 包其实就是文件夹
* B:包的概述
*
举例:
学生:增加,删除,修改,查询
老师:增加,删除,修改,查询
...
方案1:按照功能分
com.uplooking.add
AddStudent
AddTeacher
com.uplooking.delete
DeleteStudent
DeleteTeacher
com.uplooking.update
UpdateStudent
UpdateTeacher
com.uplooking.find
FindStudent
FindTeacher
方案2:按照模块分
com.uplooking.teacher
AddTeacher
DeleteTeacher
UpdateTeacher
FindTeacher
com.uplooking.student
AddStudent
DeleteStudent
UpdateStudent
FindStudent
###10.02_面向对象(包的定义及注意事项)(掌握)
* A:定义包的格式
* package 包名;
* 多级包用.分开即可
* B:定义包的注意事项
* A:package语句必须是程序的第一条可执行的代码
* B:package语句在一个java文件中只能有一个
* C:如果没有package,默认表示无包名
* C:案例演示
* 包的定义及注意事项
*package com.jianwen.test;
class Demo1
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
win+r
cd /d E:\jianwen\daima\day10
javac -d ./Demo1.java
java com.jianwen.test.Demo1;
###10.03_面向对象(带包的类编译和运行)(掌握)
* A:如何编译运行带包的类
* a:javac编译的时候带上-d即可
* javac -d . HelloWorld.java
* b:通过java命令执行。
* java 包名.HellWord
###10.04_面向对象(不同包下类之间的访问)(掌握)
* A:案例演示
* 不同包下类之间的访问
###10.05_面向对象(import关键字的概述和使用)(掌握)
* A:案例演示
* 为什么要有import
* 其实就是让有包的类对调用者可见,不用写全类名了
* B:导包格式
* import 包名;
* 注意:
* 这种方式导入是到类的名称。
* 虽然可以最后写*,但是不建议。
* C:package,import,class有没有顺序关系(面试题)
###10.06_面向对象(四种权限修饰符的测试)(掌握)
* A:案例演示
* 四种权限修饰符
* B:结论
*
本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
不同包下:继承
package com.jianwen.test1;
import com.jianwen.test.Demo1;
class Demo2 extends Demo1
{
public static void main(String[] args)
{
Demo2 p=new Demo2();
p.show();
p.news();
// p.show1();//不能输出的
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
void show1()
{
System.out.println("Hello");
}
public void show()
{
System.out.println("Hello");
}
protected void news()
{
System.out.println("world");
}
}
不同包下:没有继承
package com.jianwen.test1;
import com.jianwen.test.Demo1;//这个要有
class Demo2
{
public static void main(String[] args)
{
Demo1 p=new Demo1();
//p.show();
p.show1();
//p.show2();
//p.news();
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
public void show1()
{
System.out.println("Hello");
}
}
不同包下的子类必须是只是继承的表达式Demo2 p=new Demo2();(不能是多态的Demo1 p=new Demo2();)这种
的protected和public和访问。Demo1 p=new Demo2();这种就只有public可以访问;
同一包下:有继承关系的
package com.jianwen.test;
import com.jianwen.test.Demo1;
class Demo2 extends Demo1
{
public static void main(String[] args)
{
Demo1 p=new Demo2();
p.show();
p.show1();
//p.show2();
p.news();
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
private void show2()
{
System.out.println("Hello");}
void show()
{
System.out.println("Hello");
}
public void show1()
{
System.out.println("Hello");
}
protected void news()
{
System.out.println("world");
}
}
同一包下的继承类的写法和多态类的写法都可以;
:同一包下没有继承关系
package com.jianwen.test;
//import com.jianwen.test.Demo1;
class Demo2
{
public static void main(String[] args)
{
Demo1 p=new Demo1();
p.show();
p.show1();
//p.show2();
p.news();
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
void show()
{
System.out.println("Hello");
}
public void show1()
{
System.out.println("Hello");
}
protected void news()
{
System.out.println("world");
}
}
###10.07_面向对象(类及其组成所使用的常见修饰符)(掌握)
* A:修饰符:
* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 抽象修饰符:abstract
* B:类:
* 权限修饰符:默认修饰符,public
* 状态修饰符:final
* 抽象修饰符:abstract
* 用的最多的就是:public
* C:成员变量:
* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 用的最多的就是:private
* D:构造方法:
* 权限修饰符:private,默认的,protected,public
* 用的最多的就是:public
*如果不希望外部创建对象则设置为private(){}的构造方法;
* E:成员方法:
* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 抽象修饰符:abstract
* 用的最多的就是:public
* F:除此以外的组合规则:
* 成员变量:public static final
* 成员方法:
* public static
* public abstract
* public final
###10.08_面向对象(内部类概述和访问特点)(了解)
* A:内部类概述
* B:内部类访问特点
* a:内部类可以直接访问外部类的成员,包括私有。
* b:外部类要访问内部类的成员,必须创建对象。
* 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
* C:案例演示
* 内部类极其访问特点
*class Demo6
{
public static void main(String[] args)
{ //成员内部类
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Demo5.wenhua jw=new Demo5().new wenhua();
jw.show();
}
}
class Demo5
{
int bhao=4444;
class wenhua
{
public void show()
{
int age=50;
System.out.println("我是类的内部类"+age+" ,"+bhao);
}
}
}
###10.09_面向对象(成员内部类私有使用)(了解)
* private
*class Demo6
{
public static void main(String[] args)
{ //成员内部类
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Demo5.wenhua jw=new Demo5().new wenhua();
jw.show();
}
}
class Demo5
{
private int bhao=4444;
class wenhua
{
public void show()
{
int age=50;
System.out.println("我是类的内部类"+age+" ,"+bhao);
}
}
}
###10.10_面向对象(静态成员内部类)(了解)
* static
* B:成员内部类被静态修饰后的访问方式是:
* 外部类名.内部类名 对象名 =new 外部类名.内部类对象();
*class Demo6
{
public static void main(String[] args)
{ //静态成员内部类
//外部类名.内部类名 对象名 = new 外部类对象.内部类对象();
Demo5.wenhua jw= new Demo5.wenhua();
jw.show();
}
}
class Demo5
{
static int bhao=4444;//静态的只能访问静态的,final是不能访问的;
static class wenhua
{
public void show()
{
int age=50;
System.out.println("我是类的内部类"+age+bhao);
}
}
}
###10.11_面向对象(成员内部类的面试题)(掌握)
* A:面试题
*
要求:使用已知的变量,在控制台输出30,20,10。
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(?);
System.out.println(??);
System.out.println(???);
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
执行:
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(Outer.this.num);//10
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
###10.12_面向对象(局部内部类访问局部变量的问题)(掌握)
* A:案例演示
* 局部内部类访问局部变量必须用final修饰
* 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
但是jdk1.8取消了这个事情,所以我认为这是个bug
class Demo4
{ int bhao=4444;
class wenhua
{
}
public void show()
{
final int age=50;
class inner //局部内部类
{
private String name="我是内部类里私有的";
public void test()
{
System.out.println("我兄弟调用的我"+" "+age);//这个age必须是final修饰的不然没法访问;
}
}
inner w=new inner();
System.out.println(w.name+" ,"+age+" ,"+bhao);//和他们之间是兄弟关系;
w.test();
}
public static void main(String[] args)
{
Demo4 jw=new Demo4();
jw.show();
}
}
###10.13_面向对象(匿名内部类的格式和理解)
* A:匿名内部类
* 就是内部类的简化写法。
* B:前提:存在一个类或者接口
* 这里的类可以是具体类也可以是抽象类。
* C:格式:
*
new 类名或者接口名(){
重写方法;
}
* D:本质是什么呢?
* 是一个继承了该类或者实现了该接口的子类匿名对象。
* E:案例演示
* 按照要求来一个匿名内部类
class Demo14
{
public static void main(String[] args)
{
Demo14 demo = new Demo14();
demo.test(new Dao());
}
public void test(Dao wen)
{
wen.show();
}
}
class Dao
{
public void show()
{
System.out.println("show");
}
}
匿名调用:
class Demo14
{
public static void main(String[] args)
{
/*
(new 类名或者接口名(){
重写方法
}
);
*/
Demo14 demo = new Demo14();
demo.test(new Dao() //创建一个匿名对象,并对方法重写;
{
public void show()
{
super.show();//调用输出相当于父类里的show();
System.out.println("匿名内部类的输出");
}
}
);
}
public void test(Dao dao)//匿名传输 demo.test(new Dao()),public void test(Dao dao)
{
dao.show();
}
}
abstract class Dao //创建一个抽象的类
{
public void show()
{
System.out.println("抽象父类的输出");
}
}
###10.14_面向对象(匿名内部类重写多个方法调用)
* A:案例演示
* 匿名内部类的方法调用
###10.15_面向对象(匿名内部类在开发中的应用)
* A:代码如下
*
//这里写抽象类,接口都行
abstract class Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
class PersonTest {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
}
}
代码:
abstract class Person
{
public abstract void show();
}
class PersonDemo
{
public void method(Person p)
{
p.show();
}
}
class PersonTest {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo();
pd.method(new Person(){
public void show()
{
System.out.println("匿名内部类的输出");
}
}
);
}
}
###10.16_面向对象(匿名内部类的面试题)
* A:面试题
*
按照要求,补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
代码1:
interface Inter
{
public abstract void show();
}
class Outer
{
//补齐代码
static class method //静态成员内部类
{
public void show()
{
System.out.println("hello worid!");
}
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer.method jw = new Outer.method();
jw.show();
}
}
代码2:
interface Inter
{
public abstract void show();
}
class Outer
{
//补齐代码
class method //成员内部类
{
public void show()
{
System.out.println("hello worid!");
}
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer.method jw = new Outer().new method();
jw.show();
}
}
代码3:
interface Inter
{
public abstract void show();
}
class Outer
{
//补齐代码
public static void method()//局部内部类
{
class inner
{
public void show()
{
System.out.println("hello");
}
}
inner w=new inner();
w.show();
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer jw=new Outer();
jw.method();
}
}
代码4:
interface Inter
{
public abstract void show();
}
class Outer //匿名内部类
{
//补齐代码
public void method(Inter p)
{
p.show();
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer jw=new Outer();
jw.method(new Inter(){
public void show()
{
System.out.println("hello world");
}
}
);
}
}
* A:为什么要有包
* 将字节码(.class)进行分类存放
* 包其实就是文件夹
* B:包的概述
*
举例:
学生:增加,删除,修改,查询
老师:增加,删除,修改,查询
...
方案1:按照功能分
com.uplooking.add
AddStudent
AddTeacher
com.uplooking.delete
DeleteStudent
DeleteTeacher
com.uplooking.update
UpdateStudent
UpdateTeacher
com.uplooking.find
FindStudent
FindTeacher
方案2:按照模块分
com.uplooking.teacher
AddTeacher
DeleteTeacher
UpdateTeacher
FindTeacher
com.uplooking.student
AddStudent
DeleteStudent
UpdateStudent
FindStudent
###10.02_面向对象(包的定义及注意事项)(掌握)
* A:定义包的格式
* package 包名;
* 多级包用.分开即可
* B:定义包的注意事项
* A:package语句必须是程序的第一条可执行的代码
* B:package语句在一个java文件中只能有一个
* C:如果没有package,默认表示无包名
* C:案例演示
* 包的定义及注意事项
*package com.jianwen.test;
class Demo1
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
win+r
cd /d E:\jianwen\daima\day10
javac -d ./Demo1.java
java com.jianwen.test.Demo1;
###10.03_面向对象(带包的类编译和运行)(掌握)
* A:如何编译运行带包的类
* a:javac编译的时候带上-d即可
* javac -d . HelloWorld.java
* b:通过java命令执行。
* java 包名.HellWord
###10.04_面向对象(不同包下类之间的访问)(掌握)
* A:案例演示
* 不同包下类之间的访问
###10.05_面向对象(import关键字的概述和使用)(掌握)
* A:案例演示
* 为什么要有import
* 其实就是让有包的类对调用者可见,不用写全类名了
* B:导包格式
* import 包名;
* 注意:
* 这种方式导入是到类的名称。
* 虽然可以最后写*,但是不建议。
* C:package,import,class有没有顺序关系(面试题)
###10.06_面向对象(四种权限修饰符的测试)(掌握)
* A:案例演示
* 四种权限修饰符
* B:结论
*
本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
不同包下:继承
package com.jianwen.test1;
import com.jianwen.test.Demo1;
class Demo2 extends Demo1
{
public static void main(String[] args)
{
Demo2 p=new Demo2();
p.show();
p.news();
// p.show1();//不能输出的
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
void show1()
{
System.out.println("Hello");
}
public void show()
{
System.out.println("Hello");
}
protected void news()
{
System.out.println("world");
}
}
不同包下:没有继承
package com.jianwen.test1;
import com.jianwen.test.Demo1;//这个要有
class Demo2
{
public static void main(String[] args)
{
Demo1 p=new Demo1();
//p.show();
p.show1();
//p.show2();
//p.news();
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
public void show1()
{
System.out.println("Hello");
}
}
不同包下的子类必须是只是继承的表达式Demo2 p=new Demo2();(不能是多态的Demo1 p=new Demo2();)这种
的protected和public和访问。Demo1 p=new Demo2();这种就只有public可以访问;
同一包下:有继承关系的
package com.jianwen.test;
import com.jianwen.test.Demo1;
class Demo2 extends Demo1
{
public static void main(String[] args)
{
Demo1 p=new Demo2();
p.show();
p.show1();
//p.show2();
p.news();
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
private void show2()
{
System.out.println("Hello");}
void show()
{
System.out.println("Hello");
}
public void show1()
{
System.out.println("Hello");
}
protected void news()
{
System.out.println("world");
}
}
同一包下的继承类的写法和多态类的写法都可以;
:同一包下没有继承关系
package com.jianwen.test;
//import com.jianwen.test.Demo1;
class Demo2
{
public static void main(String[] args)
{
Demo1 p=new Demo1();
p.show();
p.show1();
//p.show2();
p.news();
}
}
package com.jianwen.test;
public class Demo1
{
private int age= 10;
private String name;
public Demo1()
{
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
void show()
{
System.out.println("Hello");
}
public void show1()
{
System.out.println("Hello");
}
protected void news()
{
System.out.println("world");
}
}
###10.07_面向对象(类及其组成所使用的常见修饰符)(掌握)
* A:修饰符:
* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 抽象修饰符:abstract
* B:类:
* 权限修饰符:默认修饰符,public
* 状态修饰符:final
* 抽象修饰符:abstract
* 用的最多的就是:public
* C:成员变量:
* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 用的最多的就是:private
* D:构造方法:
* 权限修饰符:private,默认的,protected,public
* 用的最多的就是:public
*如果不希望外部创建对象则设置为private(){}的构造方法;
* E:成员方法:
* 权限修饰符:private,默认的,protected,public
* 状态修饰符:static,final
* 抽象修饰符:abstract
* 用的最多的就是:public
* F:除此以外的组合规则:
* 成员变量:public static final
* 成员方法:
* public static
* public abstract
* public final
###10.08_面向对象(内部类概述和访问特点)(了解)
* A:内部类概述
* B:内部类访问特点
* a:内部类可以直接访问外部类的成员,包括私有。
* b:外部类要访问内部类的成员,必须创建对象。
* 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
* C:案例演示
* 内部类极其访问特点
*class Demo6
{
public static void main(String[] args)
{ //成员内部类
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Demo5.wenhua jw=new Demo5().new wenhua();
jw.show();
}
}
class Demo5
{
int bhao=4444;
class wenhua
{
public void show()
{
int age=50;
System.out.println("我是类的内部类"+age+" ,"+bhao);
}
}
}
###10.09_面向对象(成员内部类私有使用)(了解)
* private
*class Demo6
{
public static void main(String[] args)
{ //成员内部类
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Demo5.wenhua jw=new Demo5().new wenhua();
jw.show();
}
}
class Demo5
{
private int bhao=4444;
class wenhua
{
public void show()
{
int age=50;
System.out.println("我是类的内部类"+age+" ,"+bhao);
}
}
}
###10.10_面向对象(静态成员内部类)(了解)
* static
* B:成员内部类被静态修饰后的访问方式是:
* 外部类名.内部类名 对象名 =new 外部类名.内部类对象();
*class Demo6
{
public static void main(String[] args)
{ //静态成员内部类
//外部类名.内部类名 对象名 = new 外部类对象.内部类对象();
Demo5.wenhua jw= new Demo5.wenhua();
jw.show();
}
}
class Demo5
{
static int bhao=4444;//静态的只能访问静态的,final是不能访问的;
static class wenhua
{
public void show()
{
int age=50;
System.out.println("我是类的内部类"+age+bhao);
}
}
}
###10.11_面向对象(成员内部类的面试题)(掌握)
* A:面试题
*
要求:使用已知的变量,在控制台输出30,20,10。
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(?);
System.out.println(??);
System.out.println(???);
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
执行:
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(Outer.this.num);//10
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
###10.12_面向对象(局部内部类访问局部变量的问题)(掌握)
* A:案例演示
* 局部内部类访问局部变量必须用final修饰
* 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
但是jdk1.8取消了这个事情,所以我认为这是个bug
class Demo4
{ int bhao=4444;
class wenhua
{
}
public void show()
{
final int age=50;
class inner //局部内部类
{
private String name="我是内部类里私有的";
public void test()
{
System.out.println("我兄弟调用的我"+" "+age);//这个age必须是final修饰的不然没法访问;
}
}
inner w=new inner();
System.out.println(w.name+" ,"+age+" ,"+bhao);//和他们之间是兄弟关系;
w.test();
}
public static void main(String[] args)
{
Demo4 jw=new Demo4();
jw.show();
}
}
###10.13_面向对象(匿名内部类的格式和理解)
* A:匿名内部类
* 就是内部类的简化写法。
* B:前提:存在一个类或者接口
* 这里的类可以是具体类也可以是抽象类。
* C:格式:
*
new 类名或者接口名(){
重写方法;
}
* D:本质是什么呢?
* 是一个继承了该类或者实现了该接口的子类匿名对象。
* E:案例演示
* 按照要求来一个匿名内部类
class Demo14
{
public static void main(String[] args)
{
Demo14 demo = new Demo14();
demo.test(new Dao());
}
public void test(Dao wen)
{
wen.show();
}
}
class Dao
{
public void show()
{
System.out.println("show");
}
}
匿名调用:
class Demo14
{
public static void main(String[] args)
{
/*
(new 类名或者接口名(){
重写方法
}
);
*/
Demo14 demo = new Demo14();
demo.test(new Dao() //创建一个匿名对象,并对方法重写;
{
public void show()
{
super.show();//调用输出相当于父类里的show();
System.out.println("匿名内部类的输出");
}
}
);
}
public void test(Dao dao)//匿名传输 demo.test(new Dao()),public void test(Dao dao)
{
dao.show();
}
}
abstract class Dao //创建一个抽象的类
{
public void show()
{
System.out.println("抽象父类的输出");
}
}
###10.14_面向对象(匿名内部类重写多个方法调用)
* A:案例演示
* 匿名内部类的方法调用
###10.15_面向对象(匿名内部类在开发中的应用)
* A:代码如下
*
//这里写抽象类,接口都行
abstract class Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
class PersonTest {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
}
}
代码:
abstract class Person
{
public abstract void show();
}
class PersonDemo
{
public void method(Person p)
{
p.show();
}
}
class PersonTest {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo();
pd.method(new Person(){
public void show()
{
System.out.println("匿名内部类的输出");
}
}
);
}
}
###10.16_面向对象(匿名内部类的面试题)
* A:面试题
*
按照要求,补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
代码1:
interface Inter
{
public abstract void show();
}
class Outer
{
//补齐代码
static class method //静态成员内部类
{
public void show()
{
System.out.println("hello worid!");
}
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer.method jw = new Outer.method();
jw.show();
}
}
代码2:
interface Inter
{
public abstract void show();
}
class Outer
{
//补齐代码
class method //成员内部类
{
public void show()
{
System.out.println("hello worid!");
}
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer.method jw = new Outer().new method();
jw.show();
}
}
代码3:
interface Inter
{
public abstract void show();
}
class Outer
{
//补齐代码
public static void method()//局部内部类
{
class inner
{
public void show()
{
System.out.println("hello");
}
}
inner w=new inner();
w.show();
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer jw=new Outer();
jw.method();
}
}
代码4:
interface Inter
{
public abstract void show();
}
class Outer //匿名内部类
{
//补齐代码
public void method(Inter p)
{
p.show();
}
}
class OuterDemo
{
public static void main(String[] args)
{
//要求在控制台输出”HelloWorld”
Outer jw=new Outer();
jw.method(new Inter(){
public void show()
{
System.out.println("hello world");
}
}
);
}
}