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修饰的成员出现的晚---->我们(后人)