一,final关键字
1.final修饰类,该类不能被继承,
2.final修饰成员方法,该方法不能重写.
3.final修饰类的成员变量,该变量的值不能改变,
4.final修饰局部变量:
a,若该局部变量的类型为基本数据类型,该变量的值不能被改变.
b,若该变量的类型为引用类型,那么它不能再次被分配堆内存空间,但是该变量的值可以改变.
#当final修饰变量时,需要在对象创建创建之前进行初始化这个值:
a,构造代码块中进行初始化
b,构造方法中进行初始化
c,定义成员变量的时候,可以直接进行初始化.
注意:这三种方式只能同时使用一种.
#final修饰局部变量的综合应用:
packageDay_08_01;
public classFinalXiuShi {
intage;
public static voidmain(String[] args) {
/*intn=100;
n=200;
System.out.println(n);*/
final intn=100;
/*n=200;*/ //该变量被final修饰,其值不会发生改变
/*System.out.println(n);
System.out.println("---------------");*/
/* FinalXiuShifl=newFinalXiuShi();
fl.age=200;
System.out.println(fl.age);
System.out.println("---------------");*/
finalFinalXiuShi fl=newFinalXiuShi();//final修饰的是fl引用类型
fl.age=200;
fl.age=120;//当final修饰引用类型时,其值可以改变
System.out.println(fl.age);
System.out.println("---------------");
}
}
二:多态;
1. 对于多态的三个前提条件
1) 条件1:必须有继承关系(如果没有继承关系,谈不上多态!)
2) 条件2:必须有方法重写
3) 有父类引用指向子类对象:向上转型
Fu f = new Zi() ;
#多态的三个条缺一不可!
2. 多态的成员访问特点:
成员变量:编译看左边,执行看左边.
成员方法(非静态):编译看左边,执行看右边,由于存在方法重写,所以执行的是子类的成员方法,会将父类中同名的方法覆盖掉.
构造方法:还是对象进行初始化,由于是一种继承关系,还是分层初始化.
成员方法(静态):编译看左,执行看左,由于static随着类加载而加载,所以与类有关,与对象无关,也就不存在方法重写.
3. 多态的好处:
(1) 提高代码的维护性(有继承保证)
(2) 提高代码的扩展性(有多态保证)
#扩展性的综合应用:
packageDay_01_DuoTai;
public classKuoZhan {
public static voidmain(String[] args) {
Teacher te=newTeacher();
ITit=newIT ();
System.out.println("--------------");
PersonTools.UseWork(te);
PersonTools.UseWork(it);
}
}
classPerson{
public voidWork(){
System.out.println("人每天需要上班");
}
}
classTeacherextendsPerson{
public voidWork(){
System.out.println("老师需要站着上班");
}
}
classITextendsPerson{
public voidWork(){
System.out.println("程序员每天需要坐着上班");
}
}
classPersonTools{//将Teacher类和IT类中的方法封装在一个类中
private voidPersonTools(){//对构造方法进行私有化,防止外界创建对象
}
public static voidUseWork(Person a){//该方法定义为static修饰,直接用类名调用
a.Work();
}
}
4. 多态的弊端
(1) 不能访问子类的特有方法
解决方法:(1)创建子类的具体对象,来访问自己的特有功能,虽然可以解决多态的弊端,但是从内存角度考虑,需要创建子类对象,那么必须在堆和栈内开辟空间,浪费内存,不建议这么做.
#多态成员访问的综合应用:
packageDay_01_DuoTai;
public classKongZiZhuangDie {
public static voidmain(String[] args) {
Father fu=newKongZi();//向上转型:有父类的引用指向子类的对象
System.out.println("输出的年龄为:" + fu.age);//多态中成员变量的访问:编译看左,执行看左,所以打印出Father的年龄
System.out.println("讲课的内容为:" );
fu.Teacher();//因为多态中,存在方法重写,当通过子类对象访问相同方法时,子类的方法会覆盖父类的方法,所以编译看左,执行看右
System.out.println("--------------");
KongZi zi=(KongZi)fu;//向下转型:父类的引用强制转换为子类的引用,(前提是必须有向上转型):可以通过子类的引用调用子类的特有方法.
System.out.println("孔子还会玩:");
zi.Play();
}
}
classFather {
public intage=40;
public voidTeacher(){
System.out.println("孔子爹讲国语");
}
}
classKongZiextendsFather{
public intage=26;
public voidTeacher(){
System.out.println("孔子讲论语");
}
public voidPlay(){
System.out.println("孔子会玩游戏");
}
}
5. 异常
(1) 向下转型使用不当会出现一个异常:class cast exception
(2) 数组角标越界异常:Array Pointer Exception
(3)空指针异常(解决方案:给对象做非空判断 if(对象名 != null) {给对象进行操作}):Null Pointer Exception
6.抽象类
(1)概念: 1.每一个动物的吃和睡的功能不一样,不应该把动物类定义为一个具体类,而是给出一个声明(abstract)
(2) 当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类!(一个类中既可以有抽象方法,也可以有非抽象方法)
(3) 抽象类的子类的特点: 抽象类的子类是抽象类,那么没有意义! 最终使用的就是通过子类进行对象初始化的,如果子类都被抽象修饰了,那么也不能创建对象,所以没意义
抽象类多态: 强制子类必须重写当前抽象的父类中所有的抽象方法
* 还可以提高代码的维护性(里面继承关系保证!)
#抽象类不能实例化:抽象类不能创建对象
抽象类如何进行实例化: 通过抽象类多态形式:父类的引用指向子类对象,通过子类进行初始化!
(3) 抽象类成员特点:
a, 成员变量:可以是变量也可以是自定义常量.
b, 构造方法:抽象类可以有构造方法,包括有参构造和无参构造.
作用:通过抽象类多态的形成,让子类进行数据的初始化.
#:abstract不能与以下关键字共同使用:
Private finalstatic
#抽象类与多态的综合应用:
packageDay_01_DuoTai;
public classChouXiangLei {
public static voidmain(String[] args) {
Employee sc=newIT2("王抢","9527",2000);//向上转型:父类的引用指向子类的对象
IT2 it=(IT2)sc;//向下转型:父类的引用强制转换为子类的引用
it.GetInformation();//通过子实现类的对象调用子类的特有方法
it.work();//通过子实现类的对象调用子类的特有方法
System.out.println("----------------");
Employee an=newManager("上官万成","9528",2000,50);
Manager mg =(Manager)an;
mg.GetInformation();
mg.work();
}
}
abstract classEmployee{//一个类中有抽象方法时,该类一定是抽象方法,抽象类中可以没有抽象方法
publicString name;
publicString number;
public intsalary;
publicEmployee() {
super();
//TODO自动生成的构造函数存根
}
publicEmployee(String name, String number,intsalary) {
super();
this.name = name;
this.number = number;
this.salary = salary;
}
publicString getName() {
returnname;
}
public voidsetName(String name) {
this.name = name;
}
publicString getNumber() {
returnnumber;
}
public voidsetNumber(String number) {
this.number = number;
}
public intgetSalary() {
returnsalary;
}
public voidsetSalary(intsalary) {
this.salary = salary;
}
public abstract voidwork();
}
classIT2extendsEmployee{
publicIT2() {
super();
//TODO自动生成的构造函数存根
}
publicIT2(String name, String number,intsalary) {
super();
this.name = name;
this.number = number;
this.salary = salary;
}
public voidsetName(String name) {
this.name = name;
}
publicString getName() {
returnname;
}
public voidsetNumber(String number) {
this.number = number;
}
publicString getNumber() {
returnnumber;
}
public voidsetSalary(intsalary) {
this.salary = salary;
}
public intgetSalary() {
returnsalary;
}
voidGetInformation(){
System.out.println(this.name + "的编号是:" +this.number + ";它的工资是:" +this.salary );
}
@Override
public voidwork() {
System.out.println("程序员每天敲代码");//TODO自动生成的方法存根
}
}
classManagerextendsEmployee{
public intbonus;
publicManager() {
super();
//TODO自动生成的构造函数存根
}
publicManager(String name, String number,intsalary,intbonus) {
super();
this.name = name;
this.number = number;
this.salary = salary;
this.bonus = bonus;
}
public voidsetName(String name) {
this.name = name;
}
publicString getName() {
returnname;
}
public voidsetNumber(String number) {
this.number = number;
}
publicString getNumber() {
returnnumber;
}
public voidsetSalary(intsalary) {
this.salary = salary;
}
public intgetSalary() {
returnsalary;
}
public voidsetBonus(intbonus) {
this.bonus = bonus;
}
public intgetBonus() {
returnbonus;
}
@Override
public voidwork() {
System.out.println("经理每天待办公室");//TODO自动生成的方法存根
}
voidGetInformation(){
System.out.println(this.name + "的编号是:" +this.number + ";它的工资是:" +this.salary );
}
}
7.接口
(1) 概念: 接口体现的是一种:扩展功能;
(2) 如何表示接口: interface 接口名{ }
a. 接口里面的方法只能是抽象方法
b. 接口中不能有构造方法
c. 接口不能实例化(不能直接创建对象)
d. 接口的实例化:就是通过子实现类对数据进行初始化!
接口的子实现类: 1)接口的子实现类是抽象类,没有意义,子类都不能创建对象了;实际开发中用的就是子类的对象进行初始化!
2) 接口的子实现类是非抽象类
(3)接口的子实现类和接口的关系:implements
Class 子实现类 implements 接口名{ }
(4)接口成员的特点:
a.成员变量: 只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)
b.构造方法: 接口是没有构造方法的
c.成员方法: 接口中的成员方法默认修饰符:public abstract(永远建议自己给出默认修饰符)
(5)类与接口之间的相互联系
a. 类与类的关系: 继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!
b. 类与接口的关系: 实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口
(class 子实现类名 enxtends Object implements 接口名1,接口名2...)
a. 接口与接口的关系: 继承关系:extends,可以支持单继承,也可以多继承!
(5)接口与抽象类的区别:
a.成员的区别
成员变量: 抽象类:可以是变量也可以是自定义常量
接口:只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)
构造方法: 抽象类:可以有无参构造和有参构造.作用:通过子类进行数据的初始化
接口:没有构造方法
成员方法的区别: 抽象类:可以是抽象方法也可以是非抽象方法
接口:只能是抽象方法.且存在默认修饰符(abstract)
b, 关系的区别: 类与类的关系:继承关系,extends----java中只支持单继承,不支持多继承,但可以多层继承.
类与接口的关系:实现关系,implements----一个类在继承另一个类的同时,可以实现多个接口(class 子实现类名 extends object implements 接口1,接口2.......)
接口与接口的关系:继承关系,可以支持单继承,也可以支持多继承.
c. 设计原理的区别:
抽象类:体现的是一种"is-a"的关系,存在继承关系(抽象类多态)
接口:体现的是一种"like-a"的关系,由于接口的一种扩展功能.
#一个类的无参构造私有化之后,不能创建对象,也不能通过(对象名.方法())进行调用,此时,应将方法用static修饰,应此需要用(类名.方法())直接调用.
#老师和学生案例,加入抽烟的额外功能自己分析成员:
测试类:packageday_01_Smokeing;
public classSmokeingDemo {
public static voidmain(String[] args) {
System.out.println("-----------以下是通过接口的具体类对象形式进行调用子实现类的方法");
TeacherSmoking ts=newTeacherSmoking();//此时的TeacherSmoking是一个具体的类,它包含的功能最多,可以直接用该类创建对象,用对象直接调用方法
ts.setAge(32);
ts.setName("王抢");
ts.setOccupation("小导员");
ts.GetInformation();
ts.work();
ts.Smoking();
ts.Smoke();
//TODO自动生成的方法存根
}
}
Person类:packageday_01_Smokeing;
public abstract classPerson {
public intage;
publicString name;
publicPerson() {
super();
//TODO自动生成的构造函数存根
}
publicPerson(intage, String name) {
super();
this.age = age;
this.name = name;
}
public voidsetAge(intage) {
this.age = age;
}
public intgetAge() {
returnage;
}
public voidsetName(String name) {
this.name = name;
}
publicString getName() {
returnname;
}
public abstract voidSmoking();
}
Teacher类:packageday_01_Smokeing;
classTeacherextendsPerson {
public intage;
publicString name;
publicString occupation;
publicTeacher() {
//TODO自动生成的构造函数存根
}
publicTeacher(intage, String name, Stringoccupation) {
super();
this.age = age;
this.name = name;
this.occupation = occupation;
}
public voidsetAge(intage) {
this.age = age;
}
public intgetAge() {
returnage;
}
public voidsetName(String name) {
this.name = name;
}
publicString getName() {
returnname;
}
public voidsetOccupation(String occupation) {
this.occupation = occupation;
}
publicString getOccupation() {
returnoccupation;
}
public voidwork(){
System.out.println("老师工作负责教学生");
}
@Override
public voidSmoking() {
System.out.println("老师比学生早抽烟");
//TODO自动生成的方法存根
}
public voidGetInformation(){
System.out.println(this.name + "在" +this.age + "岁的时候开始抽烟");
}
}
Student类:packageday_01_Smokeing;
classStudentextendsPerson {
public intage;
publicString name;
publicString occupation;
publicStudent() {
//TODO自动生成的构造函数存根
}
publicStudent(intage, String name, Stringoccupation) {
super();
this.age = age;
this.name = name;
this.occupation = occupation;
}
public voidsetAge(intage) {
this.age = age;
}
public intgetAge() {
returnage;
}
public voidsetName(String name) {
this.name = name;
}
publicString getName() {
returnname;
}
public voidsetOccupation(String occupation) {
this.occupation = occupation;
}
publicString getOccupation() {
returnoccupation;
}
public voidwork(){
System.out.println("学生的任务就是每天学习");
}
public voidGetInformation(){
System.out.println(this.name + "在" +this.age + "岁的时候开始抽烟");
}
@Override
public voidSmoking() {
System.out.println("学生普遍在小学的时候开始抽烟");
//TODO自动生成的方法存根
}
}
接口类:packageday_01_Smokeing;
public interfaceSmoke {
public voidSmoke();//接口中的方法只能是抽象方法,且存在默认修饰符:abstract
}
子实现类:packageday_01_Smokeing;
public classTeacherSmokingextendsTeacherimplementsSmoke {
publicTeacherSmoking() {
//TODO自动生成的构造函数存根
}
publicTeacherSmoking(intage, Stringname, String occupation) {
super(age, name, occupation);
//TODO自动生成的构造函数存根
}
@Override
public voidSmoke() {
System.out.println("老师学会抽烟呢");
//TODO自动生成的方法存根
}
}
8.API文档的制作:
#关于数组的自定义类:
(1)测试类:packageday_01_APIDemo;
/**
*@authorLenovo
*@version1.0
*
* */
public classApiDemo {
public static voidmain(String[] args) {
int[] array={26,9,16,24,62,56};
intan=ArraysTools .GetMax(array);
inta=ArraysTools .PrintArray(array, 56);
System.out.println("该数组的最大值为:" + an);
System.out.println("传入数的下标为:" + a);
//TODO自动生成的方法存根
}
}
(2)数组工具类
packageday_01_APIDemo;
/**该类是定义的一个数组工具类
*@authorLenovo
*@version1.0
*
* */
public classArraysTools {
privateArraysTools() {//将该构造方法私有化,防止外界创建对象访问它.
super();
//TODO自动生成的构造函数存根
}
/**
*@paramarray:需要求最大值的数组
*
* */
public static intGetMax(int[]array){
intmax=array[0];
for(inti=0;i<array.length;i++){
if(array[i]>array[0]){
max=array[i];
break;
}
}
returnmax;
}
/**
*@paramarray:需要求数组下标的原始数组
*@paramvalue:该数组中元素的下标
*@return:以形参传入该方法,若数组中找到该元素,则返回该元素的下标,若没有找到,则返回默认值-1;
*
* */
public static intPrintArray(int[]array,intvalue){
intindex=-1;
for(inti=0;i<array.length;i++){
if(array[i]==value){
index=i;
break;
}
}
returnindex;
}
}
9. 形式参数和返回值问题研究:
(1)形式参数:
基本数据类型:需要什么数据类型,在实际传参的时候就传什么数据类型;形式参数的改变对实际参数没有影响(String是引用类型和基本数据类型的效果一样Strings ="abc")
引用类型: 具体类:如果形式参数是一个具体类,需要创建该类的对象.
抽象类: 如果形式参数是抽象类,需要创建一个抽象类的子类来进行实例化.
接口:如果一个方法的形式参数是一个接口,需要创建该接口的子实现类,然后通过接口多态的形式给接口进行初始化;
(2) 返回值:
具体类: 直接返回该类对象(通常实际开发中使用的是匿名对象)
抽象类: 返回值如果是抽象类,需要的返回是该抽象类的子类对象
接口:如果一个方法的返回值类型为接口时,需要返回的是该接口的子实现类的对象
#形式参数是抽象类的综合应用:
packageday_01_XingCan;
public classChouXiangLei {
public static voidmain(String[] args) {
System.out.println("----------以下是创建AnimalDemo类的具体对象,直接调用Method方法");
AnimalDemo ad=newAnimalDemo();
ad.method(newBirdie());
System.out.println("----------以下是链式编程");
newAnimalDemo().method(newBirdie());//链式编程
}
}
abstract classAnimal{
public abstract voidEat();
}
classAnimalDemo{
public voidmethod(Animal an){//当形式参数是抽象类时,需要创建子实现类的具体对象:Animal an1=new Birdie();
an.Eat();//因为存在方法重写,所以此对象调用的是子类的方法
}
}
classBirdieextendsAnimal{
Birdie() {
super();
//TODO自动生成的构造函数存根
}
@Override
public voidEat() {
System.out.println("小鸟饿了,会找虫子吃");
//TODO自动生成的方法存根
}
}
#形式参数是接口时的综合应用:
packageday_01_XingCan;
public classJieKou {
public static voidmain(String[] args) {
System.out.println("------------通过具体类的对象,将接口类多态进行传参");
JieKouDemo jd=newJieKouDemo();//通过创建JieKouDemo类的具体对象,之后直接调用Method方法
jd.Method(newStudent());//当一个方法的参数是接口时,需要创建该接口的子实现类的对象,也就是接口类多态的形式:sleep s=new Student();
System.out.println("------------链式编程");
newJieKouDemo().Method(newStudent());
//TODO自动生成的方法存根
}
}
interfacesleep{
public abstract voidsleep();
}
classJieKouDemo{
public voidMethod(sleep s){
s.sleep();
}
}
classStudentimplementssleep{
@Override
public voidsleep() {
System.out.println("学生学习一天之后,需要早点休息");
//TODO自动生成的方法存根
}
}
#返回值是抽象类的综合应用:
packageday_01_FanHuiZhi;
public classChouXiangLei {
public static voidmain(String[] args) {
ChouXiangLeiDemo cld=newChouXiangLeiDemo();//创建ChouXiangLeiDemo该类的具体对象
cld.method().life();//实际是创建 Person p=newTeather();多态的形式;
System.out.println("------------以下是链式编程");
newChouXiangLeiDemo().method().life();
//TODO自动生成的方法存根
}
}
abstract classPerson{
public abstract voidlife();
}
classChouXiangLeiDemo{
publicPerson method(){//该方法的返回值是一个抽象类
return newTeather();//需要创建该抽象类的子实现类,直接返回抽象类的子类的对象
}
}
classTeatherextendsPerson{
@Override
public voidlife() {
System.out.println("老师的生活很丰富");
//TODO自动生成的方法存根
}
}
#返回值是接口的综合应用:
packageday_01_FanHuiZhi;
public classJieKou {
public static voidmain(String[] args) {
System.out.println("以下是创建JieKouDemo类的具体对象,直接调用该方法");
JieKouDemo jkd=newJieKouDemo();
jkd.method().Eat();
System.out.println("以下是链式编程");
newJieKouDemo().method().Eat();
//TODO自动生成的方法存根
}
}
interfaceSpeak{
public abstract voidEat();
}
classJieKouDemo{
publicSpeak method(){
return newStudent();
}
}
classStudentimplementsSpeak{
@Override
public voidEat() {
System.out.println("学生饿了,需要吃营养餐");
//TODO自动生成的方法存根
}
}
10.内部类
:在一个类中定义的另一个类;
a. 内部类可以访问外部内的成员,包括私有.
b. 外部内想要访问内部类的成员,必须通过创建内部类的对象,通过对象访问内部类的成员方法.
分类:1.成员内部类:在外部类的成员位置定义的另一个类
2.局部内部类:在外部类的局部位置定义的另一个类
(1).成员内部类(非静态):
在测试类中需要访问成员内部类中的成员的方法:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
例: Body.Inner bo = new Body().newInner() ;
#成员内部类的成员方法访问的综合应用:
packageday_01_NeiBuLei;
public classCeShiLei {
public static voidmain(String[] args) {
System.out.println("--------------");
Person.Animal pa=newPerson().newAnimal();//内部类访问外部类的成员,调用内部类的成员方法
pa.speak();
System.out.println("--------------");
Person p=newPerson();//创建外部类的对象,直接调用外部类的成员方法,然后在此方法中创建内部类的对象,通过内部类的对象访问内部类的成员方法
p.talk();
//TODO自动生成的方法存根
}
}
classPerson{
private intage=34;//外部类的私有成员变量
String name="王抢";//外部类的成员变量
classAnimal{
public voidspeak(){
intage2=33;//内部类的成员变量
Stringname2="上官万成";//内部类的成员变量
System.out.println(name + "的年龄是" + age);//内部类可以访问外部类的成员,包括私有.
}
}
public voidtalk(){
Animal a=newAnimal();
a.speak();
}
}
成员内部类的修饰符:
private:为了保证数的安全性
static修饰:为了方便调用(如果成员内部类被static修饰,那么要访问外部类的成员变量,这个变量必须被static修饰)
静态的成员内部类访问该类中的成员方法:
格式:外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
例: Outer4.Inner4 oi = newOuter4.Inner4() ;
#静态成员内部类访问外部成员的综合应用:
packageday_01_NeiBuLei;
public classJingTaiCe {
public static voidmain(String[] args) {
System.out.println("-----------");
Animal.ChuSheng cs=newAnimal.ChuSheng();//该内部类被static修饰,要访问外部类的成员变量,必须要被static修饰
cs.work();//静态内部类的非静态方法
cs.show();//静态内部类的静态方法
//TODO自动生成的方法存根
}
}
classAnimal{
public staticStringname="王抢";//外部类的成员变量需要被static修饰
public static intage=35;//外部类的成员变量需要被static修饰
static classChuSheng{
public static voidshow(){
System.out.println(name+ "的年龄为:" +age);
}
public voidwork(){
System.out.println(name+ "工作为学校卖命");
}
}
}
(3) 局部内部类: 定义在外部类的局部位置
Question:当局部内部类访问外部类的局部变量时,需要加final修饰,不然会报错
事由于局部变量时随着方法调用而产生的,随着调用完毕而消失,而现在局部位置有一个局部内部类,它主要在自己的成员方法位置访问当前的局部变量,必须把变量编程一个常量(需要通过final修饰,自定义常量)这样的一个变量的值永远是固定的.
#局部内部类访问局部变量的综合应用:
packageday_01_jubuneibulei;
public classJuBuCeShi {
public static voidmain(String[] args) {
Occupation oc=newOccupation();//创建外部类的对象,直接调用外部类的成员方法
oc.method();
//TODO自动生成的方法存根
}
}
classOccupation{
privateString vary="teacher";
publicString vary2="student";
public voidmethod(){
finalString vary3="singer";//外部类的局部变量必须要被final修饰
classPerson{
public voidwork(){
System.out.println("学校的工作只要" + vary+ "和" + vary2);
System.out.println("学校的工作不需要" + vary3);//局部类中访问外部类的局部变量,次变量需要加final修饰
}
}
Person p=newPerson();//创建局部内部类的对象,
p.work();//直接调用局部内部类的方法
}
}
11.匿名内部类:是内部类的简化形式
前提条件:必须存在一个接口或者是一个类(可以是具体类,也可以是抽象类)
书写格式:new 接口名或者类名(){方法重写}
匿名内部类的实质:继承了该类(抽象类)或者实现了该接口的子实现类
#匿名内部类的综合应用:
packageNiMing;
public classNiMing {
public static voidmain(String[] args) {
//TODO自动生成的方法存根
NiMIngDemo.method().Run();//用NiMIngDemo类名直接调用Method方法,返回一个接口的对象,然后用接口对象直接调用Run()方法
}
}
interfaceInter{//匿名内部类必须存在一个接口或者一个类
public abstract voidRun();
}
classNiMIngDemo{
public staticInter method(){//该方法的返回值是一个接口
return newInter(){//相当于创建了接口多态的形式:Interi=newInter();
@Override
public voidRun() {//重写了接口中的方法
System.out.println("狗急跳墙");
//TODO自动生成的方法存根
}
};//return后面的代码实质是返回了一个接口对象
}
}
#匿名内部类与接口多态形式调用方法:
packageNiMing;
public classNiMingCeShi {
public static voidmain(String[] args) {
//TODO自动生成的方法存根
System.out.println("-------------通过创建接口的子实现类来访问方法");
inter1 tt=newPerson();
tt.Entertain();
System.out.println("-----------通过匿名内部类调用方法");
NiMingCeShiDemo ncd=newNiMingCeShiDemo();
ncd.method(newinter1(){
@Override
public voidEntertain() {
System.out.println("我的生活中会选择健身来休闲");
//TODO自动生成的方法存根
}
});
}
}
interfaceinter1{
public abstract voidEntertain();
}
classNiMingCeShiDemo{
public voidmethod(inter1 t){
t.Entertain();
}
}
classPersonimplementsinter1{//通过创建接口的子实现类
@Override
public voidEntertain() {
System.out.println("我的生活中会选择健身,打球,玩吉他来休闲");
//TODO自动生成的方法存根
}
