重生之我是Java小白四

最新推荐文章于 2024-09-30 10:36:33 发布

Y 开心599

最新推荐文章于 2024-09-30 10:36:33 发布

阅读量932

点赞数 22

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_65909965/article/details/136459880

版权

一抽象类

1.相关概念

1.1什么是抽象类

1.为了能够表示抽象的集合概念这样的思想

1.2格式

abstract class 类名 {}

1.3抽象方法

被abstract修饰的成员方法

2.抽象类的的特点

2.1抽象类无法被实例化(不能new出来对象)

package com.shujia.day8;
abstract class Animal1{

    //创建抽象类成员变量
    String name;
    int age;

    //创建抽象类无参构造方法
    public Animal1() {
    }

    //创建抽象类有参构造方法
    public Animal1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //创建抽象类eat方法
    public void eat(){
        System.out.println("吃");
    }

    //创建抽象类sleep方法
    public void sleep(){
        System.out.println("睡");
    }
}
public class AbstractDemo1 {
    public static void main(String[] args) {
//        Animal1 animal1 = new Animal1();  java: com.shujia.day8.Animal1是抽象的; 无法实例化
    }
}

2.2有抽象方法的一定是抽象类

如果一个类中有抽象方法，那么不要忘记在类前加abstract

2.3抽象类无法被实例化，却可以在抽象类中编写构造方法

目的是：为了子类能够成功创建对象，要想初始化子类，必选初始化其直接父类。

2.4被abstract关键字修饰的方法，不允许有方法体的实现，连大括号都不能有。

2.5当一个具体的class类继承一个抽象类的时候，必须要实现抽象类中的所有抽象方法

这里报错就是因为我Cat1类继承Animal抽象类时没有实现抽象类里面的所有抽象方法

下面是修改代码

package com.shujia.day8;
abstract class Animal1{

    //创建抽象类成员变量
    String name;
    int age;

    //创建抽象类无参构造方法
    public Animal1() {
    }

    //创建抽象类有参构造方法
    public Animal1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //创建抽象类eat方法
    public void eat(){
        System.out.println("吃");
    }

    //创建抽象类sleep方法
    public void sleep(){
        System.out.println("睡");
    }

    //创建抽象方法
    public abstract void play();

}

//创建子类
class Cat1 extends Animal1{


    public Cat1() {
    }

    public Cat1(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void eat(){
        System.out.println("🐱吃🐟");
    }

    @Override
    public void sleep(){
        System.out.println("🐱蜷着睡");
    }
    
    @Override
    public void play(){
        System.out.println("🐱躲着玩");
    }
}
public class AbstractDemo1 {
    public static void main(String[] args) {
//        Animal1 animal1 = new Animal1();  java: com.shujia.day8.Animal1是抽象的; 无法实例化

    }
}

重写抽象方法只用把abstract去除，然后重写即可

2.7抽象类与抽象之间允许存在继承关系, 抽象类继承抽象类的时候，可以选择性地重写方法，也可以都不重写

1.抽象类继承抽象类时可以选择的重写父类的抽象方法

2.也可以选择性的重写父类的成员方法

3.例题

package com.shujia.day8;

//创建Teacher抽象类
abstract class Teacher{

    //创建父类私有成员变量
    private String name;
    private int age;

    //创建父类的构造方法
    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //创建set，get方法

    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 abstract void teach();
}

//创建子类继承抽象类
class YuWenTeacher extends Teacher{

    //创建子类的构造方法
    public YuWenTeacher() {
    }

    public YuWenTeacher(String name, int age) {
        super(name, age);
    }

    //重写父类的抽象方法
    public void teach(){
        System.out.println("语文老师教语文");
    }

