10-java学习-方法参数类型以及返回值类型问题研究、权限修饰符、内部类、匿名内部类&案例代码

10-java学习-方法参数类型以及返回值类型问题研究、权限修饰符、内部类、匿名内部类&案例代码

目录：

方法参数类型以及返回值类型问题研究
权限修饰符
内部类
匿名内部类

1.类名作为形式参数

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

class Student{
    int num=100;
    public void show(int num){
        this.num=num;
    }
}

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

public class MyTest2 {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参要一个 抽象类 类型，你就传一个该类的子类对象
        Zi zi = new Zi();
        test(zi,15);
        System.out.println(zi.num);//20

    }
    public static void test(Teacher teacher,int num){
        System.out.println(teacher.num);
        teacher.num=num;
        System.out.println(teacher.num);
    }
}

 abstract class Teacher{
    int num=100;

     public Teacher() {
         System.out.println("Teacher 的构造执行了");
     }

     public abstract void show(int num);
 }

 class Zi extends Teacher{
        int num=20;
     @Override
     public void show(int num) {
         this.num=num;
     }
 }

3.接口名作为形式参数

public class MyTest3 {
    public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个 接口 类型 那么你就传一个该接口的 子类对象
        MyClass myClass = new MyClass();
        test(myClass);
        System.out.println(myClass.num); //20
        System.out.println(MyInterface.num);//200
    }
    public static void test(MyInterface myInterface){
        System.out.println(myInterface.num); //1.200
    }
}
interface MyInterface{
    public static  final int num=200;
    void show(int num);
}
class MyClass implements MyInterface{
    int num=20;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

4.类名作为返回值类型

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student(); //
        Student s = test(student, 20);
        System.out.println(student.num); //20
        System.out.println(s.num); //10
    }

    public static Student test(Student student, int num) {
        //如果你以后看到一个方法的返回值类型，要一个类 类型，你就返回一个该类对象
        student.num = num;
        Student student1 = new Student();
        return student1;
    }
}

class Student {
    int num = 10;
}

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

public class MyTest2 {
    public static void main(String[] args) {
        BB bb = new BB();
        AA  aa = test(bb, 500);
        System.out.println(bb.num);//
        System.out.println(aa.num);//
    }
    //如果你以后看到一个方法的返回值类型要一个 抽象类 类型。你就返回一个该类的子类对象
    public static AA test(AA aa, int num) {
        aa.num = num;
        BB bb = new BB();
        return bb;
    }
}
abstract class AA {
    int num = 20;
    public abstract void show(int num);
}
class BB extends AA {
    int num = 200;
    @Override
    public void show(int num) {
        System.out.println(num);
    }
}

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

public class MyTest3 {
    public static void main(String[] args) {
        Son son = new Son();
        MyInterface myInterface = test(son, 120);
        son.show(53);
        System.out.println(son.num);//2.500
        System.out.println(myInterface.num); //200
        System.out.println(MyInterface.num); //200
    }
    //如果你以后看到一个方法的返回值类型，要一个接口类型，你就返回一个改接口的子类对象
    public static MyInterface test(MyInterface myInterface,int num){
        System.out.println(myInterface.num);//1.200
        Son son = new Son();
        return son;
    }
}
interface MyInterface{
    int num=200;
    void show(int num);
}
class Son implements MyInterface{
    int num=500;
    @Override
    public void show(int num) {
        this.num=num;
        System.out.println(num); //
    }
}

8.链式编程

public class MyTest {
    public static void main(String[] args) {
       /* Student student = new Student();
        Student student1=student.getStudent(student,200);
        student1.show();*/
        //l.链式编程语法风格:当你调用完一个方法后，这个方法返回一个对象，那么你紧接着就可以打点再去调用这个对象的方法。
        new Student().getStudent(new Student(), 50).show();

    }
}
class Student {
    int num = 10;

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

    public void show() {
        System.out.println(this.num);//
    }
}

9.package关键字的概述及作用

