一、包
包的划分好处：1、方便管理我们的代码文件2、不同包下的文件名可以是一样的常见的包命名规则：1、按照功能划分增加- 学生增加- 老师增加删除- 学生删除- 老师删除修改- 学生修改- 老师修改查询- 学生查询- 老师查询2、按照角色划分学生- 学生增加- 学生删除- 学生修改- 学生查询老师- 老师增加- 老师删除- 老师修改- 老师查询
若某一维度不会大幅度或经常性修改的话，就可以考虑将该维度定义成一个包springboot中层划分:configs: 存放配置文件controller: 主要前端页面与后端交互的入口dao: 主要是与数据库操作相关的代码entity[pojo]: 实体类层service: 业务层
二、形式参数
形式参数基本类型: 当基本数据类型作为参数传递的时候，传递是具体的数值引用类型:数组：当数组作为方法的参数类型的时候，将来需要传递数组的地址值具体的类：当你看到一个类作为方法的参数类型的时候，将来调用需要传入该类或该类的子类的对象抽象类：当你看到一个抽象类作为方法的参数类型的时候，将来调用需要传入该抽象类具体实现子类的对象接口：当你看到一个接口作为方法的参数类型的时候，将来调用需要传入实现了该接口的具体子类对象
具体的类：当你看到一个类作为方法的参数类型的时候，将来调用需要传入该类或该类的子类的对象
代码案例
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{@Overridepublic 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{@Overridepublic 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());}
}
三、返回值
返回值基本类型: 当基本数据类型作为方法的返回值类型的时候，方法中return具体类型的数值即可引用类型:数组：当数组作为方法的返回值类型的时候，将来需要在方法中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();}
}
当抽象类作为方法的返回值类型的时候，将来需要在方法中return该一个该类的具体子类对象
代码案例
abstract class Student2{public abstract void fun1();
}class Student2Zi extends Student2{@Overridepublic 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();}
}
当接口作为方法的返回值类型的时候，将来需要在方法中return该一个实现了该接口的具体子类对象
代码案例
interface Inter1{void fun1();
}class Inter1Impl implements Inter1{@Overridepublic 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();}
}
四、修饰符
权限修饰符：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 final2、public abstract
五、内部类
内部类：在一个类中定义一个类根据定义的位置不同，分为两种内部类成员内部类：将类定义在类中成员的位置【类中方法外】上常见修饰成员内部类的修饰词：privatestatic局部内部类：将一个类定义在一个方法的内部,只能在方法的内部使用
成员内部类
//class Outer{
// //成员方法
// int a = 10;
// //成员方法
// public void show1(){
// System.out.println(this.a);
// }
//
// //成员内部类
// class Inner{
// int a = 20;
// public void fun1(){
// int a = 30;
// System.out.println(a); // 30
// System.out.println(this.a); // 20
// System.out.println(Outer.this.a); // 10
// }
// }
//}class Outer{//成员方法int a = 10;//成员方法public void show1(){System.out.println(this.a);}//成员内部类
// private class Inner{
// int a = 20;
// public void fun1(){
// int a = 30;
// System.out.println(a); // 30
// System.out.println(this.a); // 20
// System.out.println(Outer.this.a); // 10
// }
// }static class Inner{int a = 20;public void fun1(){int a = 30;System.out.println(a); // 30System.out.println(this.a); // 20
// System.out.println(Outer.this.a); // 10}}// public void show2(){
// Inner inner = new Inner();
// inner.fun1();
// }}public class InnerClassDemo1 {public static void main(String[] args) {//创建成员内部类对象//外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
// Outer.Inner inner = new Outer().new Inner();
// inner.fun1();//若成员内部类使用static修饰的话，可以直接使用外部类名获取内部类的构造方法进行创建Outer.Inner inner = new Outer.Inner();}
}
局部内部类
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() {@Overridepublic void fun1() {System.out.println("李刚今天下午没有睡觉...");}});demo1.show1(new Inter1() {@Overridepublic void fun1() {System.out.println("江川今天下午睡觉了...");}});