    //定义子类自己的成员方法
    public void sing(){
        System.out.println("语文老师喜欢唱歌");
    }
}

public class AbstractDemo2 {
    public static void main(String[] args) {

        //使用多态
        Teacher teacher=new YuWenTeacher();
        teacher.teach();

        //像调用子类的成员方法，需要向下转型
        YuWenTeacher yuWenTeacher=new YuWenTeacher();
        yuWenTeacher.teach();
        yuWenTeacher.sing();
    }
}
/*
语文老师教语文
语文老师教语文
语文老师喜欢唱歌
 */

4.与abstract冲突的修饰符

static

private

final

二.接口

1.相关概念

1.什么是接口

接口是抽象类的延申，可以将他看作是纯粹的抽象类，接口中的所有方法都没有方法体

1.2接口的定义 interface关键字

interface 接口名 {}

1.3接口的实现

class 类名 implements 接口名 {}

2接口的特点

2.1 接口不能实例化

不能new出来一个对象

2.2接口的成员变量

1.是个常量，不允许被修改

2.默认被public static final修饰

3.可以直接通过接口名.变量名获取

package com.shujia.day8;

//创建接口
interface Inter{
    int a=10;

    //创建接口抽象方法
    void fun1();
    void fun2();
    void fun3();

//编写实现了Inter接口的实现标准类
//规范接口实现类的写法：接口名Impl
class InterImpl1 implements Inter{

    //重写接口的抽象方法
    @Override
    public void fun1(){
//        a=100;  java: 无法为最终变量a分配值
        System.out.println(a);
        System.out.println("这是重写接口的抽象方法fun1");
    }
    @Override
    public void fun2() {
        System.out.println("这是重写接口的抽象方法fun2");
    }
    @Override
    public void fun3() {
        System.out.println("这是重写接口的抽象方法fun3");

    }
}

abstract class InterImpl2 implements Inter{
    @Override
    public void fun1(){
        System.out.println("这是抽象类实现接口的重写接口的抽象方法");
    }
}

}
public class InterfaceDemo2 {
    public static void main(String[] args) {

        //创建标准类接口实现的对象
        Inter.InterImpl1 interImpl1 = new Inter.InterImpl1();
        interImpl1.fun1();
        System.out.println(Inter.a);
    }
}
/*

10
这是重写接口的抽象方法fun1
10
 */

2.3接口中只允许出现抽象方法

1.接口抽象方法不能带有主体

2.默认被public abstract修饰

3.没有构造方法

2.4实现接口 class 类名 implements 接口名 {}

1.当一个具体的类实现一个接口的时候，必须要重写其中所有抽象方法

package com.shujia.day8;

//定义抽象父类
abstract class Animal3 {

    //定义抽象方法
    public abstract void eat();

    public abstract void sleep();
}

//定义子类继承抽象类
class Dog3 extends Animal3 {

    //重写父类的抽象方法
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void sleep() {
        System.out.println("狗趴着睡");
    }
}

//定义一个接口
interface Compute {
//    public void compute(){ // 接口抽象方法不能带有主体
//        System.out.println("狗会计算");
//    }

    public abstract void compute();
}

//实现接口
class DogCompute extends Dog3 implements Compute{

    //重写抽象方法
    @Override
    public void compute() {
        System.out.println("狗会计算");
    }
}
public class InterfaceDemo1 {
    public static void main(String[] args) {
        DogCompute dogCompute = new DogCompute();
        dogCompute.compute();

    }
}

2.5规范接口实现类的写法：接口名Impl

package com.shujia.day8;

//创建接口
interface Inter{

    //创建接口抽象方法
    void fun1();
    void fun2();
    void fun3();

//编写实现了Inter接口的实现标准类
//规范接口实现类的写法：接口名Impl
class InterImpl1 implements Inter{

    //重写接口的抽象方法
    public void fun1(){
        @Override
        System.out.println("这是重写接口的抽象方法fun1");
    }

    @Override
    public void fun2() {
        System.out.println("这是重写接口的抽象方法fun2");
    }

