1.abstract 抽象的
(1)类 抽象类
①抽象类编译之后会生成独立的 .class 文件
②只能声明引用, 不能创建对象。
③供子类去继承。
④生活中, 抽象类是从不同的子类中抽 象出的父类, 自身不存在对象 如:动物类, 交通工具类。
(2)方法 抽象方法
①只有方法声明, 没有方法实现 方法实现部分用 分号 代替。
②留给子类实现 (覆盖)。
③只声明了对象具有什么功能, 没有定义对象如何实现该功能。
(3)抽象类和抽象方法的关系
① 如果一个类具有抽象方法, 那么这个类就必须是抽象类。
②抽象类中未必有抽象方法。
③子类继承抽象类, 如果子类不希望也成为抽象类, 就必须实现父类中所有的抽象方法。
——引用可以调用其引用类型中声明的所有方法, 包括抽象方法
Super s = XXXX;
s.method();
abstract class Super{
public abstract void method();
}
——方法的声明和实现分离. 声明放在父类, 实现留给子类 ---- 子类的共性放在父类
(4)抽象类强制使用多态
抽象类类名 引用名 = new 子类类名(形参);
public class TestAbstract{
public static void main(String[] args){
MyClass mc ;
mc = new Sub(); // 强制使用多态
mc.m1();
mc.m2();
mc.m3();
}
}
//抽象类
abstract class MyClass{
int a; // 属性
public void m1(){
System.out.println("m1()...");
}
public abstract void m2();
abstract public void m3();
}
// 子类
class Sub extends MyClass{
public void m2(){
System.out.println("m2()实现内容...");
}
public void m3(){
System.out.println("m3()...实现内容.../");
}
}
2.接口(interface)
接口:是一种标准、规范,接口的使用者和接口的实现者都必须遵循的约定。
语法:(基于 jdk7.0 版本) 【重点】
(1) 关键字: interface
interface 接口名{}
(2) 接口在编译之后会生独立 .class 文件
(3) 接口不能创建对象,但是可以声明引用。
接口名 变量名;
(4) 接口中没有构造方法
private、static、final可以组合使用。
(5) 接口中属性都是公开、静态、常量(默认被 public static
final 修饰)
(6) 接口中方法都是公开、抽象方法(默认被 public abstract
修饰)
注意:接口从语法角度是一个特殊的抽象类,是对抽象类进
一步的抽象。
但是接口 从 Java分类:不是类。
public class TestMyInter{
public static void main(String[] args){
MyInter mi ;
//MyInter.n = 20;
System.out.println(MyInter.n);
System.out.println(MyInter.m);
//MyInter.m = 50;
}
}
// 抽象类
/*
抽象类不能单独new 对象,但是可以声明引用
抽象类:编译之后生成独立的 .class
*/
abstract class MyClass{
int a = 3; // 实例变量
static int b = 7; // 静态变量
public MyClass(){}
public void m1(){}
public abstract void m2();
}
// 接口:共语法角度,相当于 特殊的抽象类
interface MyInter{
int m =0; // 默认 被 static ,同是 被 final修饰
static int n = 7; // 静态变量,默认 被 final修饰
//public MyInter(){} // 接口中没有构造方法
public void t1();// 默认的被 publicabstract 修饰
public abstract void t2();
void t3();// 被 public abstract 修饰
}
实现类【开发应用重点】
(1) 语法:
class 类名 implements 接口名{}
(2) 注意:
a. 如果实现类不想定义为 抽象类,则必须覆盖接口中所
有的抽象方法,同时给与实现;否则实现类必须定义为抽象类。
b. 接口中方法默认的访问权限为 public ,所以实现类覆盖接口中的方法时访问修饰符必须也是 public。因为 类中方法如果不谢访问修饰符。默认的访问权限为 default。
(3) 使用:接口类型的引用中可以存储 实现类的对象,多态的应用
语法:接口名 引用 = new 实现类类名(实参);
注意:如果以接口类型的引用调用方法,只能调用 接口
中有的方法。
(4) 案例:
public class TestInter{
public static void main(String[] args){
// 接口类型的引用 --》 实现类的对象
MyInter mi = new MyClass(); // 多态
mi.m1();
mi.m2();
//mi.m3();
}
// 接口
interface MyInter{
public void m1();// 默认 被 abstract
void m2(); //默认 public abstract 修饰
}
// 接口的实现类 (从语法角度:类 继承一个 特殊的 抽象
类)
class MyClass implements MyInter{
public void m1(){
System.out.println("m1方法的实现....");
}
public void m2(){
System.out.println("m2方法的实现....");
}
public void m3(){}
}
Java中接口的继承性 【开发应用重点】
(1) 接口与接口之间是多继承
语法:interface 接口名 extends 父类接口1,父接口2{}
(2) 类和接口是实现的关系:即一个类可以同时实现多个接口
① 语法: class 类名 implements 接口名1,接口名2{ }
}
② 注意:如果实现类不想成为抽象类,必须覆盖所有接口中
的所有方法
(3) 一个类继承一个父类的同时可以实现多个接口:
① 语法:class 类名 extends 父类 implements 接口1,接口
名2{}
② 注意:必须先定义继承,再定义实现
public class Test6{
public static void main(String[] args){
MyClass mc = new MyClass();
ClassA ca = mc;
ca.m6();
}
}
interface IA{
void m1();
void m2();
}
interface IB{
void m3();
}
interface IC extends IA,IB{
void m4();
}
interface ID{
void m5();
}
// 类和接口的多实现
class MyClass extends ClassA implements IC,ID {
public void m1(){
System.out.println("m1()...");
}
public void m2(){
System.out.println("m2()...");
}
public void m3(){
System.out.println("m3()...");
}
public void m4(){
System.out.println("m4()...");
}
public void m5(){
System.out.println("m5()...");
}
}
class ClassA{
public void m6(){
System.out.println("m6()...");
}
}
抽象类与接口区别: