4.面向对象--内部类-CSDN博客

本文链接：https://blog.csdn.net/weixin_45940433/article/details/120281850

本文详细介绍了Java中的面向对象特性，包括形参和返回值为类名、抽象类名和接口名的情况，以及内部类的使用，包括成员内部类、局部内部类、匿名内部类，并通过实例展示了它们在实际开发中的应用，强调了多态和抽象在设计中的重要性。

摘要由CSDN通过智能技术生成

1.形参和返回值

1.类名作为形参和返回值

方法的形参是类名、其实需要的是该类的对象
方法的返回值是类名、其实返回的是该类的对象

//Cat类
package internal.study01;

public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

//CatOperator类
package internal.study01;

public class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }

    public Cat cat(){
        Cat cat = new Cat();
        return cat;
    }
}

//测试类
package internal.study01;

public class CatDemo {
    public static void main(String[] args) {
        CatOperator catOperator = new CatOperator();
        Cat cat = new Cat();
        catOperator.useCat(cat);

        Cat c2 = catOperator.cat();
        c2.eat();
    }
}

2.抽象类名作为形参和返回值

方法的形参是抽象类名、其实需要的是该抽象类的子类对象
方法的返回值是抽象类名，其实返回的是该抽象类型的子类对象
注意：抽象类创建对象时需使用多态形式。

//
package internal.study02;

public abstract class Animal {
    public abstract void eat();
}

//
package internal.study02;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//
package internal.study02;

public class AnimalOperator {
    public void useAnimal(Animal animal){
        animal.eat();
    }
    public Animal getAnimal(){
        Animal a = new Cat();
        return a;
    }
}

//
package internal.study02;

public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperator animalOperator = new AnimalOperator();
        Animal a = new Cat();
        animalOperator.useAnimal(a);

        Animal a2 = animalOperator.getAnimal();
        a2.eat();
    }
}

3. 接口名作为形参和返回值

方法的形参是接口名，其实需要的是该接口的实现类对象
方法的返回值是接口名，其实返回的是该接口的实现类对象

//Jumpping接口
package internal.study03;

public interface Jumpping {
    void jump();
}

//Cat类
package internal.study03;

public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫跳");
    }
}

//JumpOperator操作类
package internal.study03;

public class JumpOperator {
    public void useJumpping(Jumpping j){
        j.jump();
    }
    public Jumpping getJumpping(){
        Jumpping j = new Cat();
        return j;
    }
}

//JumpDemo测试类
package internal.study03;

public class JumpDemo {
    public static void main(String[] args) {
        JumpOperator jo = new JumpOperator();
        Jumpping c = new Cat();
        jo.useJumpping(c);

        Jumpping j2 = jo.getJumpping();
        j2.jump();
    }
}

2. 内部类

1. 内部类概述

内部类：其实就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类。
内部类的定义格式

public cass 类名{
  修饰符 class 类名{
    
  }
}

范例：

public class Outer{
  public class Tnner{
    
  }
}

内部类的访问特点

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

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

package internal.study04;

public class Outer {
    private int sum;
    //内部类
    public class inner{
        public void show(){
            sum =9;//内部类可以直接访问外部类的成员，包括私有。
            System.out.println("sum:"+sum);
        }
    }

//    外部类要访问内部类的成员，必须创建对象。
    public void methon(){
        inner i = new inner();
        i.show();
    }
}

2.成员内部类

内部类的分类

按照内部类在类中定义的位置不同，可以分为如下两种形式

在类的成员位置：成员内部类
在类的局部位置：局部内部类

成员内部类，外界如何创建对象使用：

格式：外部类名.内部类名对象名 = 外部类对象.内部类对象

//内部类
package internal.study05;

public class Outer {
    private int sum = 10;
    /*public class inner{
        public void show(){
            System.out.println(sum);
        }
    }
      不常用
     */

    private class inner{
        public void show(){
            System.out.println(sum);
        }
    }
    public void methon(){
        inner i = new inner();
        i.show();
    }
}

//测试类
package internal.study05;
/*测试类*/
public class Demo {
    public static void main(String[] args) {
        //创建内部类，调用方法
      /*  Outer.inner oi = new Outer().new inner();
        oi.show();
        针对公开的内部类
        */
        Outer o = new Outer();
        o.methon();
    }
}

3. 局部内部类

局部内部类实在方法中定义的类，所以外部是无法直接使用，需要在方法内部创建对象并使用，该类可以直接访问外部类，也可以访问方法内的内部变量。

//内部类
package internal.study06;

public class Outer {
    private int sum = 10;
    public void methon(){
        int sum1 = 102;
        class inner{
            public void show(){
                System.out.println("sum:"+sum);
                System.out.println("sum:"+sum1);
            }
        }
        inner i = new inner();
        i.show();
    }
}

//测试类
package internal.study06;

public class Demo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.methon();
    }
}

4. 匿名内部类

前提：存在一个类或接口，这里的类可以是具体类也可以是抽象类。
格式

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

范例

new Inter(){
  public void show(){
    
  }
}

本质：是一个继承了该类或者实现了该接口的子类匿名对象。
匿名内部类的细节

匿名内部类可以通过多态的形式接受

Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

匿名内部类直接调用方法

interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

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

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

当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

示例代码：

interface Jumpping {
    void jump();
}
class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
class Dog implements Jumpping {
    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}
class JumppingOperator {
    public void method(Jumpping j) { //new Cat();   new Dog();
        j.jump();
    }
}
class JumppingDemo {
    public static void main(String[] args) {
        //需求：创建接口操作类的对象，调用method方法
        JumppingOperator jo = new JumppingOperator();
        Jumpping j = new Cat();
        jo.method(j);

        Jumpping j2 = new Dog();
        jo.method(j2);
        System.out.println("--------");

        // 匿名内部类的简化
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
		// 匿名内部类的简化
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高了");
            }
        });
    }
}