一个小时搞定JAVA面向对象（5）—

文章目录

抽象
- - 抽象的注意事项
  - - static\final\private是否可以修饰抽象方法
    - 继承和抽象知识点回顾
接口
- - 接口实现总结
  - 抽象方法
  - 默认方法
  - 静态方法
  - 成员变量
  - 接口的特点
  - 接口和抽象类的区别

抽象

关键字: abstract
抽象方法:
修饰符 abstract 返回值类型方法名(参数);
抽象类:
public abstract class 类名{ }

public abstract calss pet{String name;/*父类中的方法,我们可以仅仅定义为一个声明,具体的实现交给子类去实现*/public abstract void eat();
}

注意:
a.抽象方法所在的类一定是抽象类
b.抽象类中不一定非得有抽象方法
c.子类继承父类之后,需要重写父类
中所有的抽象方法,不然编译报错
d.抽象类不能new对象,只能通过new子类对象调动重写方法

抽象的注意事项

抽象类不能直接new对象,只能创建非抽象子类的对象
抽象类中不一定非得有抽象方法,但是抽象方法所在的类一定抽象类
抽象类的子类,必须重写父类中的所有抽象方法,否则,编译报错,除非该子类也是抽象类
抽象类中可以有成员变量,构造,成员方法
抽象类中可以有构造方法,是供子类创建对象时,初始化父类属性使用的
抽象类虽然不能被实例化,但是可以通过多态的方法来赋值
作为抽象类的子类

没有抽象方法的抽象类意义是啥?

为了不让外界创建对象,被实例化.

static\final\private是否可以修饰抽象方法

**static和abstract：**是不能够共存的。static是为方便调用，abstract为了给子类重写的，没有方法体
**final和abstract：**是相互冲突的，final修饰的方法不能被重写，而abstract修饰的方法就是为了让子类重写的。
**private和abstract：**也是冲突的，private修饰

继承和抽象知识点回顾

继承:子类继承父类,可以直接使用父类中非私有成员,子类不用写重复性代码
关键字: extends
成员访问特点:
成员变量:看等号左边是谁
成员方法:看new的是谁
方法的重写:子类中有一个和父类从方法名以及参数列表上一样的方法
检测:@Override
使用场景:功能的升级
继承中构造的特点:
new子类对象先初始化父类
super:代表的是父类引用
调用父类构造:super() super(实参)
调用父类成员变量: super.成员变量名
调用父类成员方法:super.成员方法名(实参)

7.this:代表的是当前对象(哪个对象调用的this所在的方法,this就代表哪个对象)

a.作用:区分重名的成员变量和局部变量

b.使用:

调用当前对象构造:this() this(实参)

调用当前对象成员变量:this.成员变量名

调用当前对象成员方法:this.成员方法名(实参)

c.注意:在构造中使用this和super,都必须要在第一行,所以两者不能同时出现

8.继承的特点:

a.继承只支持单继承,不支持多继承

b.继承支持多层继承

c.一个父类可以拥有多个子类

9.抽象:

a.抽象方法: 修饰符 abstract 返回值类型方法名(形参)

b.抽象类:public abstract class 类名{}

c.特点:

抽象方法所在的类一定是抽象类

抽象类中不一定非得有抽象方法

子类继承抽象父类时,需要重写抽象方法

抽象类不能new对象,只能new子类对象

抽象类中啥都可以有,私有属性,构造,其他方法等

抽象类中的构造是供创建子类对象时初始化父类属性使用的

接口

接口是一个引用数据类型

关键字:

interface接口
```
public interface 接口名{ }
```
implements实现
```
实现类 implements 接口名{ }
```

接口中可以定义的成员:
1. JDK7以及比之前:
  1. 抽象方法
    public abstract ( 即使不写public abstract,默认也有)
  2. 成员变量
    public static final 数据类型变量名 = 值
    (即使不写public static final,默认也有)
    (final是最终的,被final修饰的变量不能二次赋值,所以我们一般将final修饰的变量视为常量)
2. JDK8:
  1. 默认方法
    public default 返回值类型方法名(形参){}
  2. 静态方法
    public static 返回值类型方法名(形参){}
3. JDK9开始:
  1. 私有方法
    1. private的方法(实际开发中用的不是特别多)

接口实现总结

定义接口:public interface 接口名{ }
实现:public class 实现类类名 implements 接口名{ }
使用方法:
1. 实现类实现接口
2. 重写接口中的抽象方法
3. 创建实现类对象(接口不能new对象)
4. 调用重写的方法