    @Override
    public void fun3() {
        System.out.println("这是重写接口的抽象方法fun3");

    }
}



}
public class InterfaceDemo2 {
    public static void main(String[] args) {

        //创建标准类接口实现的对象
        Inter.InterImpl1 interImpl1 = new Inter.InterImpl1();
        interImpl1.fun1();
    }
}

2.6标准类与抽象类都可以实现接口

1.标准类实现接口必须要重写接口所有的抽象方法

2.抽象类实现接口选择性的重写抽象方法

2.7一个类可以同时实现多个接口，接口之间使用英文逗号分割

2.8接口与接口之间是继承关系，接口之间继承允许多继承

2.9父类与接口方法重名

子类继承父类且实现了接口，如果说父类与接口中有一个方法重名了子类调用这个方法是调用父类中的方法(jdk 9)

三.形式参数与返回值问题

1.形式参数

1.1类作为形式参数

package com.shujia.day9;

// 创建一个类
class Student{
    public void fun1(){
        System.out.println("好好学习，天天向上");
    }
}

class StudentTest{
    //当一个类作为方法参数类型传递的时候，将来调用时应该传入该的类对象
    public void show(Student student){ //Student student = new Student()
        student.fun1();
    }
}

public class StudentDemo1 {
    public static void main(String[] args) {

        //创建StudentTest对象
        StudentTest studentTest = new StudentTest();
        studentTest.show(new Student());
    }
}
/*
好好学习，天天向上
 */

1.2抽象类作为形式参数

传入的是抽象类的具体子类对象

package com.shujia.day9;

//定义一个抽象类
abstract class Student1 {
    public void fun1() {
        System.out.println("好好学习");
    }
}

//编写子类继承抽象类
class Student1Zi1 extends Student1{

}

//编写测试类
class StudentText1{
    public void show1(Student1 student1){
        student1.fun1();
    }
}

public class StudentDemo2 {
    public static void main(String[] args) {
        //创建测试类对象
        StudentText1 studentText1 = new StudentText1();
        studentText1.show1(new Student1Zi1());//传入的是抽象类的具体子类对象
    }
}
/*
好好学习
 */

1.3接口作为形式参数

传入的是实现该接口的类的对象

package com.shujia.day9;

//定义一个接口
interface Inter{
   public abstract void fun2();
}

//定义一个实现了接口的类
class InterImpl implements Inter{

