Java基础-10总结形式参数,包,修饰符,内部类-阿里云开发者社区

开发者社区> 奋斗蒙> 正文

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

简介: 你需要的是什么,直接评论留言。 获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦) 还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读 学习交流请加Java帮帮交流QQ群553841695 分享是一种美德,分享更快乐! 类,抽象类,接口的综合小练习 /* 教练和运动员案例(学生分析然后讲解
+关注继续查看

你需要的是什么,直接评论留言。

获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦)

还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读

学习交流请加Java帮帮交流QQ群553841695

分享是一种美德,分享更快乐!


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


/*

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

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

乒乓球教练和篮球教练。

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

请用所学知识:

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

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

*/

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

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

protectedYYY

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帮帮微信公众号



Java帮帮交流群


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Java基础-18总结Map,HashMap,HashMap与Hashtable区别,Collections工具类
你需要的是什么,直接评论留言。 获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦) 还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读 学习交流请加Java帮帮交流QQ群553841695 分享是一种美德,分享更快乐! 1:Map(掌握) (1)将键映射到值的对象。一个映射不能包含重复的键;每个键最多只
2452 0
BLE协议学习总结
最近因工作需要,投入到BLE项目中,故而花了不少时间翻看标准,钻研原理,以求知其所以然。结合平头哥BLE产品,实践验证理论,还是有了不少心得。一直想记录下来,奈何一直忙(给自己找了个理由),哈哈,今天终于下笔,来个小结。当然,如有不准确之处,还望各位同学批评指正。
1964 0
Java基础-02总结关键字,标识符,注释,常量进制,变量数据类型
你需要的是什么,直接评论留言。 获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦) 还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读 学习交流请加Java帮帮交流QQ群553841695 分享是一种美德,分享更快乐! 1:关键字(掌握) (1)被Java语言赋予特定含义的单词(2)特点:全部小写。(3)注意事项:
1353 0
flutter网络dio框架公共请求参数、请求header使用总结
> 本文章将讲述 > 1.get请求中配置公共参数 > 2.post请求配置公共参数 > 3.请求header配置
564 0
Java性能优化之编程技巧总结
1、慎用异常 在Java软件开发中,经常使用 try-catch 进行错误捕获,但是,try-catch 语句对系统性能而言是非常糟糕的。
862 0
java之路,基础知识----内部类
内部类:在类的内部定义另一个类,方便访问外部类的所有的成员。内部类可以嵌套,但是如果定义在方法之内,那么他的作用域就在方法中,出了方法就不能使用了。必须先产生外部类对象,然后产生内部类对象 class out {     private int index = 100;   ...
595 0
Java基础-10总结形式参数,包,修饰符,内部类
你需要的是什么,直接评论留言。 获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦) 还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读 学习交流请加Java帮帮交流QQ群553841695 分享是一种美德,分享更快乐! 类,抽象类,接口的综合小练习 /* 教练和运动员案例(学生分析然后讲解
1141 0
03.Java基础(线程池和Callable<T>)
在以往的工作中,创建线程通常我们关注的都是Thread或者Runnable为主,其实忽略了另外一个比较有用的创建线程的方式,就是Callable接口,下边是Callable配合线程池实现异步任务 import java.
762 0
Apache Flink 零基础入门(七):Table API 编程
本文主要包含三部分:第一部分,主要介绍什么是 Table API,从概念角度进行分析,让大家有一个感性的认识;第二部分,从代码的层面介绍怎么使用 Table API;第三部分,介绍 Table API 近期的动态。
1827 0
《Ansible权威指南 》一 第一篇 Part 1 基础入门篇
“未来主体是传统行业利用互联网技术,以云端用人工智能的方式处理大数据”,在腾讯“云+未来”技术峰会上,马化腾这样形容未来。15年前,电脑还只是少数人的专属,那时的网吧还很火,还没人知道“网咖”是什么。而现在人手一部智能手机,物联网更是让日常生活中的普通家电也能在互联网占据一席之地。
1534 0
+关注
奋斗蒙
Java帮帮,全国领先的IT新媒体,从创立以来一直坚持不懈,把简单学习,快乐学习,高效学习的经营理念,发扬光大;让每一位想要学习,想要凭借自己力量改变未来的人,都能轻松的获取学习资源,从而实现自己的人生价值。
44
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载