您的位置 首页 java

Java基础-10总结形式参数,包,修饰符,内部类

获取更多免费资源与技术文章,加微信公众号:【Java帮帮】,或者关注【Java帮帮】QQ空间,csdn博客

类, 抽象类 ,接口的综合小练习

/*

教练和运动员案例(学生分析然后讲解)

乒乓球运动员和篮球运动员。

乒乓球教练和篮球教练。

为了出国交流,跟乒乓球相关的人员都需要学习英语。

请用所学知识:

分析,这个案例中有哪些抽象类,哪些接口,哪些具体类。

整个分析过程,我是通过画图讲解的。

*/

//定义一个说英语的接口

interface SpeakEnglish {

//说英语

public abstract void speak();

}

//定义人的抽象类

abstract class Person {

private String name;

private int age;

public Person() {}

public Person(String name,int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

//睡觉

public void sleep() {

System.out.println(“人都是要睡觉的”);

}

//吃饭

public abstract void eat();

}

//定义运动员抽象类

abstract class Player extends Person {

public Player() {}

public Player(String name,int age) {

super(name,age);

}

//学习

public abstract void study();

}

//定义教练抽象类

abstract class Coach extends Person {

public Coach() {}

public Coach(String name,int age) {

super(name,age);

}

//教

public abstract void teach();

}

//定义乒乓球运动员具体类

class PingPangPlayer extends Player implements SpeakEnglish {

public PingPangPlayer(){}

public PingPangPlayer(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println(“乒乓球运动员吃大白菜,喝小米粥”);

}

//学习

public void study() {

System.out.println(“乒乓球运动员学习如何发球和接球”);

}

//说英语

public void speak() {

System.out.println(“乒乓球运动员说英语”);

}

}

//定义篮球运动员具体类

class BasketballPlayer extends Player {

public BasketballPlayer(){}

public BasketballPlayer(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println(“篮球运动员吃牛肉,喝牛奶”);

}

//学习

public void study() {

System.out.println(“篮球运动员学习如何运球和投篮”);

}

}

//定义乒乓球教练具体类

class PingPangCoach extends Coach implements SpeakEnglish {

public PingPangCoach(){}

public PingPangCoach(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println(“乒乓球教练吃小白菜,喝大米粥”);

}

//教

public void teach() {

System.out.println(“乒乓球教练教如何发球和接球”);

}

//说英语

public void speak() {

System.out.println(“乒乓球教练说英语”);

}

}

//定义篮球教练具体类

class BasketballCoach extends Coach {

public BasketballCoach(){}

public BasketballCoach(String name,int age) {

super(name,age);

}

//吃

public void eat() {

System.out.println(“篮球教练吃羊肉,喝羊奶”);

}

//教

public void teach() {

System.out.println(“篮球教练教如何运球和投篮”);

}

}

class InterfaceDemo {

public static void main(String[] args) {

//测试运动员(乒乓球运动员和篮球运动员)

//乒乓球运动员

PingPangPlayer ppp = new PingPangPlayer();

ppp.setName(“王浩”);

ppp.setAge(33);

System.out.println(ppp.getName()+”—“+ppp.getAge());

ppp.eat();

ppp.sleep();

ppp.study();

ppp.speak();

System.out.println(“—————-“);

//通过带参构造给数据(留给你们)

//篮球运动员

BasketballPlayer bp = new BasketballPlayer();

bp.setName(” 姚明 “);

bp.setAge(34);

System.out.println(bp.getName()+”—“+bp.getAge());

bp.eat();

bp.sleep();

bp.study();

//bp.speak(); //没有该方法

//测试教练自己做

}

}

1: 形式参数 和返回值的问题(理解)

(1)形式参数:

类名:需要该类的对象

抽象类名:需要该类的子类对象

接口名:需要该接口的实现类对象

/*

形式参数:

基本类型(太简单,不是我今天要讲解的)

引用类型

类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象

抽象类:

接口

*/

class Student {

public void study() {

System.out.println(“Good Good Study,Day Day Up”);

}

}

class StudentDemo {

public void method(Student s) { //ss; ss = new Student(); Student s = new Student();

s.study();

}

}

class StudentTest {

public static void main(String[] args) {

//需求:我要测试Student类的study()方法

Student s = new Student();

s.study();

System.out.println(“—————-“);

//需求2:我要测试StudentDemo类中的method()方法

StudentDemo sd = new StudentDemo();

Student ss = new Student();

sd.method(ss);

System.out.println(“—————-“);

//匿名对象用法

new StudentDemo().method(new Student());

}

}

/*

形式参数:

基本类型(太简单,不是我今天要讲解的)

引用类型

类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象

抽象类:需要的是该抽象的类子类对象

接口

*/

abstract class Person {

public abstract void study();

}

class PersonDemo {

public void method(Person p) {//p; p = new Student(); Person p = new Student(); // 多态

p.study();

}

}

//定义一个具体的学生类

class Student extends Person {

public void study() {

System.out.println(“Good Good Study,Day Day Up”);

}

}

class PersonTest {

public static void main(String[] args) {

//目前是没有办法的使用的

//因为抽象类没有对应的具体类

//那么,我们就应该先定义一个具体类

//需求:我要使用PersonDemo类中的method()方法

PersonDemo pd = new PersonDemo();

Person p = new Student();

pd.method(p);

}

}

/*

形式参数:

基本类型(太简单,不是我今天要讲解的)

引用类型

类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象

抽象类:需要的是该抽象的类子类对象

接口:需要的是该接口的实现类对象

*/

//定义一个爱好的接口

interface Love {

public abstract void love();

}

class LoveDemo {

public void method(Love l) { //l; l = new Teacher(); Love l = new Teacher(); 多态

l.love();

}

}

//定义具体类实现接口

class Teacher implements Love {

public void love() {

System.out.println(“老师爱学生,爱Java,爱林青霞”);

}

}

class TeacherTest {

public static void main(String[] args) {

//需求:我要测试LoveDemo类中的love()方法

LoveDemo ld = new LoveDemo();

Love l = new Teacher();

ld.method(l);

}

}

(2)返回值类型:

类名:返回的是该类的对象

抽象类名:返回的是该类的子类对象

接口名:返回的是该接口的实现类的对象

/*

返回值类型

基本类型:(基本类型太简单,我不准备讲解)

引用类型:

类:返回的是该类的对象

抽象类:

接口:

*/

class Student {

public void study() {

System.out.println(“Good Good Study,Day Day Up”);

}

}

class StudentDemo {

public Student getStudent() {

//Student s = new Student();

//Student ss = s;

//Student s = new Student();

//return s;

return new Student();

}

}

class StudentTest2 {

public static void main(String[] args) {

//需求:我要使用Student类中的study()方法

//但是,这一次我的要求是,不要直接创建Student的对象

//让你使用StudentDemo帮你创建对象

StudentDemo sd = new StudentDemo();

Student s = sd.getStudent(); //new Student(); Student s = new Student();

s.study();

}

}

/*

返回值类型

基本类型:(基本类型太简单,我不准备讲解)

引用类型:

类:返回的是该类的对象

抽象类:返回的是该抽象类的子类对象

接口:

*/

abstract class Person {

public abstract void study();

}

class PersonDemo {

public Person getPerson() {

//Person p = new Student();

//return p;

return new Student();

}

}

class Student extends Person {

public void study() {

System.out.println(“Good Good Study,Day Day Up”);

}

}

class PersonTest2 {

public static void main(String[] args) {

//需求:我要测试Person类中的study()方法

PersonDemo pd = new PersonDemo();

Person p = pd.getPerson(); //new Student(); Person p = new Student(); 多态

p.study();

}

}

/*

返回值类型

基本类型:(基本类型太简单,我不准备讲解)

引用类型:

类:返回的是该类的对象

抽象类:返回的是该抽象类的子类对象

接口:返回的是该接口的实现类的对象

*/

//定义一个爱好的接口

interface Love {

public abstract void love();

}

class LoveDemo {

public Love getLove() {

//Love l = new Teacher();

//return l;

return new Teacher();

}

}

//定义具体类实现接口

class Teacher implements Love {

public void love() {

System.out.println(“老师爱学生,爱Java,爱林青霞”);

}

}

class TeacherTest2 {

public static void main(String[] args) {

//如何测试呢?

LoveDemo ld = new LoveDemo();

Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态

l.love();

}

}

(3)链式编程

对象.方法1().方法2()…….方法n();

这种用法:其实在方法1()调用完毕后,应该一个对象;

方法2()调用完毕后,应该返回一个对象。

方法n()调用完毕后,可能是对象,也可以不是对象。

/*

链式编程。

每次调用完毕方法后,返回的是一个对象。

*/

class Student {

public void study() {

System.out.println(“Good Good Study,Day Day Up”);

}

}

class StudentDemo {

public Student getStudent() {

return new Student();

}

}

class StudentTest3 {

public static void main(String[] args) {

//如何调用的呢?

StudentDemo sd = new StudentDemo();

//Student s = sd.getStudent();

//s.study();

//大家注意了

sd.getStudent().study();

}

}

2:包(理解)

(1)其实就是文件夹

(2)作用:

A:区分同名的类

B:对类进行分类管理

a:按照功能分

b:按照模块分

/*

包:

A:其实就是文件夹

B:作用

a:把相同的类名放到不同的包中

b:对类进行分类管理

举例:

学生:增加,删除,修改,查询

老师:增加,删除,修改,查询

方案1:按照功能分

cn.itcast.add

AddStudent

AddTeacher

cn.itcast.delete

DeleteStudent

DeleteTeacher

cn.itcast.update

UpdateStudent

UpdateTeacher

cn.itcast.find

FindStudent

FindTeacher

方案2:按照模块分

cn.itcast.teacher

AddTeacher

DeleteTeacher

UpdateTeacher

FindTeacher

cn.itcast.student

AddStudent

DeleteStudent

UpdateStudent

FindStudent

包的定义

package 包名;

多级包用.分开即可

注意事项:

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

B:package语句在一个java文件中只能有一个

C:如果没有package,默认表示无包名

带包的编译和运行:

A:手动式

a:编写一个带包的java文件。

b:通过javac命令编译该java文件。

c:手动创建包名。

d:把b步骤的class文件放到c步骤的最底层包

e:回到和包根目录在同一目录的地方,然后运行

带包运行。

B:自动式

a:编写一个带包的java文件。

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

javac -d . HelloWorld.java

c:回到和包根目录在同一目录的地方,然后运行

带包运行。

*/

package cn.itcast;

class HelloWorld {

public static void main(String[] args) {

System.out.println(“HelloWorld”);

}

}

(3)包的定义(掌握)

package 包名;

多级包用.分开。

(4)注意事项:(掌握)

A:package语句必须在文件中的第一条有效语句

B:在一个java文件中,只能有一个package

C:如果没有package,默认就是无包名

(5)带包的编译和运行

A:手动式

B:自动式(掌握)

javac -d . HelloWorld.java

3:导包(掌握)

(1)我们多次使用一个带包的类,非常的麻烦,这个时候,Java就提供了一个关键字import。

(2)格式:

import 包名…类名;

另一种:

import 包名…*;(不建议)

(3)package,import,class的顺序

package > import > class

/*

Test类,测试

导包:

格式:import 包名;

这种方式导入是到类的名称。

注意:我们用谁就导谁。

面试题:

package,import,class有没有顺序关系?

有。

package > import > class

Package:只能有一个

import:可以有多个

class:可以有多个,以后建议是一个

*/

package cn.itcast;

import com.liuyi.Demo;

class Test {

public static void main(String[] args) {

//Demo d = new Demo();

/*

com.liuyi.Demo d = new com.liuyi.Demo();

System.out.println(d.sum(10,20));

com.liuyi.Demo d2 = new com.liuyi.Demo();

System.out.println(d2.sum(10,20));

com.liuyi.Demo d3 = new com.liuyi.Demo();

System.out.println(d3.sum(10,20));

com.liuyi.Demo d4 = new com.liuyi.Demo();

System.out.println(d4.sum(10,20));

*/

Demo d = new Demo();

System.out.println(d.sum(10,20));

}

}

/*

第一个问题:找不到Demo

第二个问题:程序包com.liuyi不存在

第三个问题: Demo在com.liuyi中不是公共的; 无法从外部程序包中对其进行访问

*/

4:权限修饰符(掌握)

(1)权限修饰符

本类同一个包下不同包下的子类不同包下的无关类

privateY

默认YY

protected YYY

publicYYYY

(2)这四种权限修饰符在任意时刻只能出现一种。

public class Demo {}

/*

权限修饰符:

本类同一个包下(子类和无关类)不同包下(子类)不同包下(无关类)

private Y

默认YY

protectedYYY

publicYYYY

*/

package com.liuyi;

public class Father {

private void show() {

System.out.println(“show”);

}

void show2() {

System.out.println(“show2”);

}

protected void show3() {

System.out.println(“show3”);

}

public void show4() {

System.out.println(“show4”);

}

public static void main(String[] args) {

Father f = new Father();

f.show();

f.show2();

f.show3();

f.show4();

}

}

5:常见的修饰符(理解)

(1)分类:

权限修饰符:private,默认,protected,public

状态修饰符:static,final

抽象修饰符: abstract

(2)常见的类及其组成的修饰

类:

默认,public,final,abstract

常用的:public

成员变量:

private,默认,protected,public,static,final

常用的:private

构造方法:

private,默认,protected,public

常用的:public

成员方法:

private,默认,protected,public,static,final,abstract

常用的:public

(3)另外比较常见的:

public static final int X = 10;

public static void show() {}

public final void show() {}

public abstract void show();

/*

修饰符:

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

状态修饰符:static,final

抽象修饰符:abstract

类:

权限修饰符:默认修饰符,public

状态修饰符:final

抽象修饰符:abstract

用的最多的就是:public

成员变量:

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

状态修饰符:static,final

用的最多的就是:private

构造方法:

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

用的最多的就是:public

成员方法:

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

状态修饰符:static,final

抽象修饰符:abstract

用的最多的就是:public

除此以外的组合规则:

成员变量:public static final

成员方法:public static

public abstract

public final

*/

//此处不允许使用修饰符private

//此处不允许使用修饰符protected

//此处不允许使用修饰符static

public class Demo {

//成员变量

private int x = 10;

int y = 20;

protected int z = 30;

public int a = 40;

public final int b = 50;

public static int c = 60;

public static final int d = 70;

//此处不允许使用修饰符abstract

//abstract int e = 80;

//构造方法

private Demo(){}

Demo(String name){}

protected Demo(String name,int age) {}

public Demo(String name,int age,String address) {}

//此处不允许使用修饰符static

//public static Demo(){}

//此处不允许使用修饰符final

//public final Demo() {}

//此处不允许使用修饰符abstract

//public abstract Demo(){}

//成员方法

//static void show() {}

//abstract void show();

//final void show(){}

}

package com.liuyi;

public class Son extends Father {

public static void main(String[] args) {

Father f = new Father();

//f.show();

f.show2();

f.show3();

f.show4();

System.out.println(“————–“);

Son s = new Son();

//s.show();

s.show2();

s.show3();

s.show4();

}

}

package cn.qx;

import com.liuyi.Father;

public class Son2 extends Father {

public static void main(String[] args) {

Father f = new Father();

//f.show();

//f.show2();

//f.show3();

f.show4();

System.out.println(“————–“);

Son2 s = new Son2();

//s.show();

//s.show2();

s.show3();

s.show4();

}

}

package com.liuyi;

public class Test {

public static void main(String[] args) {

Father f = new Father();

//f.show();

f.show2();

f.show3();

f.show4();

}

}

package cn.qx;

import com.liuyi.Father;

class Test2 {

public static void main(String[] args) {

Father f = new Father();

//f.show();

//f.show2();

//f.show3();

f.show4();

}

}

6:内部类(理解)

(1)把类定义在另一个类的内部,该类就被称为内部类。

举例:把类B定义在类A中,类B就被称为内部类。

(2)内部类的访问规则

A:可以直接访问外部类的成员,包括私有

B:外部类要想访问内部类成员,必须创建对象

/*

内部类概述:

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

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

内部的访问特点:

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

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

*/

class Outer {

private int num = 10;

class Inner {

public void show() {

System.out.println(num);

}

}

public void method() {

//找不到符号

//show();

Inner i = new Inner();

i.show();

}

}

class InnerClassDemo {

public static void main(String[] args) {

}

}

(3)内部类的分类

A:成员内部类

B:局部内部类

/*

内部类位置

成员位置:在成员位置定义的类,被称为成员内部类。

局部位置:在局部位置定义的类,被称为局部内部类。

成员位置:在成员位置定义的类,被称为成员内部类。

*/

class Outer {

private int num = 10;

//成员位置

/*

class Inner {

}

*/

public void method() {

//局部位置

class Inner {

}

}

}

class InnerClassDemo2 {

public static void main(String[] args) {

}

}

(4)成员内部类

A:private 为了数据的安全性

B:static 为了访问的方便性

成员内部类不是静态的:

外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

成员内部类是静态的:

外部类名.内部类名 对象名 = new 外部类名.内部类名();

/*

成员内部类:

如何直接访问内部类的成员。

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

*/

class Outer {

private int num = 10;

class Inner {

public void show() {

System.out.println(num);

}

}

}

class InnerClassDemo3 {

public static void main(String[] args) {

//需求:我要访问Inner类的show()方法

//Inner i = new Inner();

//i.show();

//格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;

Outer.Inner oi = new Outer().new Inner();

oi.show();

}

}

/*

成员内部类的修饰符:

private 为了保证数据的安全性

static 为了方便访问数据

注意:静态内部类访问的外部类数据必须用静态修饰。

案例:我有一个人(人有身体,身体内有心脏。)

class Body {

private class Heart {

public void operator() {

System.out.println(“心脏搭桥”);

}

}

public void method() {

if(如果你是外科医生) {

Heart h = new Heart();

h.operator();

}

}

}

按照我们刚才的讲解,来使用一下

Body.Heart bh = new Body().new Heart();

bh.operator();

//加了private后,就不能被访问了,那么,怎么玩呢?

Body b = new Body();

b.method();

*/

class Outer {

private int num = 10;

private static int num2 = 100;

//内部类用静态修饰是因为内部类可以看出是外部类的成员

public static class Inner {

public void show() {

//System.out.println(num);

System.out.println(num2);

}

public static void show2() {

//System.out.println(num);

System.out.println(num2);

}

}

}

class InnerClassDemo4 {

public static void main(String[] args) {

//使用内部类

// 限定的新静态类

//Outer.Inner oi = new Outer().new Inner();

//oi.show();

//oi.show2();

//成员内部类被静态修饰后的访问方式是:

//格式:外部类名.内部类名 对象名 = new 外部类名.内部类名();

Outer.Inner oi = new Outer.Inner();

oi.show();

oi.show2();

//show2()的另一种调用方式

Outer.Inner.show2();

}

}

(5)成员内部类的面试题(填空)

30,20,10

class Outer {

public int num = 10;

class Inner {

public int num = 20;

public viod show() {

int num = 30;

System.out.println(num);

System.out.println(this.num);

System.out.println(Outer.this.num);

}

}

}

/*

面试题:

要求请填空分别输出30,20,10。

注意:

1:内部类和外部类没有继承关系。

2:通过外部类名限定this对象

Outer.this

*/

class Outer {

public int num = 10;

class Inner {

public int num = 20;

public void show() {

int num = 30;

System.out.println(num);

System.out.println(this.num);

//System.out.println(new Outer().num);

System.out.println(Outer.this.num);

}

}

}

class InnerClassTest {

public static void main(String[] args) {

Outer.Inner oi = new Outer().new Inner();

oi.show();

}

}

(6)局部内部类

A:局部内部类访问局部变量必须加final修饰。

B:为什么呢?

因为局部变量使用完毕就消失,而堆内存的数据并不会立即消失。

所以,堆内存还是用该变量,而改变量已经没有了。

为了让该值还存在,就加final修饰。

通过反编译工具我们看到了,加入final后,堆内存直接存储的是值,而不是变量名。

/*

局部内部类

A:可以直接访问外部类的成员

B:在局部位置,可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能

面试题:

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

A:局部内部类访问局部变量必须用final修饰

B:为什么呢?

局部变量是随着方法的调用而调用,随着调用完毕而消失。

而堆内存的内容并不会立即消失。所以,我们加final修饰。

加入final修饰后,这个变量就成了常量。既然是常量。你消失了。

我在内存中存储的是数据20,所以,我还是有数据在使用。

*/

class Outer {

private int num = 10;

public void method() {

//int num2 = 20;

//final int num2 = 20;

class Inner {

public void show() {

System.out.println(num);

//从内部类中访问本地变量num2; 需要被声明为最终类型

System.out.println(num2);//20

}

}

//System.out.println(num2);

Inner i = new Inner();

i.show();

}

}

class InnerClassDemo5 {

public static void main(String[] args) {

Outer o = new Outer();

o.method();

}

}

(7)匿名内部类(掌握)

A:是局部内部类的简化形式

B:前提

存在一个类或者接口

C:格式:

new 类名或者接口名() {

重写方法;

}

D:本质:

其实是继承该类或者实现接口的子类匿名对象

/*

匿名内部类

就是内部类的简化写法。

前提:存在一个类或者接口

这里的类可以是具体类也可以是抽象类。

格式:

new 类名或者接口名(){

重写方法;

}

本质是什么呢?

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

*/

interface Inter {

public abstract void show();

public abstract void show2();

}

class Outer {

public void method() {

//一个方法的时候

/*

new Inter() {

public void show() {

System.out.println(“show”);

}

}.show();

*/

//二个方法的时候

/*

new Inter() {

public void show() {

System.out.println(“show”);

}

public void show2() {

System.out.println(“show2”);

}

}.show();

new Inter() {

public void show() {

System.out.println(“show”);

}

public void show2() {

System.out.println(“show2”);

}

}.show2();

*/

//如果我是很多个方法,就很麻烦了

//那么,我们有没有改进的方案呢?

Inter i = new Inter() { //多态

public void show() {

System.out.println(“show”);

}

public void show2() {

System.out.println(“show2”);

}

};

i.show();

i.show2();

}

}

class InnerClassDemo6 {

public static void main(String[] args) {

Outer o = new Outer();

o.method();

}

}

(8)匿名内部类在开发中的使用

我们在开发的时候,会看到抽象类,或者接口作为参数。

而这个时候,我们知道实际需要的是一个子类对象。

如果该方法仅仅调用一次,我们就可以使用匿名内部类的格式简化。

interface Person {

public abstract void study();

}

class PersonDemo {

public void method(Person p) {

p.study();

}

}

class PersonTest {

public static void main(String[] args) {

PersonDemo pd = new PersonDemo();

pd.method(new Person() {

public void study() {

System.out.println(“好好学习,天天向上”);

}

});

}

}

/*

匿名内部类在开发中的使用

*/

interface Person {

public abstract void study();

}

class PersonDemo {

//接口名作为形式参数

//其实这里需要的不是接口,而是该接口的实现类的对象

public void method(Person p) {

p.study();

}

}

//实现类

class Student implements Person {

public void study() {

System.out.println(“好好学习,天天向上”);

}

}

class InnerClassTest2 {

public static void main(String[] args) {

//测试

PersonDemo pd = new PersonDemo();

Person p = new Student();

pd.method(p);

System.out.println(“——————–“);

//匿名内部类在开发中的使用

//匿名内部类的本质是继承类或者实现了接口的子类匿名对象

pd.method(new Person(){

public void study() {

System.out.println(“好好学习,天天向上”);

}

});

}

}

(9)匿名内部类的面试题(补齐代码)

interface Inter {

void show();

}

class Outer {

//补齐代码

public static Inter method() {

return new Inter() {

public void show() {

System.out.println(“HelloWorld”);

}

};

}

}

class OuterDemo {

public static void main(String[] args) {

Outer.method().show(); //”HelloWorld”

}

}

/*

匿名内部类面试题:

按照要求,补齐代码

interface Inter { void show(); }

class Outer { //补齐代码 }

class OuterDemo {

public static void main(String[] args) {

Outer.method().show();

}

}

要求在控制台输出”HelloWorld”

*/

interface Inter {

void show();

//public abstract

}

class Outer {

//补齐代码

public static Inter method() {

//子类对象 — 子类匿名对象

return new Inter() {

public void show() {

System.out.println(“HelloWorld”);

}

};

}

}

class OuterDemo {

public static void main(String[] args) {

Outer.method().show();

/*

1:Outer.method()可以看出method()应该是Outer中的一个静态方法。

2:Outer.method().show()可以看出method()方法的返回值是一个对象。

又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。

*/

}

}


获取更多免费资源与技术文章,加微信公众号:【Java帮帮】,或者关注【Java帮帮】QQ空间,csdn博客

文章来源:智云一二三科技

文章标题:Java基础-10总结形式参数,包,修饰符,内部类

文章地址:https://www.zhihuclub.com/191522.shtml

关于作者: 智云科技

热门文章

发表回复

您的电子邮箱地址不会被公开。

网站地图