    //重写接口抽象方法
    @Override
    public void fun2() {
        System.out.println("好好学习");
    }
}
//定义一个测试类
class StudentText3{
    public void show2(Inter inter){
        inter.fun2();
    }
}


public class StudentDemo3 {
    public static void main(String[] args) {
        StudentText3 studentText3 = new StudentText3();
//        studentText3.show2(new Inter);  报错的原因是接口不能new出来
        studentText3.show2(new InterImpl());
    }
}
/*
好好学习
 */

2.返回值

2.1类作为返回值

返回的是该类的对象

package com.shujia.day9;

//创建一个类
class Teacher{
    public void fun1(){
        System.out.println("教书育人");
    }
}

//创建一个测试类
class TeacherText{
    public Teacher show1(){
        return new Teacher();
    }
}
public class TeacherDemo1 {
    public static void main(String[] args) {

        //创建一个TeacherText对象
        TeacherText teacherText = new TeacherText();

        //创建Teacher对象
        Teacher teacher = new Teacher();
        teacher.fun1();
        //这个时候如果我不想通过创建Teacher对象来调用show1方法，那么接下来就必须这样
        Teacher teacher1=teacherText.show1(); //teacherText.show1()这个一句话相当于是new Teacher
        teacher1.fun1();

    }
}
/*
教书育人
教书育人
 */

2.2抽象类作为返回值

返回的是该抽象类具体子类对象

package com.shujia.day9;

//定义一个抽象类
abstract class Teacher1{
    public void fun1(){
        System.out.println("教书育人");
    }
}

class Teacher1Zi1 extends Teacher1{

}

//定义一个测试类
class TeacherText1{
    public Teacher1 show2(){
        return new Teacher1Zi1();  //当抽象类作为返回值时 返回的是该抽象类具体子类对象
    }
}


public class TeacherDemo2 {
    public static void main(String[] args) {
        
        //创建TeacherText1对象
        TeacherText1 teacherText1 = new TeacherText1();
        Teacher1 teacher1=teacherText1.show2();
        teacher1.fun1();
    }
}
/*
教书育人
 */

2.3接口作为返回值时

接口作为返回值时返回的是实现该接口的类

package com.shujia.day9;

//定义一个接口
interface Inter1{
    public abstract void fun2();
}

//定义一个实现接口的类
class InterImpl1 implements Inter1{
    //重写接口的抽象方法
    @Override
    public void fun2() {
        System.out.println("教书育人");
    }
}

//定义一个测试类
class TeacherText2{
    public Inter1 show2(){
        return new InterImpl1();  //接口作为返回值时返回的是实现该接口的类
    }
}

public class TeacherDemo3 {
    public static void main(String[] args) {

        //定义一个TeacherDemo3
        TeacherText2 teacherText2 = new TeacherText2();
        Inter1 inter1=teacherText2.show2();
        inter1.fun2();
    }
}

四.包

1.包的相关概念

1.1什么是包

其实就是文件夹

1.2作用

对类进行分类管理

1.3包的划分

1按照角色划分

2、按照功能划分

2定义包的相关事项

2.1定义格式

package 包名

多级包用.分开即可

2.2注意事项

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

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

如果没有package，默认表示无包名

3.导包

3.1导包格式

import 包名;

3.2导包事项

1.导包必须在包下类上

2.如果想用一个包下面的所有东西用*即可例如 import 包名.*,且这个*不要随便用，当一个包下的类超过15个才用

五.权限修饰符

1.变量被权限修饰符修饰

2.类里面的多个修饰符

2.1 修饰类的

1.权限修饰符 public 默认的

2.常量修饰符 final 如果这个修饰类，类无法被继承

3.静态修饰符 static 修饰类部类可以

4.抽象修饰符 abstract 抽象类无法new

2.2.修饰成员变量

1.权限修饰符参考变量被权限修饰符修饰

2.常量修饰符 final 变成常量，无法修改

3.静态修饰符 static 变成类变量，使用直接可以用类名.类变量名

4.抽象修饰符无法修饰

2.3修饰构造方法

1.权限修饰符全部都可以

2.只能用权限修饰符修饰

2.4修饰成员方法

1.权限修饰符

a.public protected 默认的 private 可以在本类中调用成员方法

b.在子类中不能调用父类中被private修饰的成员方法

2.常量修饰符fianl 不能被重写

3.静态修饰符static 变成类方法，想要使用直接类名.类方法名();

4.抽象修饰符 abstract 变成抽象方法子类想继承抽象类必须重写所有的抽象方法

六.内部类

1.内部类的相关概念

1.1什么是内部类

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

class 类名{

class 类名1

}

1.2内部类的访问特点

1.内部类可以直接访问外部类的成员，包括私有。

2.外部类要访问内部类的成员，必须创建对象。

2.成员内部类

2.1概念

定义在类中方法外的类

2.2非静态的成员内部类

1.创建成员内部类对象

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

idea中的快捷键

new 外部类名().new 内部类名().var即可

package com.shujia.day9;

//创建一个外部类
class Outer1{
    //定义一个成员变量
    int a=10;

    //定义一个内部类
    class Inter1{
        public void fun1(){
            System.out.println(a);
        }
    }
    
}
public class InnerClassDemo1 {
    public static void main(String[] args) {

        //创建成员内部类对象
        Outer1.Inter1 inter1 = new Outer1().new Inter1();
        inter1.fun1();
    }
}
/*
10
 */

2.相关特点

1.无论是私有成员变量还要私有成员方法，在内部类中可以直接调用或者使用

package com.shujia.day9;

//创建一个外部类
class Outer1{
    //定义一个成员变量
    int a=10;
    //定义一个私有成员变量
    private int b=20;

    //定义一个成员方法
    public void show1(){
        System.out.println("好好学习");
    }

    //定义一个私有成员方法
    private void show2(){
        System.out.println("天天向上");
    }

