Java 初学 day09

java 09

1、形式参数

基本类型: 当基本数据类型作为参数传递的时候，传递是具体的数值
引用类型:
    数组：当数组作为方法的参数类型的时候，将来需要传递数组的地址值
    具体的类：当你看到一个类作为方法的参数类型的时候，将来调用需要传入该类或该类的子类的对象
    抽象类：当你看到一个抽象类作为方法的参数类型的时候，将来调用需要传入该抽象类具体实现子类的对象
    接口：当你看到一个接口作为方法的参数类型的时候，将来调用需要传入实现了该接口的具体子类对象

具体的类作参数传递示例

class Student{
    public void fun1(){
        System.out.println("好好学习，天天向上！");
    }
}

class StudentDemo1{
    //当你看到一个类作为方法的参数类型的时候，将来调用需要传入该类或该类的子类的对象
    public void show1(Student student){
        student.fun1();
    }
}

public class Demo1 {
    public static void main(String[] args) {
        StudentDemo1 studentDemo1 = new StudentDemo1();
        studentDemo1.show1(new Student());
    }
}

抽象类作参数传递案例

abstract class Student2{
    public abstract void fun1();
}

class Student2Zi extends Student2{
    @Override
    public void fun1() {
        System.out.println("江川是世界上手速最快的男人！");
    }
}

class StudentDemo2{
    //当你看到一个抽象类作为方法的参数类型的时候，将来调用需要传入该抽象类具体实现子类的对象
    public void show1(Student2 student2){ //Student2 student2 = new Student2Zi()
        student2.fun1();
    }
}

public class Demo2 {
    public static void main(String[] args) {
        StudentDemo2 studentDemo2 = new StudentDemo2();
        studentDemo2.show1(new Student2Zi());
    }
}

接口作参数传递案例

interface Inter1{
    void fun1();
}

class Student3 implements Inter1{
    @Override
    public void fun1() {
        System.out.println("钱志强是世界上最有钱的男人！");
    }
}

class StudentDemo3{
    //当你看到一个接口作为方法的参数类型的时候，将来调用需要传入实现了该接口的具体子类对象
    public void show1(Inter1 inter1){ //Inter1 inter1 = new Student3()
        inter1.fun1();
    }
}

public class Demo3 {
    public static void main(String[] args) {
        StudentDemo3 studentDemo3 = new StudentDemo3();
        studentDemo3.show1(new Student3());
    }
}

2、返回值

基本类型: 当基本数据类型作为方法的返回值类型的时候，方法中return具体类型的数值即可
引用类型:
    数组：当数组作为方法的返回值类型的时候，将来需要在方法中return该一个数组的地址值
    具体的类：当类作为方法的返回值类型的时候，将来需要在方法中return该一个该类的对象
    抽象类：当抽象类作为方法的返回值类型的时候，将来需要在方法中return该一个该类的具体子类对象
    接口：当接口作为方法的返回值类型的时候，将来需要在方法中return该一个实现了该接口的具体子类对象

返回值为具体的类示例

class Student1{
    public void fun1(){
        System.out.println("李刚觉得自己是亿万富翁...");
    }
}

class StudentDemo1{
    //当类作为方法的返回值类型的时候，将来需要在方法中return该一个该类的对象
    public Student1 show1(){
        return new Student1();
    }
}


public class Demo1 {
    public static void main(String[] args) {
        StudentDemo1 studentDemo1 = new StudentDemo1();
        Student1 s1 = studentDemo1.show1(); // new Student1()
        s1.fun1();
    }
}

返回值为抽象类示例

abstract class Student2{
    public abstract void fun1();
}

class Student2Zi extends Student2{
    @Override
    public void fun1() {
        System.out.println("好好学习，天天向上！");
    }
}

class StudentDemo2{
    //当抽象类作为方法的返回值类型的时候，将来需要在方法中return该一个该类的具体子类对象
    public Student2 show1(){
        return new Student2Zi();
    }
}

public class Demo2 {
    public static void main(String[] args) {
        StudentDemo2 studentDemo2 = new StudentDemo2();
        Student2 s1 = studentDemo2.show1(); //Student2 s1 = new Student2Zi()
        s1.fun1();
    }
}

返回值为接口示例

interface Inter1{
    void fun1();
}

class Inter1Impl implements Inter1{
    @Override
    public void fun1() {
        System.out.println("好好学习，天天向上！");
    }
}

class Student3{
    //当接口作为方法的返回值类型的时候，将来需要在方法中return该一个实现了该接口的具体子类对象
    public Inter1 show1(){
        return new Inter1Impl();
    }
}


public class Demo3 {
    public static void main(String[] args) {
//        Student3 student3 = new Student3();
//        Inter1 i = student3.show1(); //Inter1 i = new Inter1Impl()
//        i.fun1();
//        Student3 s = new Student3();
//        Inter1 i = new Student3().show1(); //Inter1 i = new Inter1Impl()

        //当一个方法结果是一个对象的时候，可以继续.调用返回对象中的其它方法
        //像这种对象调用方法继续调用的编程方式，称之为叫做链式调用【链式编程】
        new Student3()
                .show1()
                .fun1();
    }
}

