JAVA零学习之基础归纳（十）--参数传递、内部类的基础知识

1、 参数传递

1.1 类名作为形参和返回值

• 类名作为方法的形参
  • 方法的形参是类名，其实需要的是该类的对象
  • 实际传递的是该对象的地址值
• 类名作为方法的返回值
  • 方法的返回值是类名，其实返回的是该类的对象
  • 实际传递的，也是该对象的地址值
• 实例：

class Cat {
	public void eat() {
    System.out.println("猫吃鱼");
    }
} 
class CatOperator {
	public void useCat(Cat c) {
    //Cat c = new Cat();
    c.eat();
    }
    public Cat getCat() {
    Cat c = new Cat();
    return c;
    }
}
public class CatDemo {
	public static void main(String[] args) {
    //创建操作类对象，并调用方法
    CatOperator co = new CatOperator();
    Cat c = new Cat();
    co.useCat(c);
    Cat c2 = co.getCat();
    //new Cat()
    c2.eat();
   } 
}

1.2 抽象类作为形参和返回值

• 抽象类作为形参和返回值
  • 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
  • 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
• 示例：

abstract class Animal {
	public abstract void eat(); }
class Cat extends Animal {
	@Override
	public void eat() {
    System.out.println("猫吃鱼");
    }
}
class AnimalOperator {     public void useAnimal(Animal a) { //Animal a = new Cat();         a.eat();     }
	public Animal getAnimal() {
	Animal a = new Cat();
	return a;
	}
} 
public class AnimalDemo {
	public static void main(String[] args) {         //创建操作类对象，并调用方法
    AnimalOperator ao = new AnimalOperator();
    Animal a = new Cat();
    ao.useAnimal(a);
    Animal a2 = ao.getAnimal(); //new Cat()
    a2.eat();
  }
}

1.3 接口名作为形参和返回值

• 接口作为形参和返回值
  • 方法的形参是接口名，其实需要的是该接口的实现类对象
  • 方法的返回值是接口名，其实返回的是该接口的实现类对象
• 示例：

interface Jumpping {
	void jump();
}
class JumppingOperator {
	public void useJumpping(Jumpping j) {
	//Jumpping j = new Cat();
    j.jump();
}
	public Jumpping getJumpping() {
    Jumpping j = new Cat();
    return j;
  }
} 
class Cat implements Jumpping {
	@Override
    public void jump() {
    System.out.println("猫可以跳高了");
   }
} 
public class JumppingDemo {
	public static void main(String[] args) {
    //创建操作类对象，并调用方法         JumppingOperator jo = new JumppingOperator();         Jumpping j = new Cat();
    	jo.useJumpping(j);           Jumpping j2 = jo.getJumpping(); //new Cat()
        j2.jump(); 
    }
 }

2、内部类

2.1 内部类的基本使用

• 内部类概念

  • 在一个类中定义另一个类

• 格式：

  • class 外部类名{

    ​ 修饰符 class 内部类名 {

    ​ }

    }

• 访问：

  • 内部类可以直接访问外部类的成员、方法包括私有的
  • 外部类要访问内部类，必须通过对象

2.2 成员内部类

• 位置：
  • 在类中方法，跟成员变量是一个位置
• 外界创建成员内部类格式
  • 格式： 外部类名.内部类型 对象名 = 外部类对象.内部类对象;
• 成员内部类的推荐使用方案
  • 将一个类，设计为内部类的目的，大部分是不想让外界访问，所以内部类的定义应该是私有化，私有化之后，在提供一个可以让外界调用的方法，方法内部类对象并调用

package com.bdit.test;

public class Test04 {
    public static void main(String[] args) {
        External external = new External();
        external.informa01("张三",20);
        external.aa();
//  external.informa02();
        //使用内部类
        External.Interior interior01 = new External().new Interior();
        interior01.Interfor();
        interior01.iorfor01();
        interior01.iorfor02("甲一",12);
    }
}

//定义外部类
class External{
    private String name;
    private int age;
    String compellation = "王五";
    int aagee = 10;
    public void informa01(String name,int age){
        System.out.println("外部类姓名："+name+"，外部类年龄："+age);
    }
    //外部类使用内部类，需要使用对象
    Interior interior02 = new Interior();
    public void aa(){
        System.out.println("外部类姓名："+compellation+"，外部类年龄："+aagee+"，内部类地址："+interior02.site);
    }