    //定义一个内部类
    class Inter1{
        public void fun1(){
            System.out.println(a);
            System.out.println(b);
            show1();
            show2();
        }
    }

}
public class InnerClassDemo1 {
    public static void main(String[] args) {

        //创建成员内部类对象
        Outer1.Inter1 inter1 = new Outer1().new Inter1();
        inter1.fun1();
    }
}
/*
10
20
好好学习
天天向上
 */

2.内部类都不会单独编译出一个class文件

2.3被private修饰的成员内部类

1.无法new出成员内部类的对象

package com.shujia.day9;

//定义一个类
class Outer2{

    //创建成员变量和私有成员变量
    int a=10;
    private int b=20;

    //定义一个成员方法
    public void show1(){
        System.out.println("好好学习");
    }

    //定义一个私有成员方法
    private void show2(){
        System.out.println("天天向上");
    }

    private class Inter2{
        public void fun2(){
            System.out.println("好好学习天天向上");
            System.out.println(a);
            System.out.println(b);
            show1();
            show2();
        }
    }

    //定义一个调用成员内部类方法的方法
    public  void show(){
        Inter2 inter2 = new Inter2();
        inter2.fun2();
    }
}

public class InnerClassDemo2 {
    public static void main(String[] args) {
//        Outer2.Inter2 inter2 = new Outer2().new Inter2(); 报错原因是无法创建private修饰的成员内部类对象

        //既然都不能new出来成员内部类对象，那么里面的方法岂不是不能用了
        //如果真的是调用这个方法，直接在内部类外定义一个方法来调用内部类里面的方法,这个方法里面要创建内部类对象
        //创建好了 再去测试类创建外部类对象，调用这个方法即可
        Outer2 outer2 = new Outer2();
        outer2.show();

    }
}
/*
好好学习天天向上
10
20
好好学习
天天向上
 */

2.如何调用成员内部类被private修饰的成员方法

1.在成员内部类外，外部类里定义一个成员方法，方法里面创建内部类对象，通过对象调用内部类成员方法

2.在主方法里面创建外部类对象然后通过外部类对象调用这个成员方法

package com.shujia.day9;

//定义一个类
class Outer2{

    //创建成员变量和私有成员变量
    int a=10;
    private int b=20;

    //定义一个成员方法
    public void show1(){
        System.out.println("好好学习");
    }

    //定义一个私有成员方法
    private void show2(){
        System.out.println("天天向上");
    }

    private class Inter2{
        public void fun2(){
            System.out.println("好好学习天天向上");
            System.out.println(a);
            System.out.println(b);
            show1();
            show2();
        }
    }

    //定义一个调用成员内部类方法的方法
    public  void show(){
        Inter2 inter2 = new Inter2();
        inter2.fun2();
    }
}

public class InnerClassDemo2 {
    public static void main(String[] args) {
//        Outer2.Inter2 inter2 = new Outer2().new Inter2(); 报错原因是无法创建private修饰的成员内部类对象

        //既然都不能new出来成员内部类对象，那么里面的方法岂不是不能用了
        //如果真的是调用这个方法，直接在内部类外定义一个方法来调用内部类里面的方法,这个方法里面要创建内部类对象
        //创建好了 再去测试类创建外部类对象，调用这个方法即可
        Outer2 outer2 = new Outer2();
        outer2.show();

    }
}
/*
好好学习天天向上
10
20
好好学习
天天向上
 */

2.4静态成员内部类

1.如何创建对象

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

2.idea中的快捷键

new 外部类名.内部类名（）.var

2.只能访问外部的静态成员变量跟成员方法

package com.shujia.day9;

//创建一个类
class Outer3 {

    //定义一个成员变量
    int a = 10;
    //定义一个私有成员变量
    private int b = 20;

    //定义一个静态成员变量
    static int c = 30;

    //定义一个成员方法
    public void show1() {
        System.out.println("好好学习");
    }

    //定义一个私有成员方法
    private void show2() {
        System.out.println("天天向上");
    }