3、权限修饰符

                     public      protected       默认的     private
 同一类中                √           √               √           √
 同一包子类,其他类        √            √              √
 不同包子类              √            √
 不同包其他类            √


 目前为止学过的修饰符：
     权限修饰符：public,protected,默认的,private
     静态修饰符：static
     抽象修饰符：abstract
     最终修饰符：final

 类：
     权限修饰符：public,默认的
     抽象修饰符：abstract
     最终修饰符：final
 成员变量：
     权限修饰符：public,protected,默认的,private
     静态修饰符：static
     最终修饰符：final
 构造方法：
     权限修饰符：public,protected,默认的,private
 成员方法：
     权限修饰符：public,protected,默认的,private
     静态修饰符：static
     最终修饰符：final
     抽象修饰符：abstract

常见的修饰符组合：
     1、public static final
     2、public abstract

4、内部类

内部类：在一个类中定义一个类
    根据定义的位置不同，分为两种内部类
    成员内部类：将类定义在类中成员的位置【类中方法外】上
        常见修饰成员内部类的修饰词：
            private
            static

局部内部类：将一个类定义在一个方法的内部,只能在方法的内部使用

class Outer2{

    public void fun1(){
        //局部变量
        int a = 10;
    }

    public void show1(){
        int b = 11; // 若是被局部内部类使用的话，JDK1.8之后JVM默认会加上final
        //局部内部类
        class Inner{
            public void function(){
//                b = 22;
                System.out.println("好好学习，天天向上！");
//                System.out.println(b);
            }
        }
        b = 22;
        Inner inner = new Inner();
        inner.function();
    }
}

public class InnerClassDemo2 {
    public static void main(String[] args) {
        Outer2 outer2 = new Outer2();
        outer2.show1();
    }
}

匿名内部类

书写格式

匿名内部类：
    new 接口名/抽象类名(){
        //重写接口或者抽象类中的方法
    }

就意味着JVM在运行过程中做了几件事：
    1、JVM内部自己创建一个类
    2、这个类实现一个接口或者继承了一个抽象类
    3、将这个类的对象创建出来

interface Inter1{
    void fun1();
}

//class Inter1Impl1 implements Inter1{
//    @Override
//    public void fun1() {
//        System.out.println("李刚今天下午没有睡觉...");
//    }
//}
//
//class Inter1Impl2 implements Inter1{
//    @Override
//    public void fun1() {
//        System.out.println("江川今天下午睡觉了...");
//    }
//}

class Demo1{
    //当你看到一个接口作为方法参数类型的时候，将来调用时需要传入实现该接口的具体类对象
    public void show1(Inter1 inter1){ //Inter1 inter1 = new Inter1Impl1()
        inter1.fun1();
    }
}

public class NiMingClassDemo1 {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
//        demo1.show1(new Inter1Impl1());
//
//        demo1.show1(new Inter1Impl2());

        demo1.show1(new Inter1() {
            @Override
            public void fun1() {
                System.out.println("李刚今天下午没有睡觉...");
            }
        });

        demo1.show1(new Inter1() {
            @Override
            public void fun1() {
                System.out.println("江川今天下午睡觉了...");
            }
        });

        //扩展知识，今天不细说，最后一天的时候细说
//        demo1.show1(new Inter1() {
//            @Override
//            public void fun1() {
//                System.out.println("数加666");
//            }
//        });
        //若匿名内部类是一个接口的对象，且接口中只有一个抽象方法，就可以改写以下写法格式
//        demo1.show1(()->System.out.println("数加666")); // lambda表达式




    }
}

/*
    要求在控制台输出”HelloWorld”
 */
interface Inter3 {
    void show();
}


//class Inter3Impl implements Inter3{
//    @Override
//    public void show() {
//        System.out.println("HelloWorld");
//    }
//}

class Outer3 {
    //补齐代码
    public static Inter3 method(){
//        return new Inter3Impl();
        //使用匿名内部类改进
        return new Inter3() {
            @Override
            public void show() {
                System.out.println("HelloWorld");
            }
        };

//        return ()->System.out.println("HelloWorld");
    }
}

class OuterDemo {
    public static void main(String[] args) {
        //method方法是直接通过Outer3类名进行访问，method方法在Outer3是被static修饰的
        //调用完method方法之后还可以继续调用show方法，就说明method的返回值是一个对象
        //因为最后调用的是show方法，在这个程序中只有在接口中看到一个show方法
        //所以method的返回值类型是Inter3类型
        Outer3.method().show();
    }
}

包的划分

包的划分好处：
    1、方便管理我们的代码文件
    2、不同包下的文件名可以是一样的

常见的包命名规则：
    1、按照功能划分
        增加
            - 学生增加
            - 老师增加
        删除
            - 学生删除
            - 老师删除
        修改
            - 学生修改
            - 老师修改
        查询
            - 学生查询
            - 老师查询
    2、按照角色划分
        学生
            - 学生增加
            - 学生删除
            - 学生修改
            - 学生查询

        老师
            - 老师增加
            - 老师删除
            - 老师修改
            - 老师查询
若某一维度不会大幅度或经常性修改的话，就可以考虑将该维度定义成一个包

springboot中层划分:
    configs: 存放配置文件
    controller: 主要前端页面与后端交互的入口
    dao: 主要是与数据库操作相关的代码
    entity[pojo]: 实体类层
    service: 业务层