    //定义内部类
    public class Interior{
        String site = "中国";
        public void Interfor(){
            System.out.println("内部类地址："+site);
        }
        //内部类可以直接使用外部类的方法和属性甚至是私有的
        public void iorfor01(){
            System.out.println("内部类姓名："+compellation+"，内部类年龄："+aagee+"，内部类地址："+site);
        }//内部类使用外部类私有属性
        public void iorfor02(String name,int age){
            System.out.println("内部类姓名："+name+"，内部类年龄："+age+"，内部类地址："+site);
        }
    }
}

2.3 局部内部类

• 局部内部类定义位置
  • 局部内部类是在方法中定义的类
• 局部内部类方式方式
  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
  • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
• 示例：

package com.bdit.test;

public class Test05 {
    public static void main(String[] args) {
        Outside outside = new Outside();
        outside.Common();
        outside.inner();
    }
}

class Outside{
    private String name = "张三";
    int age = 20;

    public void Common(){
        System.out.println("外层类的普通方法");
    }
    //定义局部内部类
    public void inner(){
        int weight = 60;

        class InnerClass{
            //在局部内部类中可以直接访问外部类中的方法、属性、包括私有的
            private String sit = "山东";
            int hright = 120;

            public void Internal(){
                System.out.println("局部内部类的姓名："+name+"，局部内部类的年龄："+age+"，局部内部类的体重："+weight+"，局部内部类的身高："+hright+"，局部内部类的地址："+sit);
                Common();//访问外部类的方法
            }


        }
        //调用局部内部类
        InnerClass innerClass = new InnerClass();
        innerClass.Internal();

    }
}

2.4 匿名内部类

1、

• 前提：
  • 存在一个类或者接口，这个类可以实具体的也可使抽象的
• 匿名内部类的格式
  • new 类名(){重写方法};
• 本质
  • 是一个继承了该类或者实现了该接口的子类匿名对象
• 细节
  • 匿名内部类可以通过多态的形式接受

2、

• 匿名内部类在开发中使用
  • 当发现某个方法需要，接口或抽象类子类对象，我们就可以传递一个匿名内部类过去。

3、

• 示例：

package com.bdit.test;

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

        //定义匿名类(一般用于抽象类和接口类)
            //new 接口/抽象类名(){};
            //调用方法则需在{}后面 .方法名 即可
        new Abstra01(){

            @Override
            public void abject01() {
                System.out.println("重写抽象类中的方法");
            }
        }.abject01();

        new Port01(){

            @Override
            public void sum01(int a, int b) {
                System.out.println("重写接口类的方法");
                System.out.println("a"+"+"+"b"+"="+(a+b));
            }
        }.sum01(1,2);


    }
}

abstract class Abstra01{
    public abstract void abject01();
}

interface Port01{
    public abstract void sum01(int a,int b);
}

第二种：

package com.bdit.test;

public class Test06_01 {
    public static void main(String[] args) {
        //参数传递方法的匿名方法(抽象)
        Test06_01 test06_01 = new Test06_01();
        test06_01.display01(new Abstra02() {
            @Override
            void abject02() {
                System.out.println("重写Abstra02(抽象类)中的abject02(抽象)方法");
            }
        });

        System.out.println("-------------------------------------------------------------");

        //参数传递方法的匿名方法(接口)
        Test06_01 test06_011 = new Test06_01();
        test06_011.display02(new Port02() {
            @Override
            public void sum02(int a, int b) {
                System.out.println("重写Port02(接口类)中的sum02(抽象)方法");
                System.out.println("a"+"+"+"b"+"="+(a+b));
            }
        });

    }

    //参数接收的抽象方法
    public void display01(Abstra02 abstra02){
        abstra02.abject02();
    }

    //参数接收的接口方法
    public void display02(Port02 port02){
        port02.sum02(1,2);
    }

}

abstract class Abstra02{
    abstract void abject02();
}

interface Port02{
    void sum02(int a,int b);
}