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