Java学习每日总结五

大学自学Java（五）

学习的五天，会分享学习中有意思值得深挖的部分或难点

接口

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型
它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做 是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象 类。

public interface InterFaceName { 
//抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。
public abstract void method(){
}
//默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。     
public default void method1() {         
// 执行语句     }  
//静态方法：使用 static 修饰，供接口直接调用。
public static void method2() {         
// 执行语句         
} 
//私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。(java9开始有)

private void method() {         
 // 执行语句     
 } 
}

抽象方法例子

public interface LiveAble {     
// 定义抽象方法     
public abstract void eat();     
public abstract void sleep(); 
}
public class Animal implements LiveAble {     
@Override     
public void eat() {         
System.out.println("吃东西");     
}       
@Override     
public void sleep() {         
System.out.println("睡");     
} 
}

默认方法例子

public interface LiveAble {     
public default void fly(){         
System.out.println("飞");     
  } 
}
public class Animal implements LiveAble { 
// 继承，什么都不用写，直接调用      
}
public interface LiveAble {     
public default void fly(){         
System.out.println("飞");     
} 
}

静态方法的使用

public interface LiveAble {     
public static void name(){         
System.out.println("方唉唉");     
} 
}
public class Animal implements LiveAble { 
// 无法重写静态方法      
}

接口的多继承

class 类名 extends 父类名 implements 接口名1,接口名2,接口名3... {     // 重写接口中抽象方法【必须】    
// 重写接口中默认方法【不重名时可选】    
}

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。
接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法

接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继 承父接口的方法。

多态

多态是继封装、继承之后，面向对象的第三大特性。
是指同一行为，具有多个不同表现形式。
多态的前提

1. 继承，实现
2. 方法重写
3. 父类引用指向子类对象

public abstract class food {       
     public abstract void eat();   
} 
class Race extends food {       
   public void eat() {           
   System.out.println("吃饭");       
}   
}     
class cai extends food {       
public void eat() {           
System.out.println("吃菜");       
}   
}
public class Test {     
public static void main(String[] args) {         
// 多态形式，创建对象         
Race c = new Race();           
cai d = new cai();            
// 调用showCatEat          
showRaceEat(c);         /
/ 调用showDogEat
 showcaiEat(d);            
 /*         
 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代        而执行效果一致         
 */         
 showfoodEat(c);         
 showfoodEat(d);      
 }       
 public static void showRaceEat (Race c){         
 c.eat();      }       
 public static void showcaiEat (cai d){         
 d.eat();     }       
 public static void showfoodEat (food a){         
 a.eat();     
 } 
 }

向上转型

多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。

向下转型

父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
格式
子类类型 变量名 = (子类类型) 父类变量名;
原因
想要调用子 类特有的方法，必须做向下转型。
转型过程中最好使用instanceof方法
变量名 instanceof 数据类型 如果变量属于该数据类型，返回true。 如果变量不属于该数据类型，返回false

public class Test {     
public static void main(String[] args) {         
// 向上转型           
Animal a = new Cat();           
a.eat();               
// 调用的是 Cat 的 eat           
// 向下转型           
if (a instanceof Cat){             
Cat c = (Cat)a;                    
c.catchMouse();        
// 调用的是 Cat 的 catchMouse         
} else if (a instanceof Dog){             
Dog d = (Dog)a;                    
d.watchHouse();       
// 调用的是 Dog 的 watchHouse         
}     
}   
}