一,final关键字
1. final修饰类,该类不能被继承,
2. final修饰成员方法,该方法不能重写.
3. final修饰类的成员变量,该变量的值不能改变,
4. final修饰局部变量:
a,若该局部变量的类型为基本数据类型,该变量的值不能被改变.
b,若该变量的类型为引用类型,那么它不能再次被分配堆内存空间,但是该变量的值可以改变.
#当final修饰变量时,需要在对象创建创建之前进行初始化这个值:
a,构造代码块中进行初始化
b,构造方法中进行初始化
c,定义成员变量的时候,可以直接进行初始化.
注意:这三种方式只能同时使用一种.
#final修饰局部变量的综合应用:
packageDay_08_01;
public class FinalXiuShi {
int age;
public static void main(String[] args) {
/*int n=100;
n=200;
System.out.println(n);*/
final int n=100;
/*n=200;*/ //该变量被final修饰,其值不会发生改变
/*System.out.println(n);
System.out.println("---------------");*/
/* FinalXiuShi fl=newFinalXiuShi();
fl.age=200;
System.out.println(fl.age);
System.out.println("---------------");*/
final FinalXiuShi fl=new FinalXiuShi();//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 class KuoZhan {
public static void main(String[] args) {
Teacher te=new Teacher();
IT it=new IT ();
System.out.println("--------------");
PersonTools.UseWork(te);
PersonTools.UseWork(it);
}
}
class Person{
public void Work(){
System.out.println("人每天需要上班");
}
}
class Teacher extends Person{
public void Work(){
System.out.println("老师需要站着上班");
}
}
class IT extends Person{
public void Work(){
System.out.println("程序员每天需要坐着上班");
}
}
class PersonTools{//将Teacher类和IT类中的方法封装在一个类中
private void PersonTools(){//对构造方法进行私有化,防止外界创建对象
}
public static void UseWork(Person a){//该方法定义为static修饰,直接用类名调用
a.Work();
}
}
4. 多态的弊端
(1) 不能访问子类的特有方法
解决方法:(1)创建子类的具体对象,来访问自己的特有功能,虽然可以解决多态的弊端,但是从内存角度考虑,需要创建子类对象,那么必须在堆和栈内开辟空间,浪费内存,不建议这么做.
#多态成员访问的综合应用:
packageDay_01_DuoTai;
public class KongZiZhuangDie {
public static void main(String[] args) {
Father fu=new KongZi();//向上转型:有父类的引用指向子类的对象
System.out.println("输出的年龄为:" + fu.age);//多态中成员变量的访问:编译看左,执行看左,所以打印出Father的年龄
System.out.println("讲课的内容为:" );
fu.Teacher();//因为多态中,存在方法重写,当通过子类对象访问相同方法时,子类的方法会覆盖父类的方法,所以编译看左,执行看右
System.out.println("--------------");
KongZi zi=(KongZi)fu;//向下转型:父类的引用强制转换为子类的引用,(前提是必须有向上转型):可以通过子类的引用调用子类的特有方法.
System.out.println("孔子还会玩:");
zi.Play();
}
}
class Father {
public int age=40;
public void Teacher(){
System.out.println("孔子爹讲国语");
}
}
class KongZi extends Father{
public int age=26;
public void Teacher(){
System.out.println("孔子讲论语");
}
public void Play(){
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 class ChouXiangLei {
public static void main(String[] args) {
Employee sc=new IT2("王抢","9527",2000);//向上转型:父类的引用指向子类的对象
IT2 it=(IT2)sc;//向下转型:父类的引用强制转换为子类的引用
it.GetInformation();//通过子实现类的对象调用子类的特有方法
it.work();//通过子实现类的对象调用子类的特有方法
System.out.println("----------------");
Employee an=new Manager("上官万成","9528",2000,50);
Manager mg =(Manager)an;
mg.GetInformation();
mg.work();
}
}
abstract class Employee{//一个类中有抽象方法时,该类一定是抽象方法,抽象类中可以没有抽象方法
public String name;
public String number;
public int salary;
public Employee() {
super();
// TODO自动生成的构造函数存根
}
public Employee(String name, String number, int salary) {
super();
this.name = name;
this.number = number;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public abstract void work();
}
class IT2 extends Employee{
public IT2() {
super();
// TODO自动生成的构造函数存根
}
public IT2(String name, String number, int salary) {
super();
this.name = name;
this.number = number;
this.salary = salary;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setNumber(String number) {
this.number = number;
}
public String getNumber() {
return number;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getSalary() {
return salary;
}
void GetInformation(){
System.out.println(this.name + "的编号是:" + this.number + ";它的工资是:" + this.salary );
}
@Override
public void work() {
System.out.println("程序员每天敲代码");// TODO自动生成的方法存根
}
}
class Manager extends Employee{
public int bonus;
public Manager() {
super();
// TODO自动生成的构造函数存根
}
public Manager(String name, String number, int salary, int bonus) {
super();
this.name = name;
this.number = number;
this.salary = salary;
this.bonus = bonus;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setNumber(String number) {
this.number = number;
}
public String getNumber() {
return number;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getSalary() {
return salary;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
public int getBonus() {
return bonus;
}
@Override
public void work() {
System.out.println("经理每天待办公室");// TODO自动生成的方法存根
}
void GetInformation(){
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 class SmokeingDemo {
public static void main(String[] args) {
System.out.println("-----------以下是通过接口的具体类对象形式进行调用子实现类的方法");
TeacherSmoking ts=new TeacherSmoking();//此时的TeacherSmoking是一个具体的类,它包含的功能最多,可以直接用该类创建对象,用对象直接调用方法
ts.setAge(32);
ts.setName("王抢");
ts.setOccupation("小导员");
ts.GetInformation();
ts.work();
ts.Smoking();
ts.Smoke();
// TODO自动生成的方法存根
}
}
Person类: package day_01_Smokeing;
public abstract class Person {
public int age;
public String name;
public Person() {
super();
// TODO自动生成的构造函数存根
}
public Person(int age, String name) {
super();
this.age = age;
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public abstract void Smoking();
}
Teacher类: package day_01_Smokeing;
class Teacher extends Person {
public int age;
public String name;
public String occupation;
public Teacher() {
// TODO自动生成的构造函数存根
}
public Teacher(int age, String name, Stringoccupation) {
super();
this.age = age;
this.name = name;
this.occupation = occupation;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setOccupation(String occupation) {
this.occupation = occupation;
}
public String getOccupation() {
return occupation;
}
public void work(){
System.out.println("老师工作负责教学生");
}
@Override
public void Smoking() {
System.out.println("老师比学生早抽烟");
// TODO自动生成的方法存根
}
public void GetInformation(){
System.out.println(this.name + "在" + this.age + "岁的时候开始抽烟");
}
}
Student类: package day_01_Smokeing;
class Student extends Person {
public int age;
public String name;
public String occupation;
public Student() {
// TODO自动生成的构造函数存根
}
public Student(int age, String name, Stringoccupation) {
super();
this.age = age;
this.name = name;
this.occupation = occupation;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setOccupation(String occupation) {
this.occupation = occupation;
}
public String getOccupation() {
return occupation;
}
public void work(){
System.out.println("学生的任务就是每天学习");
}
public void GetInformation(){
System.out.println(this.name + "在" + this.age + "岁的时候开始抽烟");
}
@Override
public void Smoking() {
System.out.println("学生普遍在小学的时候开始抽烟");
// TODO自动生成的方法存根
}
}
接口类: packageday_01_Smokeing;
public interface Smoke {
public void Smoke();//接口中的方法只能是抽象方法,且存在默认修饰符:abstract
}
子实现类: packageday_01_Smokeing;
public class TeacherSmoking extends Teacher implements Smoke {
public TeacherSmoking() {
// TODO自动生成的构造函数存根
}
public TeacherSmoking(int age, Stringname, String occupation) {
super(age, name, occupation);
// TODO自动生成的构造函数存根
}
@Override
public void Smoke() {
System.out.println("老师学会抽烟呢");
// TODO自动生成的方法存根
}
}
8.API文档的制作:
#关于数组的自定义类:
(1)测试类: package day_01_APIDemo;
/**
* @author Lenovo
* @version 1.0
*
* */
public class ApiDemo {
public static void main(String[] args) {
int [] array={26,9,16,24,62,56};
int an=ArraysTools .GetMax(array);
int a=ArraysTools .PrintArray(array, 56);
System.out.println("该数组的最大值为:" + an);
System.out.println("传入数的下标为:" + a);
// TODO自动生成的方法存根
}
}
(2)数组工具类
packageday_01_APIDemo;
/**该类是定义的一个数组工具类
* @author Lenovo
* @version 1.0
*
* */
public class ArraysTools {
private ArraysTools() {//将该构造方法私有化,防止外界创建对象访问它.
super();
// TODO自动生成的构造函数存根
}
/**
* @param array:需要求最大值的数组
*
* */
public static int GetMax(int []array){
int max=array[0];
for(int i=0;i<array.length;i++){
if(array[i]>array[0]){
max=array[i];
break;
}
}
return max;
}
/**
* @param array:需要求数组下标的原始数组
* @param value:该数组中元素的下标
* @return:以形参传入该方法,若数组中找到该元素,则返回该元素的下标,若没有找到,则返回默认值-1;
*
* */
public static int PrintArray(int []array,int value){
int index=-1;
for(int i=0;i<array.length;i++){
if(array[i]==value){
index=i;
break;
}
}
return index;
}
}
9. 形式参数和返回值问题研究:
(1)形式参数:
基本数据类型:需要什么数据类型,在实际传参的时候就传什么数据类型;形式参数的改变对实际参数没有影响(String是引用类型和基本数据类型的效果一样Strings ="abc")
引用类型: 具体类:如果形式参数是一个具体类,需要创建该类的对象.
抽象类: 如果形式参数是抽象类,需要创建一个抽象类的子类来进行实例化.
接口:如果一个方法的形式参数是一个接口,需要创建该接口的子实现类,然后通过接口多态的形式给接口进行初始化;
(2) 返回值:
具体类: 直接返回该类对象(通常实际开发中使用的是匿名对象)
抽象类: 返回值如果是抽象类,需要的返回是该抽象类的子类对象
接口:如果一个方法的返回值类型为接口时,需要返回的是该接口的子实现类的对象
#形式参数是抽象类的综合应用:
packageday_01_XingCan;
public class ChouXiangLei {
public static void main(String[] args) {
System.out.println("----------以下是创建AnimalDemo类的具体对象,直接调用Method方法");
AnimalDemo ad=new AnimalDemo();
ad.method(new Birdie());
System.out.println("----------以下是链式编程");
new AnimalDemo().method(new Birdie());//链式编程
}
}
abstract class Animal{
public abstract void Eat();
}
class AnimalDemo{
public void method(Animal an){//当形式参数是抽象类时,需要创建子实现类的具体对象:Animal an1=new Birdie();
an.Eat();//因为存在方法重写,所以此对象调用的是子类的方法
}
}
class Birdie extends Animal{
Birdie() {
super();
// TODO自动生成的构造函数存根
}
@Override
public void Eat() {
System.out.println("小鸟饿了,会找虫子吃");
// TODO自动生成的方法存根
}
}
#形式参数是接口时的综合应用:
packageday_01_XingCan;
public class JieKou {
public static void main(String[] args) {
System.out.println("------------通过具体类的对象,将接口类多态进行传参");
JieKouDemo jd=new JieKouDemo();//通过创建JieKouDemo类的具体对象,之后直接调用Method方法
jd.Method(new Student());//当一个方法的参数是接口时,需要创建该接口的子实现类的对象,也就是接口类多态的形式:sleep s=new Student();
System.out.println("------------链式编程");
new JieKouDemo().Method(new Student());
// TODO自动生成的方法存根
}
}
interfacesleep{
public abstract void sleep();
}
class JieKouDemo{
public void Method(sleep s){
s.sleep();
}
}
class Student implements sleep{
@Override
public void sleep() {
System.out.println("学生学习一天之后,需要早点休息");
// TODO自动生成的方法存根
}
}
#返回值是抽象类的综合应用:
packageday_01_FanHuiZhi;
public class ChouXiangLei {
public static void main(String[] args) {
ChouXiangLeiDemo cld=new ChouXiangLeiDemo();//创建ChouXiangLeiDemo该类的具体对象
cld.method().life();//实际是创建 Person p=new Teather();多态的形式;
System.out.println("------------以下是链式编程");
new ChouXiangLeiDemo().method().life();
// TODO自动生成的方法存根
}
}
abstract class Person{
public abstract void life();
}
class ChouXiangLeiDemo{
public Person method(){//该方法的返回值是一个抽象类
return new Teather();//需要创建该抽象类的子实现类,直接返回抽象类的子类的对象
}
}
class Teather extends Person{
@Override
public void life() {
System.out.println("老师的生活很丰富");
// TODO自动生成的方法存根
}
}
#返回值是接口的综合应用:
packageday_01_FanHuiZhi;
public class JieKou {
public static void main(String[] args) {
System.out.println("以下是创建JieKouDemo类的具体对象,直接调用该方法");
JieKouDemo jkd=new JieKouDemo();
jkd.method().Eat();
System.out.println("以下是链式编程");
new JieKouDemo().method().Eat();
// TODO自动生成的方法存根
}
}
interfaceSpeak{
public abstract void Eat();
}
class JieKouDemo{
public Speak method(){
return new Student();
}
}
class Student implements Speak{
@Override
public void Eat() {
System.out.println("学生饿了,需要吃营养餐");
// TODO自动生成的方法存根
}
}
10.内部类
:在一个类中定义的另一个类;
a. 内部类可以访问外部内的成员,包括私有.
b. 外部内想要访问内部类的成员,必须通过创建内部类的对象,通过对象访问内部类的成员方法.
分类:1.成员内部类:在外部类的成员位置定义的另一个类
2.局部内部类:在外部类的局部位置定义的另一个类
(1).成员内部类(非静态):
在测试类中需要访问成员内部类中的成员的方法:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
例: Body.Inner bo = new Body().newInner() ;
#成员内部类的成员方法访问的综合应用:
packageday_01_NeiBuLei;
public class CeShiLei {
public static void main(String[] args) {
System.out.println("--------------");
Person.Animal pa=new Person().new Animal();//内部类访问外部类的成员,调用内部类的成员方法
pa.speak();
System.out.println("--------------");
Person p=new Person();//创建外部类的对象,直接调用外部类的成员方法,然后在此方法中创建内部类的对象,通过内部类的对象访问内部类的成员方法
p.talk();
// TODO自动生成的方法存根
}
}
class Person{
private int age=34;//外部类的私有成员变量
String name="王抢";//外部类的成员变量
class Animal{
public void speak(){
int age2=33;//内部类的成员变量
String name2="上官万成";//内部类的成员变量
System.out.println(name + "的年龄是" + age);//内部类可以访问外部类的成员,包括私有.
}
}
public void talk(){
Animal a=new Animal();
a.speak();
}
}
成员内部类的修饰符:
private:为了保证数的安全性
static修饰:为了方便调用(如果成员内部类被static修饰,那么要访问外部类的成员变量,这个变量必须被static修饰)
静态的成员内部类访问该类中的成员方法:
格式:外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
例: Outer4.Inner4 oi = newOuter4.Inner4() ;
#静态成员内部类访问外部成员的综合应用:
packageday_01_NeiBuLei;
public class JingTaiCe {
public static void main(String[] args) {
System.out.println("-----------");
Animal.ChuSheng cs=new Animal.ChuSheng();//该内部类被static修饰,要访问外部类的成员变量,必须要被static修饰
cs.work();//静态内部类的非静态方法
cs.show();//静态内部类的静态方法
// TODO自动生成的方法存根
}
}
class Animal{
public static String name ="王抢";//外部类的成员变量需要被static修饰
public static int age=35;//外部类的成员变量需要被static修饰
static class ChuSheng{
public static void show(){
System.out.println(name + "的年龄为:" + age);
}
public void work(){
System.out.println(name + "工作为学校卖命");
}
}
}
(3) 局部内部类: 定义在外部类的局部位置
Question:当局部内部类访问外部类的局部变量时,需要加final修饰,不然会报错
事由于局部变量时随着方法调用而产生的,随着调用完毕而消失,而现在局部位置有一个局部内部类,它主要在自己的成员方法位置访问当前的局部变量,必须把变量编程一个常量(需要通过final修饰,自定义常量)这样的一个变量的值永远是固定的.
#局部内部类访问局部变量的综合应用:
packageday_01_jubuneibulei;
public class JuBuCeShi {
public static void main(String[] args) {
Occupation oc=new Occupation();//创建外部类的对象,直接调用外部类的成员方法
oc.method();
// TODO自动生成的方法存根
}
}
class Occupation{
private String vary="teacher";
public String vary2="student";
public void method(){
final String vary3="singer";//外部类的局部变量必须要被final修饰
class Person{
public void work(){
System.out.println("学校的工作只要" + vary+ "和" + vary2);
System.out.println("学校的工作不需要" + vary3);//局部类中访问外部类的局部变量,次变量需要加final修饰
}
}
Person p=new Person();//创建局部内部类的对象,
p.work();//直接调用局部内部类的方法
}
}
11.匿名内部类:是内部类的简化形式
前提条件:必须存在一个接口或者是一个类(可以是具体类,也可以是抽象类)
书写格式:new 接口名或者类名(){ 方法重写}
匿名内部类的实质:继承了该类(抽象类)或者实现了该接口的子实现类
#匿名内部类的综合应用:
packageNiMing;
public class NiMing {
public static void main(String[] args) {
// TODO自动生成的方法存根
NiMIngDemo.method().Run();//用NiMIngDemo类名直接调用Method方法,返回一个接口的对象,然后用接口对象直接调用Run()方法
}
}
interfaceInter{//匿名内部类必须存在一个接口或者一个类
public abstract void Run();
}
class NiMIngDemo{
public static Inter method(){//该方法的返回值是一个接口
return new Inter(){//相当于创建了接口多态的形式:Inter i=new Inter();
@Override
public void Run() {//重写了接口中的方法
System.out.println("狗急跳墙");
// TODO自动生成的方法存根
}
};//return后面的代码实质是返回了一个接口对象
}
}
#匿名内部类与接口多态形式调用方法:
packageNiMing;
public class NiMingCeShi {
public static void main(String[] args) {
// TODO自动生成的方法存根
System.out.println("-------------通过创建接口的子实现类来访问方法");
inter1 tt=new Person();
tt.Entertain();
System.out.println("-----------通过匿名内部类调用方法");
NiMingCeShiDemo ncd=new NiMingCeShiDemo();
ncd.method(new inter1(){
@Override
public void Entertain() {
System.out.println("我的生活中会选择健身来休闲");
// TODO自动生成的方法存根
}
});
}
}
interfaceinter1{
public abstract void Entertain();
}
classNiMingCeShiDemo{
public void method(inter1 t){
t.Entertain();
}
}
class Person implements inter1{//通过创建接口的子实现类
@Override
public void Entertain() {
System.out.println("我的生活中会选择健身,打球,玩吉他来休闲");
// TODO自动生成的方法存根
}
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
