一、包
包的划分好处：
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{
@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());
}
}
三、返回值
返回值
基本类型: 当基本数据类型作为方法的返回值类型的时候，方法中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{
@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();
}
}
当接口作为方法的返回值类型的时候，将来需要在方法中return该一个实现了该接口的具体子类对象
代码案例
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();
}
}
四、修饰符
权限修饰符：
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
五、内部类
内部类：在一个类中定义一个类
根据定义的位置不同，分为两种内部类
成员内部类：将类定义在类中成员的位置【类中方法外】上
常见修饰成员内部类的修饰词：
private
static
局部内部类：将一个类定义在一个方法的内部,只能在方法的内部使用
成员内部类
//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); // 30
System.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() {
@Override
public void fun1() {
System.out.println("李刚今天下午没有睡觉...");
}
});
demo1.show1(new Inter1() {
@Override
public void fun1() {
System.out.println("江川今天下午睡觉了...");
}
});