    //定义一个静态成员方法
    public static void show3() {
        System.out.println("春眠不觉晓");
    }

    //定义一个私有的静态成员方法
    private static void show4() {
        System.out.println("处处闻啼鸟");
    }

    //创建一个静态内部类
    static class Inter3 {
        public void fun3() {
//            System.out.println(a);  报错原因是被静态修饰的成员内部类只能访问外部类的静态成员
//            System.out.println(b);  报错原因是被静态修饰的成员内部类只能访问外部类的静态成员
            System.out.println(c);
//            show1();   报错原因是被静态修饰的成员内部类只能访问外部类的静态方法
//            show2();   报错原因是被静态修饰的成员内部类只能访问外部类的静态方法
            show3();
            show4();
        }

    }

}

public class InnerClassDemo3 {
    public static void main(String[] args) {
        //创建静态内部类成员
        Outer3.Inter3 inter3 = new Outer3.Inter3();
        
        inter3.fun3();

    }
}
/*
30
春眠不觉晓
处处闻啼鸟
 */

2.5成员内部类访问各级成员变量

1.想输出局部变量直接打印变量名

2.想输出内部类成员变量直接打印 this.成员变量名

3.想输出外部类成员变量直接打印外部类名.this.成员变量名

package com.shujia.day9;

//创建外部类
class Outer4{
    int a=10;
    class Inter4{
        int a=20;
        public void show5(){
            a=30;
            System.out.println("想输出30的方法：a"+a);
            System.out.println("想输出20的方法：this.a："+this.a);
            System.out.println("想输出10的方法：Outer.this.a："+Outer4.this.a);
        }
    }
}

public class InnerClassDemo4 {
    public static void main(String[] args) {
        final Outer4.Inter4 inter4 = new Outer4().new Inter4();
        inter4.show5();
    }
}
/*
想输出30的方法：a30
想输出20的方法：this.a：30
想输出10的方法：Outer.this.a：10

 */

3.局部内部类

3.1概念

1.将类定义在类中方法的内部

3.2使用局部内部类

1.在方法里面定义好了内部类后，直接在方法里面new出局部内部类对象，如果局部内部类里面有方法，直接使用局部内部类名的对象名.方法名。

2.在main方法里面创建外部类对象，再调用这个有局部内部类的方法，这样可以调用局部内部类的成员变量或者成员方法

package com.shujia.day9;
//定义一个外部类
class Outer5{
    //创建成员变量和私有成员变量
    int a=10;
    private int b=20;

    //定义一个成员方法
    public void show1(){
        System.out.println("好好学习");
    }

    //定义一个私有成员方法
    private void show2(){
        System.out.println("天天向上");
    }

    //创建一个方法里面有内部类
    public void show6(){
        //定义一个局部变量c
        int c=100;
        class Inter5{
            //定义一个局部内部类成员变量
            int d=99;
            public void fun(){
                a=11; //可以休改外部类成员变量
                b=12; //可以休改外部类成员变量
//                c=50; 不能被修改，因为局部内部类访问局部变量的时候，局部变量默认前面有一个fianl修饰
                d=90; //可以修改内部类自己的成员变量
                show1();
                show2();
            }

        }
        //创建局部内部类对象
        Inter5 inter5 = new Inter5();
        inter5.fun();
    }
}
public class InnerClassDemo5 {
    public static void main(String[] args) {
        Outer5 outer5 = new Outer5();
        outer5.show6();
    }
}
/*
好好学习
天天向上
 */

3.3相关变量在局部内部类的事项

1.外部类的成员变量无论是私有的还是啥，在局部内部类中都可以修改

2.方法里面的局部变量，不能被修改，默认有fianl修饰

3.局部内部类的成员变量无论是私有的还是啥，在局部内部类方法中都可以修改

package com.shujia.day9;
//定义一个外部类
class Outer5{
    //创建成员变量和私有成员变量
    int a=10;
    private int b=20;

    //定义一个成员方法
    public void show1(){
        System.out.println("好好学习");
    }

