JAVA第十一课
跟日记本一起学JAVA！相信你可以的，加油~
本课闯关内容：1.照猫画虎（0/5）
2.基础知识(0/2）
这里的基础知识的编号与照猫画虎的编号不是对应的，而是上面的基础知识对应着下面的照猫画虎代码。
有补充或者有错误我会在评论区里发或...
建议你们在电脑上看。
———————————————————————————————————————————
基础知识1：
一、接口
概念 :
- 接口：是一种标准、规范，是接口的实现者和接口的使用者都必须遵循的约定。
- 接口的语法（规则）:
（1）接口的关键字:interface interface 接口{}
（2）接口编译之后会生成独立的 .class 文件
（3）接口不能创建对象，但是可以声明引用
（4）接口中的属性都是公开、静态、常量(默认的被 public static final 修饰)
（5）接口中的方法都是公开、抽象方法(默认的被 public abstract 修饰)
（6）接口中没有构造方法注意：接口不是类。
二、实现类
1.语法： class 类名 implements 接口名{}
2.注意：实现类实现接口，如果实现类不想成为抽象类，则需要实现(覆盖)接口中所有的方法；实现类实现接口中的方法时，方法的访问修饰符必须是 public 的访问权限。
3.应用（语法）：接口名 引用名 = new 实现类类名(实参);
注意：接口类型的引用指向 实现类的对象，多态的应用。-->强制使用多态
照猫画虎1：
package demo;
public class Test1{
public static void main(String[]args){
System.out.println(MyInter.a);
System.out.println(MyInter.b);
MyInter mi = new MyClass();
//接口 引用 实现类对象
//父类型 子类型 -->多态
mi.ma();
mi.mb();
}
}
//接口
interface MyInter{
public static final int a=9;//默认为：公开静态常量，静态属性
int b=3;//默认被public static final修饰
public abstract void ma();//默认为：公开抽象方法
void mb();//默认被：public abstract
}
//实现类：如果不想成为抽象类，则需要覆盖接口中的所有抽象方法
class MyClass implements MyInter{
public void ma(){
System.out.println("ma...");
}
public void mb(){
System.out.println("mb...");
}
}
输出：
9
3
ma...
mb...
基础知识2：
三、接口的继承性
- Java中的接口之间的继承关系是多继承，一个接口可以有多个父接口
（1）语法：interface 接口名 extends 父接口1,父接口2{} - 类和接口之间是多实现的关系：一个类可以同时实现多个接口
（1）语法：class 类名 implements 接口名1,接口2{}
（2)注意：一个类同时实现多个接口，如果这个类不想成为抽象类，则必须实现所有接口中所有方法；而且每一个方法的访问修饰符都是public - 一个类继承一个父类的同时可以实现多个接口
(1)语法：class 类名 extends 父类名 implements 接口名1,接口名2{}
(2)注意：必须是先继承后实现。(单继承多实现)
四、接口多继承的影响
1. 如果引用之间相互强制类型转换，转换的一方为接口类型的引用，则编译一定通过，但是运行的时候分以下两种情况：
(1)引用中实际存储的对象类型 和 要转换的类型一致，则运行通过
(2)引用中实际存储的对象类型 和 要转换的类型不一致，则运行报错，错误信息为： java.lang.ClassCastException(类型转换异常)
五、接口的作用
- 可以扩充子类的能力
(1)由于Java中类之间是单继承，当子类从父类中继承功能方法不足以满足子类功能需求时，可以借助接口扩充子类的能力。
(2)通常将主要功能定义在父类中，次要的功能(扩展的功能)定义在接口中。 - 降低程序中的耦合度
接口定义好之后，将接口的实现者和接口的使用者分离，借助多态，降低各模块之间的耦合度。
六、接口的回调
- 接口回调：接口定义之后，先有接口的使用者，再有接口的实现者。
- 注意：遇到接口回调的应用，开发人员需要关注的是根据接口规范，给予接口的实现部分。
总结：接口和抽象类的区别？
接口 抽象类
关键字 interface abstract class
属性 公开、静态、常量 没有要求(实例变量+静态变量+对final没有要求) public static final
方法： 公开、抽象方法 抽象方法+非抽象方法
public abstract
构造方法： 没有 有构造方法
继承关系： 多继承 单继承
Java 中的 final（final修饰变量时为常量）
1.修饰变量：表示不可重新赋值（常量）。
代码：
final int MAX_VALUE = 100;
// MAX_VALUE = 200; // 编译错误！不可修改
2.修饰类：类不能被继承。
代码：
final class ImmutableClass { /*...*/ }
// class Child extends ImmutableClass {} // 编译错误！
3.修饰方法：方法不能被子类重写。
重点：
final变量如果是基本类型（int,float...），值不可变；如果是对象，引用不可变（但对象内部状态可能可变，除非类本身不可变，如 String）。
照猫画虎2：
package demo;
public class Test2{
public static void main(String[]args){
ClassA ca = new ClassA();
IA ia =ca;
ia.m1();
}
}
interface IA{
public void m1();
}
interface IB{
public void m2();
}
//java中的接口与接口之间为多继承，类与类之间为单继承
interface IC extends IA,IB{
public void m3();
}
interface ID{
public void m4();
}
//类与接口为多实现：一个类可以同时实现多个接口-->一个类实现
class ClassA extends MyClass implements IC,ID{
public void m1(){
System.out.println("m1....");
}
public void m2(){}
public void m3(){}
public void m4(){}
}
class MyClass{
public void m5(){}
}
输出：
m1....
照猫画虎3：
package demo;
public class Test1{
public static void main(String[]args){
IA.mc();
//IA.mc();
IA ia= new ClassA();
ia.mb();
}
}
interface IA{
void ma();
public default void mb(){
System.out.println("mb...方法实现...");
}
public static void mc{
System.out.println("mc...方法的实现...静态方法...");
}
}
class ClassA implements IA{
public void ma(){}//抽象方法的覆盖变为实现方法，因为要引用对象要为实现类，
}输出：
mc...方法的实现...静态方法...
mb...方法实现...
照猫画虎4：
package demo;
public class TestMyClass{
public static void main(String[]args){
MyInter mi = new MyInterImpl();
int sum = mi.ma (5,3);
mi.mb();
System.out.println(mi.ma(5,3));
}
}
interface MyInter{
public int ma(int a,int b);
public void mb();
}
class MyInterImpl implements MyInter{
public int ma(int a,int b){
return a+b;
}
public void mb(){
System.out.println("mb实现");
}
}
输出：
mb实现
8
照猫画虎5：
interface MathTool {
long intPower(int m, int n);
boolean findFactor(int m, int n);
}
class MathToolImpl implements MathTool {
public long intPower(int m, int n) {
return Math.max(m, n);
}
public boolean findFactor(int m, int n) {
return (m + n) > 100;
}
}
public class TestMyClass1{
public static void main(String[] args) {
MathTool mathTool = new MathToolImpl();
int num1 = 50, num2 = 75;
long max = mathTool.intPower(num1, num2);
System.out.println(num1 + "和" + num2 + "中的较大值是: " + max);
int a = 60, b = 45;
boolean result = mathTool.findFactor(a, b);
System.out.println(a + "和" + b + "的和是否大于100: " + result);
int c = 30, d = 40;
boolean result2 = mathTool.findFactor(c, d);
System.out.println(c + "和" + d + "的和是否大于100: " + result2);
}
}输出：
50和75中的较大值是: 75
60和45的和是否大于100: true
30和40的和是否大于100: false
跟我一步步学，慢慢走。
未完待续。。。