Java方法参数类型、返回值类型问题，权限修饰符、内部类与匿名内部类

方法参数类型

以类名作为形参传递

在调用方法时，需要将该类的一个对象作为形参传递进去才能调用此方法。

class A{
    public void change(A a){

    }
    public static void main(String[] args) {
        A A=new A();
        A.change(A);
    }
}

以抽象类名作为形参传递

在调用该方法时需要将该抽象类的一个子类对象作为参数传递进去才能调用此方法。

abstract class A{
    public abstract void change(A a);
}
class B extends A{
    @Override
    public void change(A a) {
        
    }

    public static void main(String[] args) {
        B b = new B();
        b.change(b);//子类对象b作为形参传递
    }
}

以接口名作为形参传递

在调用该方法时需要将实现该接口的一个类对象作为参数传递进去才能调用此方法。

interface C{
    public void change(C c);
}
class B implements C{
    @Override
    public void change(C c) {

    }

    public static void main(String[] args) {
        B b = new B();
        b.change(b);//实现了接口C的对象b作为形参传递
    }
}

返回值类型

以类名作为返回值类型

当以类名作为返回值类型时，返回一个该类对象即可。

class B {
    public B change(){
        return new B();//返回一个该类对象
    }
}

以抽象类作为返回值类型

当以抽象类作为返回值类型时，返回一个该抽象类的子类对象即可。

abstract class A{
    public abstract A change();
}

class B extends A {
    @Override
    public A change() {
        return new B();//返回一个继承抽象类A的子类对象
    }
}

以接口作为返回值类型

当以接口作为返回值类型时，返回一个实现该接口的类对象即可。

interface C{
    public C change();
}
class B implements C{
    @Override
    public C change() {
        return new B();//返回一个实现接口C的类对象
    }
}

链式编程

通常我们在主函数调用一个类的非静态方法的时候，我们需要实例化一个对象，然后再用对象去调用该方法，写了很多的代码。
通过链式编程我们很简洁的就能表达出来。

class A{
    public void change(A a){
        System.out.println("链式编程");
    }

    public static void main(String[] args) {
        new A().change(new A());//链式编程中只要是对象后面都可加.调用方法
    }
}

package关键字

package是什么？
	包又称为package，java中引用package这种语法机制主要是为了方便程序的管理。
	不同功能的类分门别类放到不同的软件包当中，查找比较方便，管理比较方便，易维护。
怎么定义package呢？
	在源程序的第一行上编写package语句。
	语法格式：
		paceage 包名
		如果要创建多级包，那么就需要加(.)将其分开。
创建包的注意事项：
	包名要求全部小写，包名也是标识符（大写也可以）
	一个包对应一个目录，所以多级包其实并不是一个包，而是一个包在另一个包下。

import关键字

当我们在访问不同包下的类的时候，需要提供包的全路径，这就显得非常麻烦，所以就有import关键字提供导包功能。
import语句用来导入其他包的类，同一个包下的类不需要导入，不通包下的类需要用import导入。
语法格式：
	import 包名.类名；
	例如我们需要导入Scanner类，语句格式：import java.util.Scanner;

权限修饰符

java中有四种权限修饰符：private、默认、protected、public
在本类中：四种权限修饰符修饰的变量或方法都可以被访问
在同一个包下（不同类）：private修饰的变量和方法不可被访问，其余权限修饰符修饰的变量和方法都可以被访问
不同包下（子类）：private和默认修饰符修饰的变量不可以被访问，其余权限修饰修饰的变量和方法可以被访问
不同包下（无关类）：只有public修饰的变量和方法可以被访问。

内部类

内部类根据内部类的位置分为成员内部类与局部内部类。
成员内部类：在成员位置定义的类，称为成员内部类。
局部内部类：在局部位置定义的类，称为局部内部类。

class A{
    class B {
        public void B() {
            A a = new A();//在成员内部类中可以实例化外部类并且调用外部类的方法
            a.A();
        }
    }
    public void A(){
        B b = new B();
        b.B();//在外部类中也可以实例化成员内部类访问成员内部类的方法
    }
}
class test{
    public static void main(String[] args) {
        A.B a=new A().new B();//实例化成员内部类
        a.B();
    }
}

class A{
    public void A(){
        class B{
            public void B(){
                A a = new A();//在局部内部类中可以实例化外部类；
                a.A();
            }
        }
        new B().B();//通过创建局部内部类对象然后调用局部内部类方法
    }
}

成员内部类的访问方式：
	格式：外部类名.内部类名 对象名=new 外部类名.内部类名();
成员内部类的访问特点：
	内部类可以直接访问外部类的成员，包括私有。
	外部类想要访问内部类的成员，要创建对象。
成员内部类的修饰符：
	private 保证数据的安全性
	static    方便访问数据
		注意事项：
			静态内部类访问的外部类数据必须用静态修饰；
			成员方法可以是静态或者非静态。
局部内部类的访问方式：
	创建内部类对象，通过对象调用内部类方法，使用局部内部类功能。
局部内部类访问局部变量必须用final修饰
	因为局部变量会随着方法的调用完毕而消失，而局部对象并没有从堆内存中消失，还要使用那个变量。
	为了让数据还能继续被使用，就用final修饰，这时堆内存其实存储的是常量值。

匿名内部类

匿名内部类就是局部内部类的简化写法。
前提：存在一个类或者接口；可以是具体类也可以是抽象类。
格式：
	new 类名或接口名{
			重写方法；
	};
其本质就是一个继承该类或实现该接口的一个子类匿名对象。

abstract class A {
    public abstract void show();
    public void A(){
        new A(){
            @Override
            public void show() {
                System.out.println("1");
            }
        }.show();//匿名内部类可以直接调用重写之后的方法，可以看出匿名内部类的本质就是一个对象。
    }
}