A:包的概述:	就是文件夹
B:包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
C:包的划分:
	按照功能 
	按照模块 

10.包的定义及注意事项

A:定义包的格式
	package 包名;
	多级包用.分开即可
B:定义包的注意事项
	A:package语句必须是程序的第一条可执行的代码
	B:package语句在一个java文件中只能有一个
	C:如果没有package，默认表示无包名

11.import关键字的概述和使用

A:导包的概述
	不同包下的类之间的访问,每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能
B:导包格式
	import 包名;
	注意：
		这种方式导入是到类的名称。
		虽然可以最后写*，但是不建议。

12.四种权限修饰符

				本类	同一个包下(子类和无关类)  不同包下(子类) 不同包下(无关类)
	private 	Y		
	默认		   Y	         Y
	protected	 Y		       Y		          Y
	public		 Y		       Y		          Y		          Y

13.类及其组成所使用的常见修饰符

A:修饰符：
	权限修饰符：private，默认的，protected，public
	状态修饰符：static，final 
	抽象修饰符：abstract
B:修饰类的关键字：
	权限修饰符：默认修饰符，public
	状态修饰符：final
	抽象修饰符：abstract
	用的最多的就是：public
C:修饰成员变量的关键字：
	权限修饰符：private，默认的，protected，public
	状态修饰符：static，final
	用的最多的就是：private
D:修饰构造方法的关键字：
	权限修饰符：private，默认的，protected，public
	用的最多的就是：public
E:修饰成员方法的关键字：
	权限修饰符：private，默认的，protected，public
	状态修饰符：static，final
	抽象修饰符：abstract
	用的最多的就是：public
F:除此以外的组合规则：
	成员变量：public static final 
	成员方法：public static 
	         public abstract
			 public final

14.内部类概述和访问特点

A:内部类概述:把类定义在其他类的内部，这个类就被称为内部类。
	举例：在类A中定义了一个类B，类B就是内部类。
B:内部类访问特点
	a:内部类可以直接访问外部类的成员，包括私有。
	b:外部类要访问内部类的成员，必须创建对象。

//案例演示
public class MyTest {
    public static void main(String[] args) {
        //内部类：将一个类A 定义到另一个类B 的内部，那我们就把A 叫做内部类，B叫做外部类
        //内部类根据定义的位置不同，分为成员内部类和局部内部类
        //成员内部类：在外部类的成员位置
        //局部内部类：在外部类的局部位置（方法中）
    }
}
class B{
    int num=200;
    class A { //成员内部类
    }

    public void show(){
        class C{ //局部内部类
        }
    }
}

15.内部类分类及成员内部类的直接使用

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

16.成员内部类的常见修饰符及应用

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

17.局部内部类访问局部变量的问题

A: 可以直接访问外部类的成员
B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
  	因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
	为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
	JDK1.8之后，final会默认加上，不用手动去加

18.匿名内部类的格式和理解

A:匿名内部类:	就是局部内部类的简化写法。
B:前提：	存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
C:格式：
	new 类名或者接口名(){
		重写方法;
	} ;
D:本质是什么呢?
	是一个继承了该类或者实现了该接口的子类匿名对象。
E:案例演示
	按照要求来一个匿名内部类

public class MyTest {
    public static void main(String[] args) {
        //匿名内部类：是局部内部类的一种简化写法
        //匿名内部类本质上是一个对象。是实现了该接口，或继承了该抽象类的子类对象。
      new AA(){
          @Override
          public void aa() {
              System.out.println("aaa");
          }
          @Override
          public void bb() {
              System.out.println("aaaaaaaaaaaa");
          }
      };
       AA aa= new AA() {
            @Override
            public void aa() {
                System.out.println("aaa");
            }
            @Override
            public void bb() {
                System.out.println("aaaaaaaaaaaa");
            }
        };
       aa.aa();
       aa.bb();
    }
}
abstract class AA{
    public abstract void aa();
    public abstract void bb();
}