//接口实现代码案例
public interface USB {	//定义接口public abstract void open();public abstract void close();
}public class Mouse implements USB{	//定义接口实现类@Overridepublic void open() {System.out.println("鼠标打开");}@Overridepublic void close() {System.out.println("鼠标关闭");}
}public class Test01 {	//测试类public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();mouse.close();}
}

抽象方法

定义格式:public abstract 返回值类型方法名(形参)
注意事项:不写public abstract默认也是有的
使用方法:
1. 定义实现类\实现接口
2. 需要重写抽象方法
3. 创建实现类对象,调用重写的方法

public interface USB {//定义抽象方法public abstract void open();String close();
}//调用抽象方法制作实现类
public class Mouse implements USB{@Overridepublic void open() {System.out.println("鼠标打开");}@Overridepublic String close() {return "鼠标关闭";}
}public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.open();String result = mouse.close();System.out.println("result = " + result);}
}

默认方法

定义格式:

public default 返回值类型 方法名(形参){方法体return 结果
}

使用方法:
1. 定义实现类\实现接口
2. 默认方法可以重写,也可以不重写
3. 创建实现类对象,调用默认方法

静态方法

定义格式:

public static 返回指类型 方法名(形参){方法体retuan 结果
}

使用方法:
1. 接口名直接调用

默认方法和静态方法的作用：

可以作为临时加的一个小功能来使用

public interface USB {//默认方法public default void methodDef(){System.out.println("我是默认方法");}
}
public class Mouse implements USB {//默认方法public default void methodDef(){System.out.println("我是默认方法");}//静态方法public static void methodSta(){System.out.println("我是接口中的静态方法");}//重写默认方法@Overridepublic void methodDef(){System.out.println("我是重写接口中的默认方法");}
}
public class Test01 {public static void main(String[] args) {Mouse mouse = new Mouse();mouse.methodDef();System.out.println("=============");USB.methodSta();静态方法可以直接调用接口名}
}

成员变量

定义格式：

 public static final 数据类型 变量名 = 值

使用方法：
1. 接口名直接调用
2. 可不写public static final ,默认会有

注意事项:

被static final修饰的成员变量需要手动赋值
习惯上我们将static final修饰的成员变量名称用大写

public interface USB {public static final int NUM1 = 100;int NUM2 = 200;//不写public static final 默认也有
}public class Test01 {public static void main(String[] args) {System.out.println(USB.NUM1);System.out.println(USB.NUM2);	//修饰的成员变量名称用大写}
}

接口的特点

接口可以多继承

public interface InterfaceA extends InterfaceB,InterfaceC{}

接口可以多实现

public class InterfaceImpl implements InterfaceA,InterfaceB{}

当一个类实现多个接口时,如果接口中的抽象方法有重名并且参数一样,只需要重写一次

public interface InterfaceA {public abstract void method();
}public interface InterfaceB {public abstract void method();
}public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}
}

当一个类实现多个接口时,如果多个接口中的默认方法有重名的且参数一样,必须重写一次默认方法

public interface InterfaceA {public abstract void method();public default void methodDef(){System.out.println("我是接口A中的默认方法");}
}public interface InterfaceB {public abstract void method();/*    public default void methodDef(){System.out.println("我是接口B中的默认方法");}*/public default void methodDef(int a) {System.out.println("我是接口B中的默认方法");}
}public class InterfaceImpl implements InterfaceA,InterfaceB{@Overridepublic void method() {System.out.println("重写的method方法");}/*    @Overridepublic void methodDef() {System.out.println("重写后的默认方法");}*/
}public class Test01 {public static void main(String[] args) {InterfaceImpl anInterface = new InterfaceImpl();anInterface.methodDef();anInterface.methodDef(10);}
}

一个子类可以继承一个父类的同时可以是实现一个或者多个接口
```
public class Zi extends Fu implements  InterfaceA,InterfaceB{}
```
注意事项:
1. 只要是父类中或者接口的抽象方法,子类或者实现类都要重写

接口和抽象类的区别

相同点:
1. 都位于继承体系,用于被其他类实现或者继承
2. 都不能new
3. 都包含抽象方法,其子类或者实现类都必须从重写这些抽象方法
不同点:
1. 抽象类:一般作为父类使用,可以有成员变量\构造\成员方法\抽象方法等
2. 接口:成员单一(一般抽取接口)抽取的都是方法,作为实现功能的大集合
3. 类不能多继承,但是接口可以