文章目录
1.抽象类
1.1 简介
– 抽象类是程序设计的结果
– 特点:
- 1.通过java关键字abstract实现
- 2.可以修饰方法或者类
- 3.抽象类中可以没有抽象方法(由子类去实现) ---- 外界不能实例化了
- 4.如果类中有抽象方法,那该类必须定义为一个抽象类
- 5.子类继承了抽象类以后,要么还是一个抽象类,要么就把所有抽象方法都重写
- 6.用于多态中
- 7.抽象类不可以被实例化
1.2抽象类的使用
public abstract class Animal {
//没有方法体的方法 叫 抽象方法,用abstract修饰
abstract public void eat() ;
//方法到底是抽象的还是普通的呢? --- 看需要不需要 提供方法体
public void sleep() {
System.out.println("Animal..sleep");
}
}
public class Cat extends Animal{
// abstract public void eat() ;
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
// 子类 继承 抽象类以后,,,要么就是一个抽象的子类
public abstract class Dog extends Animal{
}
public class Test {
public static void main(String[] args) {
// 创建 多态对象测试
// Animal a = new Animal();// 抽象类不能被实例化
Animal a = new Cat();//父类引用 指向 子类对象
// 多态对象 调用方法时,,,方法声明都是用的父类的....但是方法体重写了就用子类的,没重写就是父类的
a.eat();
a.sleep();
}
}
– 抽象类的构造方法
public class Test_Fuzi {
public static void main(String[] args) {
Fu a = new Zi();
System.out.println( a.age );
System.out.println( a.NAME );
}
}
public abstract class Fu{
// 抽象类里可以有 构造方法 ,,,,有什么用?
//给子类new????--因为子类的构造方法里的第一条语句就是super()
public Fu() {
System.out.println(" 无参构造方法") ;
}
// 抽象类里 可以有变量吗? 可以有常量吗 ? -- 都可以有
int age = 20 ;
public static final String NAME = "小明" ;
// 抽象类里可以有普通方法吗? 可以有抽象方法吗? -- 都可以有
//抽象类里可以都是普通方法吗 ? 可以都是抽象方法吗? -- 都可以有
}
public class Zi extends Fi{
//子类 默认就会存在 无参构造
public Zi() {
//子类的 构造方法里,,,,默认就会存在super()
super() ;
}
}
2.接口
2.1简介
- 1.接口是程序 设计的结果.
- 2.接口是一个特殊的 抽象类.
- 3.接口里都是 抽象方法.
– 特点
- 1.接口中都是抽象方法
- 2.通过interface关键字创建接口
- 3.通过implements让子类来实现
- 4.可以理解成,接口是一个特殊的抽象类
- 5.接口突破了java的单继承的局限性
- 6.接口和类之间可以多实现,接口和接口之间可以多继承
- 7.接口是对外暴露的规则,是一套开发规范
- 8.接口提高了程序的功能扩展,降低了耦合性
2.2接口的使用
public interface Fu{
//接口里有变量吗? -- 没有!!!!
//会为你的 简写的 变量自动拼接 public static final
int age=10;
//public static final int age = 10 ;
//接口里的构造方法 有吗? -- 没有
// public Fu() { }
//接口里的方法都是抽象的,可以简写吗? -- 可以
//会为你简写的方法自动拼接 public abstract
//public abstract void save();
void save();
public abstract void get();
public abstract void update();
}
//实现类 实现接口后,,,,,要么重写所有的 抽象方法 , 否则就是一个抽象的实现类
public class Zi implements Fu{
public Zi() {
//找不到接口里的无参构造, 实际上是执行了Object提供的无参构造
super() ;
}
public void save() {
System.out.println("save");
}
public void get(){
System.out.println("get");
}
public void update(){
System.out.println("update");
}
}
//抽象类 实现接口
public abstract class Zi2 implements Fu{ }
public class Test_Interface {
public static void main(String[] args) {
// Fu f = new Fu(); //接口不能被实例化
Fu f = new Zi(); //多态对象,只能调用左面 提供的功能
System.out.println( f.age );//age是静态的 age 是final的常量
System.out.println( Fu.age );
f.save();
f.get();
f.update();
}
}
2.3接口的变化
– ** jdk1.8以前没有static或者default的普通方法,1.8可以添加static或者default的普通方法**
public interface Fu{
static void save() { }
//default void save1() { }
}
2.5重写接口方法权限
public interface A{
//这是简写,会自动拼接public abstract
void save();
void get();
}
public class B implements A{
//接口里的方法想要重写,要有足够权限,接口里都是public的方法
//所以在重写时,要保持修饰符的权限>=原有的
@Override
public void save() {
System.out.println("save");
}
@Override
public void get() {
System.out.println("get");
}
}
2.4 接口的多实现,多继承
- 接口和类之间可以多实现
- 接口和接口之间可以多继承
public interface Fu{
void save();
}
public interface Fu2{
void delete();
}
//接口间可以继承,也可以多继承 , 多个接口间逗号隔开
public interface Fu3 extends Fu , Fu2{
}
//实现了3号接口的 实现类 , 要重写 所有 抽象方法,否则就是一个抽象的实现类
//abstract public class Fu4 implements Fu3
public class Fu4 implements Fu3{
@Override
public void save() { System.out.println("save"); }
@Override
public void delete() { System.out.println("delete"); }
}
//接口和类之间可以实现 ,还可以多实现, 接口间逗号隔开
public class Fu5 extends Object implements Fu1 , Fu2{
@Override
public void save() { }
@Override
public void delete() { }
}
2.5 总结(特点)
- 1.接口中都是抽象方法
- 2.通过interface关键字创建接口
- 3.通过implements让子类来实现
- 4.可以理解成,接口是一个特殊的抽象类
- 5.接口突破了java的单继承的局限性
- 6.接口和类之间可以多实现,接口和接口之间可以多继承
- 7.接口是对外暴露的规则,是一套开发规范
- 8.接口提高了程序的功能扩展,降低了耦合性
3.总结
3.1类和类之间的关系
- 1.继承关系,而且是单继承
- 2.class A extends B
- 3.A叫子类,B叫父类
- 4.A可以使用B的所有功能(除了私有),还可以使用自己的扩展功能
- 5.A还可以改 B的功能,叫方法重写现象
- 6.重写的要求:发生继承关系 + 有足够的权限 + 方法声明和父类一样
- 7.这种继承关系,是一种强耦合的关系,依赖性太强.
3.2类和接口之间的关系
- 1.实现关系,而且可以多实现
- 2.class A implements B,C
- 3.A叫实现类, B和C叫接口 逗号隔开
- 4.A可以同时拥有B和C接口的所有功能.
- 5.A需要重写所有 B C 里的抽象方法,否则就是一个抽象类
- 6.体现了接口的灵活性,扩展性.
- 7.class A extends B implements C,D
- 8.A叫子类或者叫实现类 ,B是父类,C和D是接口
- 9.A要重写B C D里的抽象方法,否则就是一个抽象类
- 10.对于普通方法是不是需要重写,怎么决定? – 想不想改
- 11.要先继承再实现
3.3接口和接口之间的关系
- 1.继承关系,而且可以多继承
- 2.interface A extends B,C
- 3.A叫子接口,B和C叫父接口
- 4.可以使用B和C接口的所有功能,还可以有自己的扩展功能
- 5.class X implements A
- 6.X需要重写A B C 里的所有抽象方法,否则就是为一个抽象类
3.4接口和抽象类的区别
- 1.相同点:都是java层次结构的上层 + 都不能被实例化
- 2.定义的关键字不同,抽象类是abstract接口是interface
- 3.下层发生的关系不同:
- 4.实现类和接口是implements实现关系,子类和父类是extends关系
- 5.抽象类是一个特殊的类,特殊在可以有抽象方法和普通方法
- 6.接口是一个特殊的抽象类,特殊在接口里 都是抽象方法
- 7.抽象类有构造方法,用来给子类new时调用…接口没有构造方法,实现 类new时调用Object的无参构造
- 8.抽象类里有变量有常量.接口里只有常量.
- 9.抽象类里的方法可以是普通的也可以是抽象的…接口里都是抽象的
- 10.接口里的资源可以简写:
- 11.接口里的常量,可以简写,会自动拼接public static final
- 12.接口里的方法,可以间写,会自动拼接public abstract
- 13.接口和实现类是实现关系,而且可以多实现
- 14.抽象类和子类是继承关系,而且是单继承