    //定义一个私有成员方法
    private void show2(){
        System.out.println("天天向上");
    }

    //创建一个方法里面有内部类
    public void show6(){
        //定义一个局部变量c
        int c=100;
        class Inter5{
            //定义一个局部内部类成员变量
            int d=99;
            private int e=39;
            public void fun(){
                a=11; //可以休改外部类成员变量
                b=12; //可以休改外部类成员变量
//                c=50; 不能被修改，因为局部内部类访问局部变量的时候，局部变量默认前面有一个fianl修饰
                d=90; //可以修改内部类自己的成员变量
                e=29;
                show1();
                show2();
                
            }

        }
        //创建局部内部类对象
        Inter5 inter5 = new Inter5();
        inter5.fun();
    }
}
public class InnerClassDemo5 {
    public static void main(String[] args) {
        Outer5 outer5 = new Outer5();
        outer5.show6();
    }
}
/*
好好学习
天天向上
 */

3.4相关方法在局部内部类中的使用

无论是public还是private都可以在局部内部类中调用

4.匿名内部类

4.1相关概念

1.前提

存在一个类或者接口。这里的类可以是具体类也可以是抽象类。

2.格式：

new 类名或者接口名() {重写方法;};

4.2相关练习

1.当接口作为匿名内部类

这是不适应匿名内部类

package com.shujia.day9;
//定义一个接口
interface InterA{
    void show9();
}

//实现接口的类
class InterAImpl1 implements InterA{
    @Override
    public void show9() {
        System.out.println("好好学习");
    }
}

class DemoText1{
    //接口作为参数,传入的是实现该接口的类的对象
    public void fun1(InterA interA){
        interA.show9();
    }
}
public class NiMingClassDemo1 {
    public static void main(String[] args) {
        DemoText1 demoText1 = new DemoText1();
//        demoText1.fun1(new InterA() {
//            @Override
//            public void show9() {
//                System.out.println("天天向上");
//            }
//        });
        demoText1.fun1(new InterAImpl1());
    }
}

这是使用匿名内部类

package com.shujia.day9;
//定义一个接口
interface InterA{
    void show9();
}

//实现接口的类
class InterAImpl1 implements InterA{
    @Override
    public void show9() {
        System.out.println("好好学习");
    }
}

class DemoText1{
    //接口作为参数,传入的是实现该接口的类
    public void fun1(InterA interA){
        interA.show9();
    }
}
public class NiMingClassDemo1 {
    public static void main(String[] args) {
        DemoText1 demoText1 = new DemoText1();
        demoText1.fun1(new InterA() {
            @Override
            public void show9() {
                System.out.println("天天向上");
            }
        });
    }
}

2.当抽象类作为匿名内部类

1.不使用匿名内部类

package com.shujia.day9;
//定义一个抽象类
abstract class Animal{
    public abstract void cry();
}

//定义一个实现该抽象类的方法
class Cat extends Animal{
    @Override
    public void cry() {
        System.out.println("🐱呜呜地哭");
    }
}

//定义测试类
class DemoText2{
    public void fun1(Animal animal){//参数是抽象类
        animal.cry();
    }
}
public class NiMingClassDemo2{
    public static void main(String[] args) {
        DemoText2 demoText2 = new DemoText2();
        demoText2.fun1(new Cat());
    }

}

2.使用匿名内部类

package com.shujia.day9;
//定义一个抽象类
abstract class Animal{
    public abstract void cry();
}

//定义一个实现该抽象类的方法
class Cat extends Animal{
    @Override
    public void cry() {
        System.out.println("🐱呜呜地哭");
    }
}

//定义测试类
class DemoText2{
    public void fun1(Animal animal){//参数是抽象类
        animal.cry();
    }
}
public class NiMingClassDemo2{
    public static void main(String[] args) {
        DemoText2 demoText2 = new DemoText2();
//        demoText2.fun1(new Cat());
        demoText2.fun1(new Animal() {
            @Override
            public void cry() {
                System.out.println("🐱萨萨地哭");
            }
        });
    }

}