Day10：10-19JAVA学习记录从方法参数、返回值开始

Day10：10-19学习记录

目录

1、方法参数类型和返回值类型问题

2、权限修饰符

3、内部类

4、匿名内部类

1.1类名、抽象类、接口作为形式参数

（1）如果你以后看到一个方法的形参要一个”类“类型，你就传一个该类的对象

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

    private static void setStudent(Student student,int num) {
        student.num=num;
    }
}

class Student{
    int num=20;

    public void show(Student student,int num){
        this.num=num;
    }
}
运行结果：18

（2）如果你以后看到一个方法的形参要一个”抽象类“类型，你就传一个该抽象类的 子类对象

public class MyTest2 {
    public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个抽象类 类型，你就传一个该抽象类的 子类对象
        MyClasss aa = new AA();
        setMyClss(aa, 200);
        System.out.println(aa.num); 
    }
    private static void setMyClss(MyClasss myClss, int num) {
        myClss.show(num);
    }
}

abstract class MyClasss {
    int num = 10;
    public abstract void show(int num);
}

class AA extends MyClasss {
    int num = 20;
    @Override
    public void show(int num) {
        this.num = num;
    }
}
运行结果为10

（3）如果你以后看到一个方法的形参要一个”接口“类型，你就传一个该接口的子类对象

public class MyTest3 {
    public static void main(String[] args) {
        //如果你以后看到一个方法的形参要一个接口类型，你就传一个该接口的子类对象
        MyInterface bb = new BB();
        setInterface(bb,600);
        System.out.println(bb.num);
        System.out.println(MyInterface.num);
    }
    private static void setInterface(MyInterface myInterface,int num) {
        myInterface.show(num);
    }
}

interface MyInterface{
    int num=100;
    void show(int num);
}

class BB implements MyInterface{
        int num=500;
    @Override
    public void show(int num) {
        this.num=num;
    }
}
运行结果为100  100

1.2 类名、抽象类、接口作为返回值类型

（1）如果你以后看到一个方法的返回值类型要一个“类”类型，你返回一个该类对象

public class MyTest {
    public static void main(String[] args) {
        Teacher teacher = getTeacher(100);
        Teacher tea = teacher.show(new Teacher(), 500);
        System.out.println(teacher.num); 
        System.out.println(tea.num);
    }
    public static Teacher getTeacher(int num) {
        //如果你以后看到一个方法的返回值类型要一个类 类型，你返回一个该类对象
        Teacher teacher = new Teacher();
        teacher.num = num;

        return teacher;
    }
}
class Teacher {
    int num = 20;
    public Teacher show(Teacher teacher, int num) {
        this.num = num;

        return this;
    }
}
运行结果为500  500

（2）如果你以后看到一个方法的返回值类型要一个”抽象类“类型，你就返回该抽象类的一个子类对象

public class MyTest2 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.num=50;
        CC cc=getCC(zi,300);
        cc.show(zi,700);
        System.out.println(cc.num);//20
        System.out.println(zi.num);//50
    }
    public static CC getCC(CC cc,int num){
        //如果你以后看到一个方法的返回值，要一个抽象类 类型，你就返回该抽象类的一个子类对象
        cc.num=num;
        return new Zi();
    }
}
abstract class CC{
    int num=20;
    public abstract void show(CC cc,int num);
}
class Zi extends CC{
    int num=200;
    @Override
    public void show(CC cc,int num) {
        this.num=num;
    }
}
运行结果 20  50

（3）如果你以后看到一个方法的返回值类型要一个”接口“类型，你就返回该接口的一个子类对象

public class MyTest3 {
    public static void main(String[] args) {
        Iinterface anInterface = getInterface();
        System.out.println(anInterface.num); //200
        System.out.println(Iinterface.num);
        System.out.println(Son.num);
    }
    private static Iinterface getInterface() {
        //如果你以后看到一个方法的返回值类型，要一个接口类型，你就返回该接口的一个子类对象
        Son son = new Son();
        return son;
    }
}
interface Iinterface {
    public static final int num = 200;
    public abstract void show();
}
class Son implements Iinterface {
    @Override
    public void show() {
    }
}
运行结果 200  200  200

1.3 package关键字的概述及作用

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

1.4包的定义及注意事项

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

1.5 import关键字的使用

导包格式：import 包名;
注意：这种方式导入是到类的名称。

2.1四种权限修饰符

四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)

在本类中：private 默认 protected public 都可以使用

同一个包下（子类和无关类）：默认 protected public 都可用

不同包下（子类）：protected public 可用

不同包下（无关类）：public 可用

2.2类及其组成所使用的常见修饰符说明

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

3.1内部类

把类定义在其他类的内部，这个类就被称为内部类

内部类：成员内部类、局部内部类

如何在测试类中直接访问内部类的成员：格式:

外部类名.内部类名 对象名 = 外部类对象.内部类对象;

内部类能直接访问外部类的成员，包括私有

成员内部类，可用private修饰：为了保证数据的安全性；可用static修饰：为了方便访问数据。成员内部类被静态修饰后的访问方式是:
格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名();

3.2局部内部类：外界没有创建其对象的语法

1.当局部内部类去访问外部类的局部变量，这个局部变量必须家final 使这个局部变量成为一个常量

2.可以直接访问外部类的成员

3.可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

4.匿名内部类：他是局部内部类的简写形式
匿名内部类：本质上使一个对象，是谁的对象？是继承了该抽象类，或实现了该接口的子类对象

格式：new 抽象类名/接口名（）{

重写抽象类/接口中的方法

}；

用多态的方式，给对象起名字

这样调用的为同一个对象

匿名内部类经常作用于作为参数传递，或者作为返回值返回

一个普通类，也可以用匿名内部类的方式，创建出一个该类的子对象

3.4匿名内部类中this关键字

 interface Inter {
		public static final int a = 23 ;
	}
	
	public class Test {

		public static void main(String[] args) {
			new Inter() {
				public void show() {
					//this 代表匿名内部类
					System.out.println(this.a);//23
		
				}
			}.show();
		}
	}

补充：

链式编程：当我调用完一个方法后，这个方法会返回一个对象，那我可以紧接着再去打点，去调用对象中的方法