传参与返回值类型、内部类、匿名内部类

参数类型

1. 类名作为形式参数

public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个类 类型你就传一个该类对象
        Student student = new Student();
        student.show(new Student(),20);
        System.out.println(student.num);
    }
}


class Student{
    int num=100;

    public void show(Student stu,int num){
        stu.num=num;

    }
}

2. 抽象类名作为形式参数

 public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个 抽象类 类型，你就传一个该类的子类对象
        Dog dog = new Dog();
        setMethod(dog,114);
    }

    private static void setMethod(Animal an,int num) {

        an.show(num);
    }

}

abstract class Animal{
    int num=110;
    public abstract void show(int a);
}

class Dog extends Animal{
    int num=20;

    @Override
    public void show(int num) {
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

3. 接口名作为形式参数

public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个 接口 类型 你就传一个该接口的子类对象
        MyClass myClass = new MyClass();
        test(myClass,22);
    }

    private static void test(MyInterface myInterface,int b) {
        myInterface.show(b);
    }
}

interface MyInterface{
    int NUM=100;
    void show(int a);

}

class MyClass implements MyInterface{
    int b=10;
    @Override
    public void show(int a) {
        System.out.println(this.b);
        System.out.println(NUM);
        System.out.println(MyInterface.NUM);
    }
}

返回值类型

1. 类名作为返回值类型

public static void main(String[] args) {
        //如果你以后看到一个方法的返回值类型，要一个类 类型 你就返回一个该类对象
        Student student = new Student();
        student.num=20;
        Student student1 = student.getStudent(new Student(),111);

        System.out.println(student1.num);

        System.out.println(student1==student);

    }
}

class Student {
    int num=10;

    public Student getStudent(Student student,int num){
        this.num=num;
        Student student2 = new Student();
        return this;
    }

}

2. 抽象类名作为返回值类型

 public static void main(String[] args) {
        Animal animal = getAnimal(new Cat());
        animal.test();
    }
    //如果你以后看到一个方法的返回值类型，要一个抽象类 类型，你返回一个该抽象类的子类对象
    private static Animal getAnimal(Cat cat) {


        return cat;

    }
}


abstract class Animal{
    public abstract void test();

}

class Cat extends Animal{

    @Override
    public void test() {
        System.out.println("abc");
    }
}

3. 接口名作为返回值类型

public class MyTest2 {
    public static void main(String[] args) {
        MyInterface anInterface = getInterface(10);
        anInterface.show(1000);
    }
        //如果你以后看到一个方法的返回值类型，要一个 接口类型，你就返回一个该接口的子类对象
    private static MyInterface getInterface(int num) {
        num=11;


        return new MyClass();
    }
}

interface  MyInterface{

    void show(int num);
}


class MyClass implements  MyInterface{

    @Override
    public void show(int num) {
        System.out.println(num);
    }
}

链式编程

当你调用完一个方法后，他的返回值又是个对象，那么你紧接着，就可以打点，在继续调用对象中的方法。

package关键字

1. 包的概述：就是文件夹
2. 包的作用：用来解决同一个路径下不能存在同名文件的问题(分类管理)
3. 定义包的格式：package 包名；
   多级包用.分开即可
4. 定义包的注意事项：
   package语句必须是程序的第一条可执行的代码
   package语句在一个java文件中只能有一个
   如果没有package，默认表示无包名

import关键字

1. 导包的概述：不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。
2. 导包格式 import 包名;

内部类

1. 按照内部类位置分类
   成员位置：在成员位置定义的类，被称为成员内部类。
   局部位置：在局部位置定义的类，被称为局部内部类。
2. 成员内部类
   如何在测试类中直接访问内部类的成员。
   格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象

成员内部类

• 成员内部类的修饰符：
  private 为了保证数据的安全性
  static 为了方便访问数据
  注意事项: a:静态内部类访问的外部类数据必须用静态修饰。
  b: 成员方法可以是静态的也可以是非静态的
• 成员内部类被静态修饰后的访问方式是:
  格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名();

局部内部类

• 可以直接访问外部类的成员
• 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
• 局部内部类访问局部变量必须用final修饰
  为什么呢?
  因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
  为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

匿名内部类

1. 匿名内部类: 就是局部内部类的简化写法。
2. 前提： 存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
3. 格式：
   new 类名或者接口名(){
   重写方法;
   } ;
4. 本质是一个继承了该类或者实现了该接口的子类匿名对象。

public class MyTest {
    public static void main(String[] args) {
        new AA(){
            @Override
            public void show() {
                System.out.println("ccccc");
            }
        }.show();
    }
}

class AA{

    public void show(){
        System.out.println("abc");
    }
}