一、继承
1.1、继承概念
将对象的共性抽取出来。提取出一个单独的类。
继承使用复用以前的代码非常容易,能够大大的缩短开发周期,降低开发成本,同时增加程序的易维护性
继承使重一个类A能够直接使用另外一个类B的属性和方法的一种途径
类A可以有自己的属性和方法通过 extends 关键字让类与类之间产生继承关系。
让类和类之间产生了关系,有了这个关系,才有了多态的特性。
注意:千万不要为了获取其他类的功能,简化代码而继承。
必须是类与类之间有所属关系才可以继承,所属关系是 is a.的关系
1.2、继承的实现
类的继承格式
在Java中使用extends关键字完成类的继承关系,操作格式:
class 父类{} // 定义父类
class 子类 extends 父类{} // 使用extends关键字实现继承
1.3、继承的特点
子类继承父类的什么?
继承public 和protected修饰的属性和方法,不管子类和父类是不是在一个包中
继承默认权限修饰的属性和方法,子类和父类必须在同一个包中
注意:
JAVA只支持单继承,也就是一个类只能继承一个类
无法继承private修饰的属性和方法
无法继承父类的构造方法
子类继承了父类的所有属性(包括private)和方法或子类拥有父类的所有属性和方法是对的,只不过父类的私有属性和方法,子类是无法直接访问到的。即只是拥有,但是无法使用。
示例:
package com.study.day07.person; /** * 父类 * @author denny * */ public class Person { /** * name=姓名 * age=年龄 * 都是私有的 */ private String name; private int age; /** * 无参数构造方法 */ public Person() { System.out.println("父类无参数的构造方法"); } /** * 有参数构造方法 * @param name=姓名 * @param age=年龄 */ public Person(String name, int age) { this.name = name; this.age = age; System.out.println("父类有参数的构造方法"); } /** * 显示信息方法 */ public void show(){ System.out.println("父类show方法"); System.out.println("姓名: "+this.name+" \n年龄: "+this.age); } /** * getterXxx和setterXxx方法 * @return */ public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
子类
package com.study.day07.person; /** * 学生类继承父类 * @author denny * */ public class Student extends Person { /** * gender=性别 * 子类特有的属性 */ private String gender; /** * 子类无参数构造方法 */ public Student() { super();//使用父类的构造方法 System.out.println("子类无参数构造方法"); } public Student(String name,int age,String gender) { /* * 调用父类有参数的构造方法 */ super(name,age); this.gender = gender; System.out.println("子类有参数构造方法"); } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } /** * 重写父类的方法 */ @Override public void show(){ super.show(); //调用父类的方法, System.out.println("子类show方法"); System.out.println("性别: "+this.gender); //子类自己的方法体 } }
测试类
package com.study.day07.person; import com.study.day07.person.Person; public class Test { public static void main(String[] args) { Person s=new Student("张三",20,"男"); s.show(); } }
结果:
父类有参数的构造方法 子类有参数构造方法 父类show方法 姓名: 张三 年龄: 20 子类show方法 性别: 男
在子类构造函数执行时,发现父类构造函数也运行了。
原因:在子类的构造函数中,第一行有一个默认的隐式语句:super();
1.4、方法重写
上例中子类show()实现的对父类show()方法的重写.
/** * 重写父类的方法 */ @Override public void show(){ super.show(); //调用父类的方法, System.out.println("子类show方法"); System.out.println("性别: "+this.gender); //子类自己的方法体 }
在子类覆盖方法中,继续使用父类的方法可以通过super.函数名获取 ,super.变量名
什么时候使用覆盖操作?
当子类需要父类的功能,而功能主体子类有自己特有内容时,可以复写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。
注意:
1、父类中的私有方法不可以被覆盖。
2、父类为static的方法无法覆盖。
3、覆盖时,子类方法权限一定要大于等于父类方法权限。
1.5、子类的实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数。
因为每一个构造函数的第一行都有一条默认的语句super();。
为什么子类实例化的时候要访问父类中的构造函数呢?
那是因为子类继承了父类,获取到了父类中内容(属性),所以在使用父类内容之前,要先看父类是如何对自己的内容进行初始化的。
注意:
1、当父类中没有空参数的构造函数时,子类的构造函数必须通过this或者super语句指定要访问的构造函数。
2、子类构造函数中如果使用this调用了本类构造函数,那么默认的super(),就没有了,因为super和this都只能定义在第一行,所以只能有一个。但是可以保证的是,子类中肯定会有其他的构造函数访问父类的构造函数。
3、super语句必须要定义在子类构造函数的第一行!因为父类的初始化动作要先完成。
总结:
一个对象实例化过程,以Person p = new Person();为例:
1. JVM会读取指定的路径下的Person.class文件,并加载进内存,并会先加载Person的父类(如果有直接的父类的情况下)。
2. 在内存中开辟空间,并分配地址。
3. 并在对象空间中,对对象的属性进行默认初始化。
4. 调用对应的构造函数进行初始化。
5. 在构造函数中,第一行会先到调用父类中构造函数进行初始化。
6. 父类初始化完毕后,再对子类的属性进行显示初始化。
7. 再进行子类构造函数的特定初始化。
8. 初始化完毕后,将地址值赋值给引用变量。
二、final
final可以修饰类,方法,变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量,只能被赋值一次。
为什么要用final修饰变量,其实,在程序中如果一个数据是固定的。那么直接使用这个数据就可以了,但是这种阅读性差,所以应该给数据起个名称。而且这个变量名称的值不能变化,所以加上final固定。
写法规范:常量所有字母都大写,多个单词,中间用_连接。
/* final 修饰的变量是常量不可更改其值 */ class FinalDemo{ public static void main(String [] args){ final int x=5; x=4; System.out.println("x="+x); } }
结果:
三、抽象类和抽象类和方法
3.1、抽象类概述
使用关键字abstract 来修饰
抽象定义:
抽象就是从多个事物中将共性的、本质的内容抽取出来。
例如:学生和老师都是人,人类就是抽象出来的共性。
抽象类:使用abstract 修饰。
抽象方法:Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。使用abstract来修饰
3.2、抽象类特点
抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明,没有方法体,定义在抽象类中。
格式:修饰符 abstract 返回值类型 函数名(参数列表) ;
抽象类不可以被实例化,也就是不可以用new创建对象。
原因如下:
1. 抽象类是具体事物抽取出来的,本身是不具体的,没有对应的实例。例如:犬科是一个抽象的概念,真正存在的是狼和狗。
2. 而且抽象类即使创建了对象,调用抽象方法也没有意义。
3. 抽象类通过其子类实例化,而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象,否则该子类也是抽象类。
示例:
package com.day08.abstrac.demo1; /** * 定义人类抽象类 * @author denny * */ public abstract class Person { /** * 定义属性 * name=姓名 * age=年龄 * gender=性别 */ private String name; private int age; private String gender; /** * 抽象方法 */ public abstract void life(); //生活方法 /** * getter和setter方法 * @return */ public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } }
子类:
package com.day08.abstrac.demo1; /** * 老师类继承人类抽象类 * 必须实现人类中的抽象方法 * 如果不实现老师类必须是抽象类 * @author denny * */ public class Teacher extends Person { @Override public void life() { System.out.println("教师的生活就是教学!"); } }
3.3、抽象类相关问题
抽象类中是否有构造函数?
答:有,用于给子类对象进行初始化。
抽象关键字abstract不可以和哪些关键字共存?
答:private、static、final。
抽象类中可不可以没有抽象方法?
答:可以,但是很少见。目的就是不让该类创建对象,AWT的适配器对象就是这种类。通常这个类中的方法有方法体,但是却没有内容。
3.4、抽象类和一般类的区别?
相同点:
抽象类和一般类都是用来描述事物的,都在内部定义了成员。
区别:
抽象类不可以被实例化,一般类可以被实例化
抽象类可以有抽象方法和一般方法,一般类只能有一般的方法
抽象类描述事物的信息有可能不足。一般类有足够的信息描述事物。
抽象类一定是个父类吗?
答:是的,因为需要子类覆盖其方法后才可以对子类实例化。
四、接口
4.1、接口定义
当一个抽象类中的方法都是抽象的时候,这时可以将该抽象类用另一种形式定义和表示,就是接口。
格式:interface 接口名 {}
接口中的成员修饰符是固定的:
成员常量:public static final 成员变量都是静态常量
成员函数:public abstract 所有方法都是抽象方法,可以不写abstract,只能是public,不能是其它的
由此得出结论,接口中的成员都是公共的权限。
接口是对外暴露的规则。
接口是程序的功能扩展。
P.S.
1、虽然接口类中的全局变量和抽象方法的修饰符都可以不用写,但是这样阅读性很差。所以,最好写上。
2、类与类之间是继承关系,类与接口直接是实现关系。
3、接口不可以实例化,能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则,这个子类就是一个抽象类。
4.2、接口的实现
类要实现接口要使用implements关键字
格式 class 类名 implements 接口名
1.实现接口时,实现接口中的所有方法
2.
示例:
分别定义接口鸟的叫和攻击方法都是抽象的
package com.day08.interfac.demo1; /** * 攻击接口 * @author denny * */ public interface BirdAttack { /** * 攻击的方法 * 没有方法体 */ public void attack(); }
package com.day08.interfac.demo1; /** * 叫声的接口 * @author denny * */ public interface BirdShout { /** * 叫的方法 * 没有方法体 */ public void shout(); }
火箭鸟
package com.day08.interfac.demo1; /** * 火箭鸟 * @author denny *攻击方式:火箭攻击 *实现了攻击的接口和叫的接口,所有要重写攻击接口中的叫方法和攻击方法 *接口可以实现多个,但继承只能有一个 * */ public class FireBird implements BirdAttack,BirdShout{ @Override public void shout() { System.out.println("火箭鸟喳喳叫!"); } @Override public void attack() { System.out.println("火箭鸟发射火箭弾攻击!"); } }
胖子鸟
package com.day08.interfac.demo1; /** * 胖子鸟 * @author denny * 叫声:唧唧叫 * 没有攻击,所以不需要实现攻击的接口 * */ public class FatBird implements BirdShout { @Override public void shout() { System.out.println("胖子鸟唧唧叫!"); } }
测试类
package com.day08.interfac.demo1; public class BirdTest { public static void main(String[] args) { //创建胖子鸟对象,并调用相应的方法 FatBird fatBird=new FatBird(); fatBird.shout(); //创建火箭鸟对象,并调用相应的方法 FireBird fireBird=new FireBird(); fireBird.shout(); fireBird.attack(); } }
结果
胖子鸟唧唧叫! 火箭鸟喳喳叫! 火箭鸟发射火箭弾攻击!
以上例子中,实现的,行为和类的分离,需要哪个就实现哪个接口,没有就不要实现
接口的出现将“多继承”通过另一种形式体现出来,即“多实现”。
java将多继承机制进行改良,在java中变成了多实现,一个类可以实现多个接口。
接口的出现避免了单继承的局限性。
4.3、抽象类和接口
相同点:
抽象类和接口都不能被实例化
都是不断向上抽取而来的。
区别:
1. 抽象类需要被继承(extends),而且只能单继承。
接口需要被实现,而且可以多实现。(implements)
2. 抽象类中可以定义抽象方法和非抽象方法,子类继承后,可以直接使用非抽象方法。
接口中只能定义抽象方法,必须由子类去实现。
3. 抽象类的继承,是is a关系,定义该体系的基本共性内容。
接口的实现是like a关系。