day02面向对象
接口
是java中的一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法、默认方法和静态方法。
使用关键字interface，它也会被编译成.class文件。
抽象类：类中方法不明确做什么，定义为抽象方法，用abstract修饰，没有{}主体。
一个抽象类中，定义了n个方法，全都是抽象的，这个再被称为类就不合适了，更贴切的名字叫接口（方法的集合，抽象）；理解为全是抽象方法的抽象类----接口。
接口的定义：
使用关键字interface
格式：
public interface 接口名字（类名）
public interface MyInterface {
}
----------------------------------------------------------
接口中成员的定义：（JDK版本不同，定义的内容不同）
JDK1.7版本和他之前：
可以定义两种成员：
1.成员变量（固定的修饰符）
public static final 数据类型 变量名=值
public static final int A=1;
2.成员方法（固定的修饰符）
public abstract 返回值类型 方法名（参数列表）；
public abstract void inter();
接口中的修饰符，可以省略不写！
----------------------------------------------------------
接口的使用——实现类实现接口
使用方式：
1.接口不能new对象
抽象类中有抽象方法和非抽象方法，子类继承后，非抽象方法可以直接被使用，抽象方法需要重写。而接口中全是抽象方法，接口和类称为实现关系。
抽象类中是继承，接口中是实现！！！
2.定义类实现接口（实现类实现接口）
关键字：implements
3.重写接口中的全部抽象方法
4.创建接口实现类对象，也就是new（实现类/子类）
----------------------------------------------------------
支持接口的多实现（一个类可以实现多个接口）
定义格式：
public class A implements 接口1，接口2，接口3{}
public interface MyInterface implements A,B,C{}
实现类重写所有实现的接口中的全部抽象方法。
一个类可以继承另一个类，同时可以实现多个接口。
public interface MyInterface extends C implements A,B{
接口中的多继承（一个接口可以继承多个接口）
public interface MyInterface extends A,B{
----------------------------------------------------------
接口在JDK1.8版本中进行了修改：
1.接口中添加了静态、非抽象方法；（接口名.方法名（）进行调用）
public interface MyInterface{
//1.接口中添加了静态、非抽象方法；
public static void staticMethod(){
System.out.println("接口中的静态方法");
}
}
public static void main(String[] args) {
//使用接口中的静态方法
//接口名.方法名（）
MyInterface.staticMethod();
}
2.接口中添加了默认非抽象方法。（默认方法只能被实现类调用）也就是impl实现接口，然后再调用。
public interface MyInterface{
//2.接口中添加了默认非抽象方法。
public default void defaultMethod(){
System.out.println("接口中的默认方法");
}
}
public class MyInterfaceImpl implements MyInterface {
}
public class Test {
public static void main(String[] args) {
MyInterfaceImpl myInterface = new MyInterfaceImpl();
myInterface.defaultMethod();
}
}
注意：对于接口的默认方法，可以被实现类对象impl调用；实现类impl也可以重写默认方法（但是不能有default关键字）。
public interface MyInterface{
public default void defaultMethod(){
System.out.println("接口中的默认方法");
}
}
public class MyInterfaceImpl implements MyInterface {
public void defaultMethod(){
System.out.println("实现类impl重写默认方法");
}
}
public class Test {
public static void main(String[] args) {
MyInterfaceImpl myInterface = new MyInterfaceImpl();
myInterface.defaultMethod();
}
}
----------------------------------------------------------
对象的多态性
多态：一个事物的多种形态。
多态的前提：
1.要有继承父类或者接口实现（一个即可）
2.要有方法的重写
3.父类或者接口的引用指向子类的对象（代码的实现）
父类引用 = 子类对象
Person p = new Student()
public abstract class Animal {
public abstract void eat();
}
public class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
//程序中的多态，子类继承父类（抽象类）的形式
Animal animal=new Cat();
animal.eat();//执行子类的方法重写
----------------------------------------------------------
对象多态性使用的细节：
成员变量：
编译：检测父类中是否有这个变量，如果有编译成功，否则失败
运行：运行的是父类中的变量
成员方法：
编译：检测父类中是否有这个变量，如果有编译成功，否则失败
运行：运行的是子类的重写
比如：Fu fu=new Zi（）；
精简：（编译就看检测，方法就是运行）
变量：编译运行看左边
方法：编译看左边，运行看右边
public class Fu {
//变量
String str="父类";
//方法
public void show(){
System.out.println("父类方法show");
}
}
public class Zi extends Fu {
//变量
String str="子类";
//方法
public void show(){
System.out.println("子类重写方法");
}
}
public class Test {
public static void main(String[] args) {
//创建子类对象，多态性
Fu fu=new Zi();
// 变量：编译运行看左边
System.out.println(fu.str);//输出父类
// 方法：编译看左边。运行看右边
fu.show();//输出子类重写方法
}
}
编译运行原理：
----------------------------------------------------------
多态的好处和弊端：
好处：对子类可以进行扩展，执行子类方法的重写
弊端：多态中，只能调用子类和父类的共有成员，不能调用子类的特有成员
如果，必须调用子类的成员，需要转型
强制转换的安全判断：关键字instanceof
在类型转换之前，进行判断，否则可能出现类型转换异常（因为animal之前可能被赋值为cat，当你再想要将animal转换成dog的时候，需要进行判断才行，否则cat无法直接强转为dog）
public abstract class Animal {
public abstract void eat();
}
public class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
//Cat猫类，添加自己特有功能
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
public class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
//Dog类，添加自己的特有功能
public void lookDoor(){
System.out.println("狗看门");
}
}
public class Test {
public static void main(String[] args) {
Animal animal=new Cat();
animal.eat();
//Cat对象，提升为父类类型
//类型强制转换，animal类型转换成Cat
//出现ClassCastException,类型的转换异常 对象是Dog,强制转成Cat
//解决异常出现的问题: 对象是Dog,强制转为Dog, 对象是Cat,强制转为Cat
// 关键字,也是比较运算符 instanceof 计算结果 true,false
// 变量名 instanceof 类名 例子: animal instanceof Cat animal类型是不是Cat对象
// boolean b = animal instanceof Dog;
// System.out.println(b);
//类型转换前,进行判断
if(animal instanceof Cat){
//转换，animal类型转换为Cat
Cat c=(Cat)animal;
c.catchMouse();
}
if(animal instanceof Dog){
//转换,animal类型转为Dog
Dog d=(Dog)animal;
d.lookDoor();
}
}
}
----------------------------------------------------------
接口的作用（笔记本案例）：
接口就是一个对外暴露的规则，只要满足此规则，就可以被使用。
接口中的权限，固定为public，解开耦合性。
/**
* 定义接口: USB接口
* 定义2个规则,开启和关闭
*/
public interface USB {
public abstract void open();
public abstract void close();
}
/**
* 定义笔记本类
* 开机,关机,使用USB接口上的外接设备功能
*/
public class Computer {
//开机
public void powerOn(){
System.out.println("笔记本开机");
}
//关机
public void powerOff(){
System.out.println("笔记本关机");
}
/**
* 使用USB接口上的外接设备功能
* 什么设备,不确定,设备很多
* 但是: 确定这些设备都实现USB接口
*
* 方法的参数列表的具体含义
* 参数是方法在运行的时候的不确定因素 (参数)
*
* 方法中,添加不确定因素,就是外接设备,但是这设备都实现接口USB
*
* useUSB( USB u )
* 方法名 参数USB接口 (不确定因素)
* 任何USB接口的实现类,都能使用
*
* USB u = mouse
* 接受的参数是,实现类的对象
* 可以传递任意的实现类
*/
public void useUSB(USB u){
//接口引用调用方法,实现类重写
u.open();
u.close();
}
}
/**
* USB接口外接设备,键盘
* 实现接口,重写方法
*/
public class KeyBoard implements USB{
@Override
public void open() {
System.out.println("键盘开启");
}
@Override
public void close() {
System.out.println("键盘关闭");
}
}
/**
* 鼠标类,外接设备,USB接口的实现类
* 实现接口,重写方法
*/
public class Mouse implements USB {
@Override
public void open() {
System.out.println("鼠标开启");
}
@Override
public void close() {
System.out.println("鼠标关闭");
}
}
public class Test {
public static void main(String[] args) {
//创建笔记本对象
Computer computer = new Computer();
/* computer.powerOff();
computer.powerOn();*/
//创建鼠标对象,是接口USB的实现类
Mouse mouse=new Mouse();
computer.useUSB(mouse);
//使用USB设备方法,使用的是键盘
//KeyBoard keyBoard = new KeyBoard();
computer.useUSB(new KeyBoard());
// computer.useUSB( 任意接口实现类对象 );
}
}
上一篇： CFS 调度器数据结构篇
下一篇： java取某段/某个时间段的值
推荐阅读
-
day02面向对象
-
Python 对象中的数据类型
-
Android从xml加载到View对象过程解析
-
php 利用ceil函数向上取整对象数向上舍入为最接近的小数
-
mybatis实现表与对象的关联关系_动力节点Java学院整理
-
程序员手记_001 类与对象
-
Android Intent传递对象的两种方法(Serializable,Parcelable)详细介绍
-
详解Spring MVC自动为对象注入枚举类型
-
Spring Boot启动过程（五）之Springboot内嵌Tomcat对象的start教程详解
-
AXIS2中OMElement和Java对象之间的转换 分享 博客分类： web service JavaSOAPWebBeanXML