接口实现业务逻辑课插拔，更换数据库直接改配置文件即可。
java环境配置
java 源代码运行必须先用javac编译生成字节码文件 XXX.class运行 java XXX 进行运行
环境变量classpath:已编译的字节码文件搜索路径--临时配置：set classpath=D:\JavaStudy //只在设置路径找类文件set classpath=D:\JavaStudy; //先设置路径找类文件，找不到去当前路径找分号后可以加多个路径--查看是否已存在环境变量：set classpath--
示例代码：
文件名 Hello.java
class Hello { //注释：class的名称要和文件名一致public static void main(String[] args) {System.out.print("Hello World !");}}
2-2关键字：public static void main class ... 特点小写蓝色
2-3 标识符 1、就是一个名字：对类名、变量名称、方法名称、参数名称等的修饰2、命名规则---以字母、下划线_或者$开头，其后可以是字母、数字、下划线或者$3、命名规范：---要求：见名知意例如单次password---要求：变量名称、方法名称、参数名等采用“驼峰”命名法-例如：firstName,getInfo,---要求：不超过15个字符 简写例如arguments 简写为：args 参数2-4 字面量(数据类型)1、根据当前的值(数据)可以得到当前值对应的数据类型2、常见字面量：---整数类型---浮点数---布尔类型：true、false---字符类型：‘a‘ ‘我‘单个---字符串类型："this is a dog"
2-5 进制见转换
2-6 字符编码1、ASCII‘a‘ --- > 97‘A‘ --- > 65‘0‘ --- > 48‘ ‘ --- > 322、GBK/GB2312:中文编码3、Unicode: 万国码
注意：Java 源代码采用的是unicode 字符编码2-7 变量1、存放数据2、常用数据类型：见字面量intdoubleboolStringchar3、声明变量：--- 语法：数据类型 变量名称如 int a;int a;int b;double c; //浮点数String d;4、赋值语法 变量名称 = 值a = 5;b = 6;c = 3.14;d = "我爱北京天安门";5、简化赋值语法格式：数据类型 变量名 值int a = 8;int b = 2018;double c = 3.14;String d = "我爱北京天安门";//使用System.out.println("年份：" + b );System.out.println("文字："+ d);System.out.println("圆周率：" + c);6、简化语法二//变量声明和赋值，简化语法，一行搞定int a = 8, b = 2018;double c = 3.14;String d = "我爱北京天安门";System.out.println("年份：" + b + "\n" + "文字："+ d + "圆周率：" + c );2-8 转义序列符\n 表示换一行\t 制表符tab 键盘\\ 表示输出一个\\" 输出一个"\‘ 输出一个‘\u0000 输出一个空格 :表示Unicode编码取值
2-9 变量的分类---按作用范围：局部变量：方法中的变量都是局部变量成员变量：在类中，方法外声明的
---按数据类型：基本数据类型变量:内存中存放的值例如：int double char ....引用数据类型变量:内存中变量存储的是0x开头的内存地址例如：String ...【内存分析】当程序运行后，JVM会自动分配内存空间---内存分析图：-栈：存放方法以及方法中的局部变量-堆：存放对象-方法区：代码片段、常量池(例如字符串的值)、静态属性
释义：---栈：数据出入走栈顶---堆：---【4大类基本数据类型】--- 整数类型--- 浮点类型--- 字符类型--- 布尔类型--------整数类型：子类型占用空间存储范围---byte：1字节-128~127---short：2字节-2的15次方~2的15次方-1---int：4字节2 正负32次方范围 【默认】---long：8字节2 的正负63次方范围--------浮点类型：子类型占用空间存储范围float4个字节-3.403E38 ~3.403E38double8个字节-1.798E3.08 ~ 1.798E3.8注意：范围小的类型不能直接赋值float x = 3.14;//报错：错误: 不兼容的类型: 从double转换到float可能会有损失---解决方法一：float x = 3.14f;//数字后面加f//自动类型转换---解决方法二：float y = (float)3.14;//强制类型转换：数字前面括号数据类型，进行强制类型转换-------字符类型：char注意：char类型只能存储一个字符。必须用单引号类型占用空间char2个字节---赋值可以和数字相互赋值，取值为ASCII对应的值char ch = ‘a‘;ch = 97;//字符类型取值范围0-65535System.out.println(ch);int i = 99;i = ‘A‘;System.out.println(i);-------布尔类型：boolean类型占用空间取值范围boolean一个字节true/false2-11 类型之间转换---自动类型转换：隐式---强制类型转换：强制
byte i = 1;short j = i;//自动类型转换int k = i;long k2 = k;
float x = k2;System.out.println(x);float a = (float)1.0;//强制类型转换int b = (int)9.9;//有损失b实际被赋值为9 2-12 类型转换6条规则---针对基本数据类型转换，除了boolean 类型外剩余7中基本数据类型之间进项相互转换---取值范围小的类型可直接给取值范围大的类型赋值，称为自动类型转换，也叫隐式类型转换 byte < short < char < int < long float < double 1字节 2字节 2字节 4字节 8字节 4字节 8字节---取值范围大的不能直接给取值范围小的类型直接赋值，需要进行强制类型转换，可能存在精度丢失，比如9.9 变成9---当对byte short char 类型赋值时，则没有超出该类型范围是可以直接赋值的。---当对byte short char 类型混合运算时，则先转为int。---当对多种类型进行混合运算时，类型最终为取值范围最大的那个类型。2-13 算数运算符+-*/%(取余数)++--//+//当两个数中有一个为非数值类型则做连接(从左到右)，最终为String类型int a = 3, b = 4;int sum = a + b;System.out.println("sum =" + sum);System.out.println("sum = " + a +b );System.out.println("sum = " + (a +b ));//-//++
//--int m = 5, n = 10;n = m--;//m = 4 n = 5System.out.println("m = " + m + "\tn = " + n);int x = 5 ,y = 6;x = --y;//x = 5 y = 5 注：y自身已经减去1，再赋值给x，所以y先变成了5，x重新赋值5，System.out.println("x = " +x +"\ty = "+ y);int a = 3, b = 4 ;b = a-- +2; // a = 2 b = 5 注：a做完运算才自身减去1 b 等于原来的a(3) + 2 = 5System.out.println("a = " + a + "\tb = " + b);2-14 连接运算符+
2-15 赋值运算符=扩展+= -= *= /= %=
//赋值运算符int sum = 0;//sum = sum +1 ;//sum = sum + 1int i = 3;//sum = sum *10 + i % 10;//sum = 3;sum *= 10 + i % 10;//sum = 0 即【sum = 0 * (10 + 3)】
2-16 关系运算符><>=<===!=注意：1、优先级别：算数运算符 > 关系运算符2、关系运算符最终结果为boolean 类型值
2-17 逻辑运算符符号意义逻辑与&并且逻辑或|或者逻辑异或^逻辑非!
短路与&&并且//短路与、逻辑与在执行结果上相同,执行过程不同，短路与效率更高，第一个为faslse，直接为falseSystem.out.println(10 > 1 && 6 != 7);//trueSystem.out.println(10 > 1 & 6 != 7);//ture//当使用短路&& 第一个判断条件为fasle 则直接判断为false；System.out.println(0 > 5 && 8 < 80 ); //falseSystem.out.println(0> 5 & 8 < 80 );//false
System.out.println(6 >= 6 && 3 >= 4 );//falseSystem.out.println(6 >= 6 & 3 >= 4);//false短路或 ||//短路或||//总结：短路或、逻辑或 在执行结果上相同，单执行过程短路或更高。第一个条件为true 直接为trueSystem.out.println(1 <= 2 || 4 != 9);//true 当左边满足条件后边的就不判断了System.out.println(1 <= 2 | 4 != 9);//tru
2-18 逻辑运算符区别&与&&：/短路与、逻辑与在执行结果上相同,执行过程不同，短路与效率更高，第一个为faslse，直接为false|与||：短路或、逻辑或 在执行结果上相同，单执行过程短路或更高。第一个条件为true 直接为true2-19 三目运算符也叫条件运算符语法格式： 条件 ？代码1： 代码2
类似Python的三元运算String s = 1 > 10 ? "是":"否";//条件满足取值:前，不满足取值:后System.out.println("s = " + s);//简写int num = 23;System.out.println(num > 0 && num < 99 ? "是两位数":"不是两位数");
//多个条件组合
2-20 接收键盘输入import java.util.Scanner;//导入软件包//创建Scanner(扫描仪) 对象Scanner input = new Scanner(System.in);//提示语System.out.print("请输入一个数");//键盘接收用户输入int num = input.nextInt();System.out.println("num = " + num);//组合判断赋值System.out.println("num = " + ( num % 2 == 0 ? "偶数" : "奇数"));//先算出后面的字符串再 组合所以要括起来
String s = input.next();//Java中不能接收字符类型，需要接收字符串再从字符串中取0位char sex = s.charAt(0);
3-1 程序流程控制三大结构循序结构：顺序执行选择结构：循环结构：3-2 选择结构ifif(条件){ 代码块}
if(score >= 95){System.out.println("O(∩_∩)O哈哈~！ 恭喜");}else if(80 < score && score < 95){System.out.println("及格！");}else{System.out.println("不及格哦");}三目运算/三元运算：System.out.println(score > 95 ? "O(∩_∩)O哈哈~！ 恭喜" : score >= 80 ? "恭喜及格！": "很遗憾，继续努力哦");3-3 字符串比较== 是比较内存地址String.equals(); 是对比值if ("第一名".equals(info)){System.out.println("奖励十万");}
3-4 switch case适用于等值操作switch(info){case "第一名":System.out.println("奖励10W");break;case "第二名":System.out.println("奖励5W");break;default:System.out.println("无奖励！");break;注意事项：1、case值的顺序可以颠倒。2、default 位置先和都可以，建议编写在最后3、case 后面的break必须有，否则会穿透。3-5 多重if 和switch case---多重if 选择结构：可以做区间操作+ 等值操作---switch case 只能做等值操作
4 循环结构4-1 重复事情：好处：减少代码特点：循环条件、循环体常用循环：for、while、do while4-2 for 循环语法：for(表达式1;表达式2;表达式3){ 循环体语句}注意：表达式1 完成变量初始值，如int i = 1；表达式2 完成循环条件判断，如果添加为true，执行循环体，否则结束for循环；如i <= 5;表达式3 完成变量值的更改(更新)循环体 重复做的事儿【注意】1、表达式1、2、3 都可以省略，但是;不可省略2、表达式1省略，可以在for循环前定义3、省略表达式2、3、出现死循环。4、省略表达式3、可以在循环体中补充。示例1：for(int i = 1; i <= 8 ; i++){System.out.println("第" + i + "遍 Hello world！");}示例2://循环结合附加条件-中间换行int count = 0;for (int i = 100;i <= 999 ; i++ ){if (i % 7 == 0){System.out.print(i + "\t");count += 1;if(count % 5 == 0 ){System.out.println();}}
}
4-3 while循环语法格式：while(循环条件){ 循环体}代码示例：while(i <= 100){//System.out.println( i % 5 == 0 ? i: null);if(i % 4 == 0){System.out.print(i + "\t");count++;if (count % 5 == 0 ){System.out.println();}}i++;}4-4 do while循环语法格式do{ 循环体}whil(循环条件)执行流程先执行循环体，后进行循环条件判断示例代码：Scanner input = new Scanner(System.in);String info ; //循环体外声明条件判断变量，否则while判断时编译错误do{System.out.println("编写代码");System.out.println("老师检查");info = input.next();
}while("不合格".equals(info));System.out.println("合格");
4-7 三种循环异同点1、格式2、循环次数：次数固定：建议for次数不固定：建议while do while先判断再循环：while先循环再判断：do while3、例：第一次为false---for 0次循环---while 0次执行循环体---do while 1次执行循环体总结：for: 0----N次while：0 ---N次do while 1--- N次
4-8 break ,continue...
4-9 break 与 continue 的区别---场景break : switch case,以及循环中都可以用continue 只能在循环中使用---作用不同break：表示中断，结束当前整个循环，或者结束switch case 语句continue：结束当次循环，继续下一次循环...5 方法
5-1 方法分类定义定义：也叫函数分类：系统方法、用户自定义方法
5-2 自定义方法(函数)语法格式：[修饰符] 返回类型 方法名称([参数列表]){方法体}场景1：无参数、无返回。返回类型写 void 注意一：1、[] 中的内容可有可无，暂时修饰符 编写为public static2、返回类型：第一种，无返回类型，写void第二种，有返回类型，也就是编写为目前所学 9 中数据类型之一3、方法(函数)名称：注意二：1、方法要编写再类中2、必须包含main方法在main方法中调用自定义方法例如：Method01.print();class Method01{/*[修饰符] 返回类型 方法名称([参数列表]){方法体}*/public static void print(){//方法内输出5遍HelloWorldfor (int i = 1; i <= 5 ;i++ ){System.out.println("第" + i + "遍Hello World！");}}//在main方法中调用方法public static void main(String[] args){Method01.print();}}
方法调用：格式: 类名.方法名()注意: 本类中的类名.可以省略
调用过程：1、方法执行，需先进栈2、方执行完毕，方法出站。3、栈特点，先进后出。
示例代码一：无参数有返回public static int sum(){Scanner input = new Scanner(System.in);System.out.print("请输入第一个数字：");int i1 = input.nextInt();System.out.print("请输入第二个数字：");int i2 = input.nextInt();int s = i1 + i2;return s;//返回}示例代码二：有参数，有返回public static int sum(int i1,int i2){ //形参return i1 + i2;}public static void main(String[] args){Scanner input = new Scanner(System.in);System.out.print("请输入第一个数字：");int i1 = input.nextInt();System.out.print("请输入第二个数字：");int i2 = input.nextInt();int count =Method04.sum(i1,i2);System.out.println(count);}示例代码三：返回boolean值//水仙花计算水仙花数有哪些class Method04{public static boolean isFlower(int num){//判断百位、十位、各位数分别是什么：十位数计算只有需注意/10 再取余数兼容两位数和三位数int bw = num /100,sw = num / 10 % 10,gw = num % 10;int sum = bw * bw * bw + sw * sw * sw + gw * gw * gw;return sum == num;//返回true or false
}}
class Method05{public static void main(String[] args){for(int i = 1;i <= 999 ; i++){if (Method04.isFlower(i))//直接用返回值是true就执行打印{System.out.println(i);}}}}
5-3 总结break 、 continue 、 return 区别break：中断continue：循环中跳过当次return：只能在方法中使用，{ ......; return }【return】无返回方法(void) 中可以使用return; 但不能返回任何值【return】后，不能再写其他语句，否则编译错误：无法访问的语句5-4 方法的重载一个类中，多个重名方法。条件：方法名必须相同，单参数列表必须不同(个数、类型、顺序)，与返回值无关示例代码：class MethodRepeat{public static void main(String[] args){//计算两个值中哪个大System.out.println(max(123,234));//使用于都是int或者都是double类型的判断}//max 方法重载public static int max(int x,int y){//第一个max 参数int类型return x > y ? x : y ;}public static double max(double x , double y){ //第二个max 参数double类型return x > y ? x :y ;}}6 面向对象==============================封装、继承、多态===========================
6-1 概念：1、同一类事物的抽象描述，不是具体的2、类和对象的关系：类 是抽象的。对象 是具体的。3、对象的体征，称为“属性”4、多个 对象的方法 + 属性 相同 构成一类6-2 类的编写构成。
第一步 语法： [修饰符] class 类名 {}注意：1、修饰符可有可无，如果写，类名和文件名必须相同。2、类名驼峰命名法。
第二步：类的属性-即 成员变量。语法格式：[修饰符] 数据类型 属性名称
注意：1、修饰符可有可无2、驼峰命名法3、不同数据类型，声明后有默认值(仅在成员变量中)。默认值整数类型：0浮点类型：0.0字符类型：\u0000 就是空格布尔类型：false引用类型：null6-3 编写测试类.即包含main方法的类
6-4 创建对象语法：类名 引用名称(实例名称) = new 类名()
访问对象中的属性和方法：实例名称.属性名称示例代码：class Student{//属性变量的默认值String name;//nullint age;//0double weight;//0.0char sex;//\u0000
public void print(){System.out.println(age);}/*public static void main(String[] args){print();//错误: 无法从静态上下文中引用非静态 方法 print()}*/
}
//编写测试类class StudentTest{public static void main(String[] args){Student s1 = new Student();s1.print();//调用对象的方法System.out.println(s1.weight);//调用(访问对象属性)}}访问对象中的方法：实例名称.方法名称();示例代码：class Student{//属性变量的默认值String name;//nullint age;//0double weight;//0.0char sex;//\u0000
public void print(){System.out.println(age);}/*public static void main(String[] args){print();//错误: 无法从静态上下文中引用非静态 方法 print()}*/
}
//编写测试类class StudentTest{public static void main(String[] args){Student s1 = new Student();s1.print();//调用对象的方法System.out.println(s1.weight + s1.name + s1.sex + s1.weight);//调用(访问对象属性)}}类中变量区别：--成员变量：没有赋值时有默认值，数据类型不同，则默认值不同。--局部变量：没有初始值，也就是说必须先声明，在赋值，然后才能使用//否则编译错误----局部变量名可以和成员变量同名，方法内调用时就近原则示例代码：class Car{String id ;String color ;
public void show(){String id = "冀H D8888";System.out.println("局部变量：" + id);System.out.println("实例变量：" + this.id); //方法中引用成员变量，使用this}}class CarTest{public static void main(String[] args){Car c1 = new Car();//实例化类c1.show();c1.id = "京 A 00000";c1.show();//给实例变量赋值}}6-5 构造方法：对成员变量赋值语法格式：public 类名([参数列表]){ 完成对成员变量赋值
}注意：1、构造方法名必须和类名一致。2、必须没有返回值类型，也就是不编写任何返回值类型示例：
3、构造方法，创建对象时自动执行4、分类：-------隐式构造方法：在一个类中，如果没有手动编写构造方法，则系统会提供一个默认的无参 的构造方法
-------显式构造方法: 手动编写的构造方法。如果手动编写了，则系统不会提供无参的构造方法建议：手动编写构造方法之前，先编写无参构造方法，再编写需要的构造方法5、构造方法重载： 同一个类中，同名，参数不同的多个构造方法代码示例：
class Dog{//有参构造方法,完成对成员变量(类的属性)的赋值public Dog(String strain,String color,int age,String name){this.strain = strain;this.color = color;this.age = age;this.name = name;}//无参数构造方法public Dog(){}//类的属性定义(成员变量)String strain;String color;int age;String name;//类的方法，public void jiao(){System.out.println(this.name + ": \t汪汪汪.......");}//类的方法public void show(){System.out.println("品种:"+ this.strain + "\n颜色："+ this.color + "\n狗龄："+ this.age + "\n名字：" + this.name );}}//测试类class DogTest{public static void main(String[] args){//测试有参构造方法创建实例System.out.println("============有参数构造方法 创建的中华田园犬===============");Dog d = new Dog("中华田园犬","黄",2,"旺财");d.show();d.jiao();//测试无参数构造方法创建实例System.out.println("============无参数构造方法 创建的默认狗===============");Dog d2 = new Dog();d2.show();d2.jiao();}}
6-6 变量按数据类型分类：---基本数据类型变量，在内存中存放真正的值。4大类 8种---引用数据类型变量，在内存中存放地址(引用) 如String 自定义类型变量引用类型数据变量6-7 空指针异常实例化一个类，然后赋值为null。再调用报错：Dog d2 = new Dog();d2.show();d2.jiao();System.out.println("=================狗=null; 再 show()报空指针异常========================");d2 = null;d2.show();6-8 封装：this关键字目的：避免不符合实际意义的【成员变量赋值】关键步骤：1、将类属性设置为 private 私有的 (类中的)，只能在当前类中使用2、编写对应属性的赋值get和取值get方法注意：this关键字代表当前对象this可以访问本类/父类中的实例方法this(参数列表...)对构造方法复用，访问本类中的其他构造方法，而且必须必须在构造方法中的第一条语句----否则出现递归调用。
6-9 对象作为参数传递。对象的值被改变则原始值也被改变测试代码：class Student{String name;int age;public Student(){}public Student(String name, int age){this.name = name;this.age = age;}}
//引用对象进行赋值，实际是将内存地址进行赋值，两个对象实际是一个。class StudentTest{public static void change(Student s,String name){System.out.println("改变对象 s.name " + s.name +"===>" + name);s.name = name;}public static void main(String[] args){
Student stu = new Student("小赵",23);System.out.println("stu.name = " + stu.name);change(stu,"小唐");System.out.println("stu.name = " + stu.name);}}6-10 static 干啥的？
多个对象，有重复的属性&值相同，则只需要存储一次，所有对象中都可以直接访问。代码中如何编写？答：【使用static 修饰】例如：static String address = "北京"; //静态属性将放到“方法区”当中特点：---【静态属性】1、所有对象都可以访问2、使用static 关键字修饰后是静态属性，也称为类属性3、静态属性与类同生死4、访问静态属性：以下方法都可以访问类名.属性名称引用名称.属性名称(含引用名称 = null场景)5、类优先于对象
---【静态方法】也叫做类的方法静态方法访问：类名.方法名称(参数列表)对象.方法名称(参数列表)---【静态方法中只能使用静态属性和静态方法】---非静态方法：可以访问静态属性和静态方法，也可以访问实例属性和实例方法6、static{}静态代码块//静态代码块对静态属性赋值static{address = "北京市";System.out.println("执行了静态代码块");}//测试静态代码块赋值过程Student s2 ;//作为类型时没有执行静态代码块//s2 = new Student();//实例化时执行了静态代码块System.out.println(Student.address); //或者被调用
7类的继承修饰符 class 子类名 extends 父类名{}自定义类默认隐藏式继承了Object类class Cat {...}等价于如下class Cat extends Object{.........}注意：1、没指定继承哪个父类，默认继承Object2、在Java中Object类是所有类的父类3、子类继承父类时，不能继承父类的构造方法【这一点不如Python】4、父类叫做基类，子类叫做派生类5、满足条件is a6、一个类只能继承一个直接父类7、类继承具有传递性。7-1 重写父类方法---子类的方法名、参数列表、修饰符一致---子类的返回类型一致或父类方法返回类型的子类型：例如：String 是Object的子类型int 是 Double的子类型注意事项：1、super.方法/变量。直接访问父类的资源2、如果不写，默认为访问本类中资源即隐含了this.3、如果子类重写父类的方法体中，有调用被重写的方法，则只能使用super4、访问父类中的实例变量可以是this. 也可以是super. 但是范围子类独有的实例变量/方法 只能用this5、super(); super([参数列表])完成对父类构造方法赋值 7-2 父类中含有构造方法 在子类中重写public 类名([参数列表]){ 完成对成员变量赋值; super(参数); //完成对父类构造方法赋值}示例代码：class Persion{String name;char sex;int age;//无参构造public Persion(){}//有参构造public Persion(String name, char sex, int age){this.name = name;this.sex = sex;this.age = age;}
public void sayHi(){System.out.print("Hi 大家好！我的名字:" +this.name+ "\t性别：" + this.sex + "\t年龄："+ this.age );}}
class Student extends Persion{//子类特有属性int id;String grade;
//子类的无参构造方法，执行父类无参构造public Student(){super();}public Student(String name, char sex, int age, int id, String grade){//执行父类构造方法super(name,sex,age);//对子类特有属性赋值this.id = id;this.grade = grade;}
//重写父类方法public void sayHi(){super.sayHi();//调用父类的方法System.out.println("\t学号：" + this.id + "\t班级：" + this.grade);//合并自己的特有输出}}
class StudentTest{public static void main(String[] args){Student s = new Student();s.sayHi();Student s2 = new Student("唐东",‘男‘,22,1234,"金山班");s2.sayHi();}}7-3 实例化子类过程中发生了什么？子类名obj = new 子类();执行了父类对应构造如果不执行super(name,sex,age)，而子类构造方法中直接执行对父类的成员变量赋值，例如如下：/*this.name = name;则默认会执行super()父类无参构造一次则：需注意,构造方法无参的无用也要写上避免出现错误
7-4 多态特性 (向父类转型)语法：父类类名 引用名称 = new 子类类名();注意，引用名称.只能访问父类的实例属性和实例方法，如果子类重写了父类的方法，则优先访问子类的方法。
效果：多个对象，调用同一个方法，输出不同的结果Vehicle v = new Car();System.out.println("小汽车默认租金"+ v.getSumRent(1));v = new Bus();System.out.println("大汽车默认租金"+ v.getSumRent(1));满足条件：子类必须继承父类子类必须重写父类方法满足语法: 子类类名 引用名称 子类类型典型示例代码：//宠物类，作为父类，都会吃class Pet{public void eat(){System.out.println("宠物正在吃东西....");}}
class Dog extends Pet{public void eat(){System.out.println("正在吃狗粮");}}
class Cat extends Pet{public void eat(){System.out.println("正在吃猫粮");}}//各种宠物吃的不同...省略class Master{public void feed(Pet pet){pet.eat();}}
class MasterTest{public static void main(String[] args){Master m = new Master();Cat c = new Cat();Dog d = new Dog();//效果，主人直接用一个喂方法喂不同的宠物。m.feed(c);m.feed(d);}}
向子类强制转型(父类创建对象，引用子类变量/方法)：语法：子类类型 引用名称 = (子类类型) 父类对象示例Pet c = new Cat();Cat c1 = (Cat)c ;c1.catching();7-5 抽象类使用abstract 修饰的类就是抽象类，方法抽象，则所在类必须为抽象类子类继承了抽象类，必须重写抽象类的方法，否则子类也要定义为抽象类抽象类不能失礼话对象，抽象类定义的引用(变量)需要复制子类对象胡总匿名内部类对象抽象类虽然不能实例化对象，但是有构造方法，可以再抽象类中定义失礼方法，静态变量，静态方法，实例变量
7-6 匿名内部类对象：抽象类名 引用名称 = new 抽象类名{@Overridepublic void eat(){抽象方法体.... }}注意：抽象
8 接口定义方法：[修饰符] interface 接口名 { 功能用方法表示，接口洪方法默认 public abstract 修饰}示例代码：package interfaces;
public interface Flyable { //定义一个接口，功能用方法描述 默认public abstract void fly();}
使用接口方法[修饰符] class 类名 implements 接口 {类实现了接口，需要重写接口的抽象方法}示例代码//Plane.javapackage interfaces;
public class Plane implements Flyable { //重写接口的抽象方法 @Override public void fly() {System.out.println("飞机在天上飞"); }}//Bird.javapackage interfaces;/*小鸟有飞行功能，消息实现Flyable接口需要重写接口的抽象方法 */public class Bird implements Flyable { @Override public void fly() {System.out.println("小鸟会飞"); }}
//测试类//Test.javapackage interfaces;
public class Test { public static void main(String[] args) {//接口是引用数据类型，不能实例化对象//Flyable f = new Flyable();//【接口引用需要赋值实现类对象】Flyable b = new Bird();//通过接口引用调用抽象方法时，实际执行的是实现类对象的方法，实际是多态b.fly();Flyable p = new Plane();p.fly();//也可以实现匿名类对象使用 new Flyable() { @Override public void fly() {System.out.println("猪在飞"); }}.fly();//f.fly(); }}
接口注意：//接口引用赋值实现类对象//接口中的字段默认为认public static final 修饰 所以调用直接使用接口名称调用//接口的静态方法只能直接通过接口名称调用//default方法没有是用static修饰只能通过对象访问示例代码：//Myinterface.javapackage interfacecontent;
public interface MyInterface { //接口中 方法默认public abstract 修饰 void m1();
//接口中字段，默认public static final 修饰 int xx = 123;
//在JDK8 中可以定义static 静态方法 static void sm(){System.out.println("在JDK8 中可以定义静态方法"); } default void dm(){System.out.println("在JDK8 中可以定义default 方法，在实现类中可以重写，可以不重写"); }}//Myclass.javapackage interfacecontent;
public class Myclass implements MyInterface{ //实现类中必须重写接口的抽象方法：static 和 default方法除外 @Override public void m1() {System.out.println("重写了接口的抽象方法"); }}//Test.javapackage interfacecontent;//使用接口的抽象方法public class Test { public static void main(String[] args) {//MyInterface m = new Myclass();//接口引用赋值实现类对象m.m1();//通过接口引用调用抽象方法，实际执行的是实现类对象的方法
//接口中的字段默认为认public static final 修饰 所以调用直接使用接口名称调用System.out.println(MyInterface.xx);
//接口的静态方法只能直接通过接口名称调用MyInterface.sm();System.out.println(Myclass.xx);//default方法没有是用static修饰只能通过对象访问m.dm(); }}
8-1 接口说明：1、接口可以简单看做功能的封装，功能用方法表示，接口中方法默认public abstract 修饰2、类实现了接口，扩展接口功能，需要重写接口的抽象方法，如果没有重写，则该类需要定义为抽象类3、接口是一种引用数据类型，单接口不能实例化对象，接口的引用赋值实现类对象或者匿名内部类对象，通过接口引用嗲用抽象方法时，实际执行的是实现类对象的方法 也叫接口多态4、接口内容：接口方法 默认public abstract 修饰，接口字段(属性)默认public static final 修饰5、在JDK8中，接口还可以定义static 静态方法和 default 方法. 静态方法与default方法主要用于接口功能的扩展上。6、接口支持继承，并且支持多继承 public interface RunnableFuture<V> extends Runnable,Future<V>{}7、一个类在继承父类的同事可以实现多个接口，需要重写所有接口的所有抽象方法 public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.ioSerializable {}8-2 接口和抽象类的区别相同点：都可以定义抽象方法都不能实例化对象不同点；1、接口 是功能的封装，解决对象能干什么；抽象类是事物的抽象，解决对象到底是什么；2、内容不同，接口抽象类含构造方法、实例变量实例变量/方法，静态变量/方法3、接口支持多继承，类只允许单继承4、扩展功能优先选择接口8-3 接口的应用1)封装某个功能2)或者看做一组操作规范3)某种程度上可以解决类的多继承问题【提倡面向接口编程】1、接口使用灵活，一个类在继承父类同时，可以实现多个接口2、面向接口编程可以体现面向抽象思想，降低类的偶合度。3、接口可以使项目分层，实现代码的可插拔
原文：https://www.cnblogs.com/zhangmingda/p/11970570.html