形参和返回值：
①基本数据类型：比较简单不介绍
②引用数据类型：重点介绍面向对象过程中的抽象类和接口
① 方法的形参是类名，说明 需要是该类的对象
public void useCat(Cat c){
c.eat();
}
//创建操作类对象，并调用useCat方法
CatOperator c = new CatOperator();
//由于CatOperator类中的方法useCat需要一个Cat类型的对象
Cat cc = new Cat();
c.useCat(cc);
② 方法的返回值是类名，说明 返回的是该类的对象
public Cat getCat(){
Cat c = new Cat();
return c;
}
抽象类名作为参数和返回值
① 方法的形参是抽象类名，说明 需要该抽象类的子类对象
public void useAnimal(Animal a){
a.eat();
}
AnimalOperator ao = new AnimalOperator();
//调用useAnimal方法，此时参数是抽象类对象
//它的实例化必须使用多态的形式
Animal c = new Cat();
ao.useAnimal(c);
② 方法的返回值是抽象类名，说明 返回的是该抽象类的子类对象
public Animal getAnimal() {
Animal ao = new Cat();
return ao;
}
接口名作为形参和返回值
① 方法形参是接口名，说明 需要的是该接口实现类对象
public void useJumpping(Jumpping j){
// 测试类中Jumpping jj = new Cat();
j.jump();
}
JumppingOperator jo = new JumppingOperator();
//接口不能直接实例化，需要创建接口的实现类，采用多态的形式创建实现类对象
Jumpping jj = new Cat();
//编译看左边，执行看右边； 左侧Jumpping类有jump这个方法；右侧Cat中重写了jump这个方法
jo.useJumpping(jj);
② 方法返回值是接口名，说明 返回的是该接口的实现类对象
public Jumpping getJumpping() {
Jumpping j = new Cat();
return j;
}
Jumpping jo2 = jo.getJumpping();
jo2.jump();
内部类
概述
概念： 就是在一个类中定义一个类。
格式：
public class 类名{
修饰符 class 类名{
}
}
内部类修饰符 一般是private
特点：
①内部类可以直接访问外部类的成员，包括私有
public class Outer {
//内部类可以访问外部类的成员
private int age = 20;
//内部类 Inter
public class Inter{
public void show(){
System.out.println(age);
}
}
}
②外部类要访问内部类的成员，必须创建对象
// 外部类 Outer
public class Outer {
//内部类可以访问外部类的成员
private int age = 20;
//内部类 Inter
public class Inter{
public void show(){
System.out.println(age);
}
}
public void method(){
//外部类访问内部类的成员，必须创建内部类的方法
// show();//直接访问会报错
Inter i = new Inter();
i.show();
}
}
内部类分类：
根据内部类在类中定义的位置不同：
①在类的成员位置：成员内部类
②在类的局部位置：局部内部类
public class Outer {
private int num = 20;
//Inter就是Outer类的成员内部类
public class Inter{
public void show(){
System.out.println(num);
}
}
}
访问
成员内部类，外界创建对象访问 格式：
前提是 内部类定义通过public修饰。
外部类名.内部类名 对象名 = 外部类对象.内部类对象； 例子：Outer.Inter oi = new Outer（）.new Inter（）；
理解xhj：
出现内部类的原因是：把内部类的内容隐藏起来，不想让外界直接看到/访问。则内部类定义 修饰符的位置不是public而是private。
内部类修饰符是private时，内部类中的方法访问 方式：
在外部类中 创建成员方法：创建内部类对象，通过对象调用方法实现访问 在测试类中 创建外部类的对象，通过对象调用外部类成员方法的形式实现对内部类方法的访问。
public class Outer {
private int num = 20;
//Inter就是Outer类的成员内部类
// public class Inter{
// public void show(){
// System.out.println(num);
// }
// }
private class Inter{
public void show(){
System.out.println(num);
}
}
public void method(){
Inter i = new Inter();
i.show();
}
}
public class OuterDemo {
public static void main(String[] args) {
//创建内部类对象，并调用方法
//内部类 采用修饰符public，可以采用上述方式访问内部类中的方法
//内部类 采用修饰符private，采用下述形式访问内部类方法。
// 在外部类中写方法，方法中 创建内部类对象，通过对象.方法实现对内部类的访问。
Outer o = new Outer();
o.method();//20
}
}
局部内部类
格式
位置是：位于外部类成员方法中。
public class Outer {
private int num = 10;
public void method(){
class Inter{
public void show(){
System.out.println(num);
}
}
}
}
访问
特点① 局部内部类是在方法中定义的类，所以外部是无法直接使用，需要在方法内部创建对象并使用。
特点② 该类可以直接访问外部类的成员变量，也可以访问方法内的局部变量。
public class Outer {
外部类的成员变量
private int num = 10;
public void method(){
外部类成员方法内的局部变量
int num2 = 30;
class Inter{
public void show(){
System.out.println(num);//10
System.out.println(num2);//20
}
}
Inter i = new Inter();
i.show();
创建外部类成员，不在内部类中创建对象、调用show方法，外部类创建的对象将不能访问内部类的show方法
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
①method方法中只有局部内部类 Inter 则外部类Outer对象调用method方法什么也不执行。
②method方法中有局部内部类Inter；Inter类的实例化对象；对象.show方法，此时执行结果是外部类的成员变量num = 10
③method方法中有局部内部内Inter；Inter类的实例化对象；对象.show方法；Inter内部输出外部类的成员变量/外部类成员方法method的局部变量，此时执行结果是外部类的成员变量num = 10、外部类成员方法的局部变量 num2 = 30
}
}
匿名内部类
概述
匿名内部类 = 是局部内部类的一种。
前提： 存在一个类或者接口，类可以是具体类或抽象类
格式：
new 类名或者接口名（）{
重写方法；
}；
理解：
①这里的new 类名或者接口名（） 说明整体是一个对象，只不过对象没有名字，也称为匿名对象，即匿名类本质是一个匿名对象。
②重写方法，说明它继承了前面的类 或者 实现了前面的接口。
本质： 是一个继承了该类或者实现了该接口的子类匿名对象。
案例：
公共部分：
// 接口
public interface Inter {
//接口 = 抽象内容
// 抽象方法
public abstract void show();
}
//测试类
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
public class Outer {
//匿名内部类是局部内部类的一种，所以需要在外部类的方法中书写
public void method(){
//匿名内部类的前提是 存在一个类或接口 所以需要先定义类或者接口 本案例中定义一个接口
new Inter(){
@Override
public void show() {
System.out.println("匿名内部类的show方法");
}
};
//此时method方法中有 内容了，执行测试类 但是没有输出结果
}
public class Outer {
//匿名内部类是局部内部类的一种，所以需要在外部类的方法中书写
public void method(){
//要想实现匿名内部类方法的调用，匿名内部类的本质是 继承了类或接口的对象，所以可以直接匿名内部类.方法进行方法的调用。
new Inter(){
@Override
public void show() {
System.out.println("匿名内部类的show方法");
}
}.show();
如果想多次调用该方法，则重复写即可。
new Inter(){
@Override
public void show() {
System.out.println("匿名内部类的show方法");
}
}.show();
}
public class Outer {
//匿名内部类是局部内部类的一种，所以需要在外部类的方法中书写
public void method(){
//但如果多次调用，则一直重复会造成代码复用性差，
//new 是Inter（），并且又重写了show方法，则new Inter(){}整体可以认为是 接口Inter的实现类对象 那么可以按照多态的形式 将其赋值给Inter类接口。
Inter i = new Inter(){
@Override
public void show() {
System.out.println("匿名内部类的show方法");
}
};
i.show();
}
}
匿名内部类在开发中的使用
分析：
创建操作类对象，调用method方法
method方法 参数是接口名时，说明需要的是 接口实现类的对象
public class JumppingOperator {
//接口的操作类
public void method(Jumpping j){
//参数是接口名，说明需要的是 接口的实现类对象
j.jump();
}
}
这时 可以采用匿名内部类的形式，new 类名/接口名（）{重写方法；}； 匿名内部类的本质是：继承类或实现接口的对象。
// 创建 JumppingOperator操作类 的 对象
JumppingOperator j = new JumppingOperator();
j.method(new Jumpping() {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
});
完整：
public interface Jumpping {
//接口是抽象的内容，接口中定义方法修饰符不写 默认是public abstract
void jump();
}
public class JumppingOperator {
//接口的操作类
public void method(Jumpping j){
//参数是接口名，说明需要的是 接口的实现类对象
j.jump();
}
}
// 测试类
public class JumppingDemo {
public static void main(String[] args) {
// 创建操作类对象，调用method方法
// method方法 参数是接口名时，说明需要的是 接口实现类的对象
// 这时 可以采用匿名内部类的形式，new 类名/接口名（）{重写方法；}； 匿名内部类的本质是：继承类或实现接口的对象。
JumppingOperator j = new JumppingOperator();
Jumpping jj = new Cat();
j.method(jj);//方法需要的 Jumpping接口的实现类对象
System.out.println("--------------");
//如果多次创建 Jumpping接口的 不同实现类 这样会产生多个类文件，只是用一次，会造成文件冗余。采用匿名内部类实现。
j.method(new Jumpping() {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
});
//其本质需要是的Jumpping接口实现类的对象，使用匿名内部类的形式，不用额外创建Jumpping的实现类。
}
}
