java基础第七篇之接口

1.什么是接口:

* 接口是方法的集合,而且接口中的方法全是抽象的

* 你可以把接口看成一个特殊的"抽象类",接口中的方法全是抽象的

*

*

* 2.java中怎么定义接口:

* 定义类的关键字:class

* 定义接口的关键字:interface

* 格式:

* public interface 接口名{

* //成员方法

* public abstract void demo01();

* public abstract void demo02();

* }

* 接口的方法 必须是public abstract 修饰,你可以不写,也可以选择性写,但是不写不代表没有(我们建议写)

*

* 3. 接口可以创建对象吗?不可以创建对象,接口也是天生作为父类

*

* 4.类和接口的关系,叫做实现,类实现接口(继承是类和类之间的关系,实现是类和接口的关系)

*

* 5.怎么实现: implements(实现的关键字) extends(继承的关键字)

* a.一个类实现接口,这个类我们称为接口的实现类

* b.一个类继承抽象类,这个类我们称为抽象类的子类

* 6.接口中成员的特点:

* a.所有的方法必须都是 public abstract修饰

*

* b.接口中成员变量必须由public static final 修饰

* 我们建议以上所有的修饰符都写上

接口中成员的特点:

* 1.所有的方法必须都是 public abstract修饰

*

* 2.接口中成员变量必须由public static final 修饰

* 我们建议以上所有的修饰符都写上

* 接口的一些特点:

*

* 1.类和类只能单继承,类和接口可以多实现

*

* 2.接口和接口的关系叫做继承,而且接口和接口可以多继承

*

* 面试题:java中支持多继承吗?

* java类和类只能单继承,但是可以多层继承

* java接口和接口可以多继承

*

* 3.一个类 继承了另外一个类,同时实现了多个接口

* 伪代码:

* public class 子类 extends 父类 implements 接口1,接口2...{

* //子类想要创建对象

* //1.重写父类的抽象方法(可能有可能没有)

* //2.重写所有接口中所有抽象方法

* }

抽象类和接口的区别:

*

* 1.抽象类中只能定义 所有子类共性内容

*

* 2.接口中定义是整个继承体系之外的方法

多态:[多种变态] 一个事物的多种形态

* 比如一个学生,你可以看成是学生,你可以看成是人

*

* 1.必须有继承关系(或者实现关系)

* 2.必须有方法的重写(但是不重写 多态失去了意义)

* 3.在12前提下,多态的表现形式 父类的引用变量 指向了 子类的对象

* 接口的引用变量 指向了 实现类的对象

* AbstractB aa = new ClassB();

* InterA ia = new ClassA();

*

* 假设 abstract class Person{

* public abstract void sleep();

* }

* 1.继承

* class Student extends Person{

* //2.重写方法

* public void sleep(){

* ..

* }

* }

* 3.表现形式:

* 父类的引用变量 指向了 子类的对象

* Student s = new Student();//不是多态

* Person p = new Student();//就是多态

多态中的成员变量:(只和父类有关系)

* 1.编译时:看父类

* 2.运行时:看父类

*

* 多态中的成员方法:

* 1.编译时:看父类

* 2.运行时:看子类

*

* 总结:多态的成员变量只和父类有关,多态的成员方法编译看父类运行时看子类

*

* 多态的好处和弊端:

*

* 1.弊端:只能调用子父类共有的方法,而不能调用子类特有的方法

*

* 2.好处:提高了程序的扩展性

* 案例:说明多态好处,提高了程序的扩展性

* 喂猫和狗的案例

* 1.抽取父类 (Animal)

* 2.猫狗继承Animal,同时重写抽象方法

* 多态的形式:

* 1.前提:

酒 a = 剑南春

酒 b = 五粮液

酒 c = 酒鬼酒

…

这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，

我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——

我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

* a.必须有继承关系(或者实现关系)

* b.必须有方法的重写

* 2.表现形式

* 父类类型 变量名 = new 子类类型();

* 接口类型 变量名 = new 实现类类型();

*

* 多态的弊端和好处:

* a.只能调用子父类共有内容,不能调用子类特有的内容

* 多态的成员变量:编译时看父类 运行时也看父类

* 多态的成员方法:编译还是看父类,运行时看子类

* b.好处:提供程序扩展性,同时提高了代码复用性

*

* 多态弊端的解决方案:(转型方案)

* 1.向上转型:(自动类型转换)

* double d = 1;//打印出来的d不是1而是1.0

* Person p = new Student();//向上转型

* Animal an = new Dog();//向上转型

*

* 2.向下转型(强制类型转换)

* int i = (int)1.9;//打印i打印出来是1

* Person p = new Student();//多态

* Student s = (Student)p;//向下转型

昨天知识回顾:

* 1.this和super的作用

*

* 2.方法重写的概念

*

* 3.方法重写的意义:增强了父类的功能

*

* 4.什么是抽象方法:

* 什么是抽象类:

*

* 5.抽象类存在的意义?

*

* 6.抽象类的抽象方法存在的意义?

*

* 补充:this(参数):

* super(参数):单一原则

*

*

*/

public class TestDemo {

public static void main(String[] args) {

C c = new C();//1.开辟空间 2.构造方法 3.返回地址

//构造方法:1:super() 2:初始化成员(赋值默认值) 3:进行后面的方法体

}

}

class A{

int x = 10;-

public A(){

super();

//初始化成员

showX();

}

public void showX(){

System.out.println(x);

}

}

class B extends A{

public B(){

super();

showX();

}

}

class C extends B{

public C(){

super();

//初始化

showX();

}

}

1.以前我们定义一个类的成员变量和成员方法的时候,以后我们是通过创建对象来调用这些成员的

*

* 2.定义一个类 CZStudent(学号,name,sex,school:就读学校)

* static修饰成员变量:比如 : static String school

* 被static修饰的成员变量 不属于某一个对象,它属于这个类,但是有学生又共享这个变量

*

* 案例: 中国人类

* name.age,job,国籍

*

* 总结:被static修饰的成员变量,在内存中有一份,保存到静态区

* 然后无论创建多少个对象,所有对象共享一份数据

* 所以说我们一般称static修饰的成员变量 叫做类成员

*

* 3.被static修饰的成员的访问方式:

* 成员变量:

* 对象名.static修饰的成员变量名;//不建议

* 类名.static修饰的成员变量名;//建议

* 成员方法:

* 对象名.static修饰的方法名();//不建议

* 类名.static修饰的方法名();

* 4.补充:被static修饰的成员 和 不被static修饰的成员相互访问的问题

* 生命周期的问题:

* static修饰成员出现的早----->秦始皇(先人)

* 非static修饰的成员出现的晚---->我们(后人)