传递形参和返回值类型，导包的一些关键字，权限修饰符，内部类和匿名内部类

1.传参和返回值类型

1.1 形参

1. 类名作为形式参数时，你就传一个该类对象

public class MyDemo {
    public static void main(String[] args) {
        Student student = new Student();
        //当你形参是一个类名时，你就传一个该类对象
        student.show(student);
    }
}
class Student{
    public void show(Student student){}
}

2. 抽象类作为形式参数时，你就传一个抽象类的子类对象

public class MyDemo2 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //如果方法的形参是一个抽象类时，你就传一个抽象类的子类对象
        setshow(dog);
    }
    private static void setshow(Animal an) {
    }
}
abstract class Animal{}			//抽象类
class Dog extends Animal{}		//抽象类的子类

3. 接口作为形式参数时，你就传一个接口的子类对象

public class MyDemo3 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        //如果形参是一个接口时，你就传一个接口的子类对象
        setmethod(zi);
    }
    private static void setmethod(Inter inter) {
    }
}
interface Inter{}		//接口
class Zi implements Inter{}	//接口子类

1.2 返回值类型

1. 如果一个方法的返回值类型，要一个类 类型 你就返回一个该类对象

public class MyDemo {
    public static void main(String[] args) {
        Student student = new Student();
    }
}
class Student{	
	//如果一个方法的返回值要一个 类 类型，你就返回一个该类的子类对象
    public Student show(Student student){
        return student;//返回子类对象
    }
}

2. 如果一个方法的返回值类型要一个 抽象类 类型，你就传一个抽象类的自诶对象

public class MyDemo2 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        setMethod(dog);
    }
    //如果一个方法的返回值类型要一个抽象类 类型，你就传一个抽象类的子类对象
    private static Animal setMethod(Dog dog) {
  
        return dog;//返回子类对象
    }
}
abstract class Animal{}
class Dog extends Animal{}

3. 如果一个方法的返回值类型要一个接口 类型，你就传一个接口的子类对象

public class MyDemo3 {
    public static void main(String[] args) {
        Myclass myclass = new Myclass();
        setMethod(myclass);
    }
	//一个方法的返回值是接口类型，你就传一个接口的子类对象
    private static MyInterface setMethod(Myclass myclass) {
        return myclass;	//返回一个接口的子类对象
    }
}
interface MyInterface{}
class Myclass implements MyInterface{}

1.3 链式编程

链式编程可以更加简便的调用方法。
链式编程就是当你调用完一个方法，其返回值还是个对象时，你就可以继续打点调用方法。

例：

public class MyDemo4 {
    public static void main(String[] args) {
        Student student = new Student();
        int t = student.show(new Student()).test(20);//链式编程
        System.out.println(t);
    }
}
class Student{
    public Student show(Student student){
        return student;
    }
    public int test(int num){
        return num;
    }
}

调用student的第一个对象时，返回值还是一个对象，所以可以继续打点调用test方法，test方法返回值时具体数值，可以用int来收。

2.导包

包就是一个文件夹
作用：来解决同一个路径下不能存在同名文件的问题。
格式：package 包名
注意事项：

1. package语句必须是程序的第一条可执行的代码。
2. package语句在java文件中只能有一个。
3. 如果没有package，默认不是无包名。

导包：可以在另外一个包下访问此包的成员。
格式：import 包名

package org.westos.demo7;//package是程序第一条可执行代码

import org.westos.demo6.Teacher;//导入demo6的Teacher类，可以在demo7中使用Teacher创建对象

public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
    }
}

注意：package、import、class顺序是package第一条，import第二条，class第三条。

3.权限修饰符

四种权限修饰符
private（私有的） ，默认，protected（受保护的），public（公共的）
结论：

	本类	同一包下（子类和无关类）	不同包下（子类）	不同包下（无关类）
private	yes
默认	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

修饰符：

1. 权限修饰符：private，默认的，protected，public
2. 状态修饰符：static，final
3. 抽象修饰符：abstract

修饰类的关键字：默认修饰符，public，final，abstract。
修饰成员变量的关键字：private，默认的，protected，public，static，final
修饰构造方法的关键字：private，默认的，protected，public
修饰成员方法的关键字：private，默认的，protected，public，static，final，abstract

4.内部类

定义：把类定义在其他类 的内部，这个类就是内部类
内部类访问特点：

1. 内部类可以直接访问外部类的成员，私有的也可以。
2. 外部类要访问内部类的成员，必须创建对象。

按照内部类位置分类：

1. 成员位置：在成员位置定义的类，称为成员内部类。
2. 局部位置：在局部位置定义的类，称为局部内部类。

4.1 成员内部类

在测试类中之直接访问成员内部类的成员
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

public class MyTest {
    public static void main(String[] args) {
        A.B b = new A().new B();	//创建内部类的对象
        b.show();
    }
}
class A{
    int num=40;
    private int num2=30;
    class B{
        public void show(){
            System.out.println(num);
            System.out.println(num2);	//可以直接调用外部类的私有成员
            aa();
        }
    }
    public void aa(){
        System.out.println("外部类方法");
    }
}

4.2 成员内部类的常见修饰符

1. private 为了保证数据的安全性
2. static 为了方便访问数据

案例演示private：

public class MyDemo {
    public static void main(String[] args) {
        //Wai.Nei nei = new Wai().new Nei();私有化内部类，你不能在外界创建对象了
        //但是可以在外部类中创建内部类对象，因为private可以在本类中使用
        //在外界创建外部类对象，调用外部类方法就可以调用到内部类成员
        Wai wai = new Wai();
        wai.show();
    }
}
class Wai{
    private class Nei{
        int num=30;
        public void Neibu(){
            System.out.println("内部类的方法");
        }
    }
    public void show(){
        Nei nei = new Nei();
        System.out.println(nei.num);
        nei.Neibu();
    }
}

用static修饰的内部类在创建内部类的对象时的格式更加简洁
外部类名.内部类名 对象名 = new 外部类名.内部类名();
注意事项：用static修饰内部类之后，内部类只能访问外部类的静态成员或静态成员方法。

4.3 局部内部类

局部内部类就是在外部类的局部位置。
局部内部类不能直接在外界创建对象。

可以使用代码来表示局部内部类的用法

public class MyDemo2 {
    public static void main(String[] args) {
        Waibu waibu = new Waibu();//在外界创建外部类对象，来调用show（）方法，来实现调用内部类成员
        waibu.show();
    }
}
class Waibu{
    public void show(){
        class Neibu{
            int num=20;
            public void test(){
                System.out.println("内部类方法");
            }
        }
        //需要在外部类的局部位置创建内部类对象
        Neibu neibu = new Neibu();
        neibu.test();
        System.out.println(neibu.num);
    }
}

注：局部内部类访问局部变量

class Outer{
    public void show(){
        int num=20;
        class Inner{
            //num=30;//此时num不能重新赋值
            // 因为定义局部内部类后，外部类局部变量就用final修饰了，变成了常量。
        }
    }
}

5.匿名内部类

匿名内部类：局部内部类的简化写法
前提：存在一个类或者接口（类可以使具体类也可以是抽象类）
格式：
new 类名或者接口名(){
重写方法;
} ;
本质：本质上是一个对象，这个对象就是接口/类名的一个子类对象。

可以使用代码演示基本匿名内部类：

public class MyDemo {
    public static void main(String[] args) {
        //new Animal(){}就是Animal抽象类的子类对象
        new Animal() {
            @Override
            public void show() {
                System.out.println("重写show方法");
            }
        }.show();
        //new Myinterface(){}就是Myinterface接口的子类对象
        new Myinterface() {
            @Override
            public void test() {
                System.out.println("重写test方法");
            }
        }.test();
    }

}
abstract class Animal{		//抽象类
    public abstract void show();
}
interface Myinterface{		//接口
    void test();
}

还有就是一个匿名内部类怎么调用两个方法，不能直接调用两个方法，否则不是同一个子类对象。这是可以给整个匿名子类对象起一个名字。

MyInter myInter=new MyInter() {
    @Override
    public void show() {
    }

    @Override
    public void test() {

    }
};
//调用两个对象，而且使用同一个子类对象调用的
myInter.show();
myInter.test();

还有就是传参和返回值类型可以使用匿名内部类
传参可以直接使用匿名内部类传：

public class MyTest {
    public static void main(String[] args) {
        setMyInter(new MyInterface() {	//调用方法
            @Override
            public void show() {
                System.out.println("show方法重写了");
            }
        });
    }
    //形参是interface类型，使用匿名内部类直接传
    private static void setMyInter(MyInterface myInterface) {
       myInterface.show();
    }
}
interface MyInterface{
    void show();
}

返回值类型：

public class MyTest2 {
    public static void main(String[] args) {
       setMethod();
    }
    //返回值类型是一个接口类型，返回一个接口类型的子类对象
    private static Myinter setMethod() {
    	//返回一个接口的子类对象
        return new Myinter() {
            @Override
            public void show() {
                System.out.println("show方法执行了");
            }
        };
    }
}
interface Myinter{
    void show();
}

5.1 类中定义接口

可以在类中定义一个接口

public class MyTest {
    public static void main(String[] args) {
    	//给接口的匿名子类对象起个名字
        Outer.MyInterface myInterface=new Outer.MyInterface() {
            @Override
            public void show() {
                System.out.println("重写show方法");
            }
        };
        myInterface.show();//用名字调用show方法
    }
}
class Outer{
    interface MyInterface{
        void show();
    }
}