7.1 类的继承
Java语言每个类只能继承一个父类,叫做单继承。
extends 继承
父类 写法与普通写法相同,关键词extends的使用方法如下:
public class 父类类名(){
}
子类
public class 子类类名 extends 父类类名(){
}
因为Java只支持单继承,即一个类只能有一个父类,所以类似下面的代码是错误的:
class 子类 extends 父类1,父类2{
}
例7.1
父类Parent和子类Child都各自有一个无参的构造方法 ,在main()方法中创建子类对象时,Java虚拟机会先执行父类的构造方法,然后再执行子类的构造方法。
运行结果:
所有的类的构造方法,第一行都有一个隐藏的“super();”,作用是在执行该构造方法之前调用其父类的构造方法。
public只能有一个,用public修饰的类就是类名(文件名)。
子类继承父类之后可以调用父类创建好的属性和方法。
例7.2
Telephone电话类作为父类衍生Mobile手机类,手机类可以直接使用电话类的按键属性和拨打电话行为。
class Telephone{//电话类
String button = "button:0~9";//成员属性,10个按键
void call() { //拨打电话功能
System.out.println("开始拨打电话");//输出
}
}
class Mobile extends Telephone{//手机类继承电话类
String screen = "screen:液晶屏";//成员属性,液晶屏幕
void call() { //拨打电话功能
System.out.println("拨打电话");//输出
}
}
public class Demo2 {
public static void main(String[] args) {
Mobile motto = new Mobile();
System.out.println(motto.button);//子类调用父类属性
System.out.println(motto.screen);//子类调用父类没有的属性
motto.call();//子类调用父类方法
}
}
运行结果:
方法的重写(子类重写父类方法):返回参数相同,方法名相同,传入参数相同,只有方法体不同
Java虽然不允许同时继承多个父类,但不代表没有多个继承,可以通过类似“祖父>父>儿子>孙子”的方式实现多代继承。
例如:
class Animal{ //父类:动物类
Eye eye;
Mouth mouth;
nose nose;
}
class Dog extends Animal{} //子类:犬类
class Husky extends Dog{} //孙子类:哈士奇类
7.2 Object类
在Java中所有的类都直接或间接继承了Java.lang.Object类。Object类是比较特殊的类,它是所有类的父类。
由于所有的类都是Object类的子类,所以任何类都可以重写Object类中的方法。下面是Object类中几种重要用法:
1、getClass()方法
它会返回对象执行时的Class实例,然后使用实例调用getClass()方法可以取得类的名称。语法如下:
getClass().getname();
2、toString()方法
功能是将一个对象返回为字符串形式,它会返回一个String实例。在实际的应用中通常重写toString()方法,为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时,将自动调用重写的toString()方法。
例7.3
创建Student类,重写toString()方法,使该类的对象可以自定义输出自己的姓名和年龄。
public class Student { //创建类
String name; //定义name变量
int age; //定义age变量
public Student( String name,int age) { //定义构造方法
this.name = name; //传入参数
this.age = age;
}
public String toString() { //重写toString()
return"我叫" +name +",今年"+age+"岁。"; //返回值
}
public static void main(String[] args) {
Student s1 =new Student("张三",16); //新建对象s1
System.out.println(s1); //输出s1
Student s2 =new Student("李四",17); //新建对象s2
System.out.println(s2); //输出s2
}
}
运行结果:
3、equals()方法
在Java语言中,有两种比较对象的方式,分别为“==”运算符与equals()方法。两者的区别在于:“==”比较的是两个对象,应用内存地址是否相同,而equals()方法比较的是两个对象的实际内容。
public class People1{
int id;//身份证
String name;//名字
public People1(int id,String name) {
this.id=id;
this.name=name;
}
public boolean equals(Object obj) {//重写Object类的equals()方法
if(this==obj)//如果参数与本类同一个对象
return true;
if(obj==null)//如果参数是null
return false;
if(getClass()!=obj.getClass())//如果参数与本类类型不同
return false;
People1 other=(People1) obj;//将参数强转成本类对象
if(id!=other.id)//如果两者的身份证号不相等
return false;
return true;
}
public String toString() {//重写Object类的toString()方法
return name;//只输出名字
}
public static void main(String[] args) {
People1 p1=new People1(220,"tom");
People1 p2=new People1(220,"汤姆");
People1 p3=new People1(220,"张三");
Object o=new Object();
System.out.println(p1+"与"+p2+"是否为同一人?");
System.out.println("equals()方法的结果:"+p1.equals(p2));
System.out.println("==运算符的结果:"+(p1==p2));
System.out.println();
System.out.print(p1+"与"+p3+"是否为同一人?");
System.out.println(p1.equals(3));
System.out.print(p1+"与"+o+"是否为同一人?");
System.out.println(p1.equals(o));
}
}
运算结果:
7.3 对象类型的转换
向上转型
子类转父类 ,子类对象赋值给父类引用。子类类型的对象直接赋值给父类类型的对象。自动类型转换 语法如下:
Animal a = new dog();
向下转型
父类转子类,父类对象赋值给子类引用。可以理解为将父类类型的对象转换为子类类型的对象。但是运用向下转换,如果把一个叫抽象的类的对象转换为一个较具体的类的对象,这样的转型通常会出现错误,这时就需要借助强制类型转换。
Dog a =(Dog)new Animal();
例7.6
class Bird {}
class Pigeon extends Bird{}
public class Demo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Bird bird = new Pigeon();//某只鸽子是一只鸟
Pigeon pigeon = (Pigeon) bird;//某只鸟是一只鸽子(要进行强制类型转换)
}
}
7.4 使用instanceof关键词判断对象类型
语法如下:
对象名 instanceof 类名
判断对象是否属于该类或其子类。
例7.7
因为四边形类与圆形类没有继承关系,因此两者不能使用instanceof关键词进行比较,否则会发生”不兼容“错误。如果删除或注释掉这一行代码,运行结果如下:
第二种使用方法:
对象名 instanceof 接口名
判断对象是否属于该接口的实现类
7.5 方法的重载
方法名相同,参数不同(返回参数不同,传入参数不同)
构造方法的名称由类名决定,所以构造方法只有一个名称。如果希望以不同的方式来实例化对象,就需要使用多个构造方法来完成。由于这些构造方法都需要根据类名进行命名,为了方法名相同而形参不同的构造方法同时存在,必须用到方法重载。虽然方法存在起源于构造方法,但它也可以应用到其他方法中。
例7.8
public class Demo4{
public static int add(int a,int b) {//定义一个方法
return a+ b;
}
public static double add(double a,double b) {//与第一个方法名称相同、参数类型不同
return a+b;
}
public static int add(int a) {//与第一个方法参数个数不同
return a;
}
public static double add(int a,double b) {//先int参数,后double参数
return a; //输出int参数值
}
public static double add(double a,int b) {//先double参数,后int参数
return b; //输出int参数值
}
public static void main(String[] args) {
System.out.println("调用add(int,int)方法:"+add(1,2));
System.out.println("调用add(double,double)方法:"+add(2.1,3.3));
System.out.println("调用add(int)方法:"+add(1));
System.out.println("调用add(int,double)方法:"+add(5,8.0));
System.out.println("调用add(double,int)方法:"+add(5.0,8));
}
}
运行结果:
在谈到参数个数可以确定两个方法是否具有重载关系时,会想到定义不定长参数方法。定义不定长参数方法语法如下:
返回值 方法名(参数数据类型...参数名称)
“...” 指的是不定长参数
例7.9
public class Demo4{
public static int add(int a,int b) {//定义一个方法
return a+ b;
}
public static double add(double a,double b) {//与第一个方法名称相同、参数类型不同
return a+b;
}
public static int add(int a) {//与第一个方法参数个数不同
return a;
}
public static double add(int a,double b) {//先int参数,后double参数
return a; //输出int参数值
}
public static double add(double a,int b) {//先double参数,后int参数
return b; //输出int参数值
}
public static int add(int...a) {//定义不定长参数方法
int s = 0;
for(int i= 0;i<a.length;i++) { //根据参数个数做循环操作
s += a[i]; //将每个参数累加
}
return s; //将计算结果返回
}
public static void main(String[] args) {
System.out.println("调用add(int,int)方法:"+add(1,2));
System.out.println("调用add(double,double)方法:"+add(2.1,3.3));
System.out.println("调用add(int)方法:"+add(1));
System.out.println("调用add(int,double)方法:"+add(5,8.0));
System.out.println("调用add(double,int)方法:"+add(5.0,8));
}
}
运行结果:
在参数列表中使用“...”形式定义不定长参数,其实这个不定长参数a就是一个数组,编译器会将“int…a”这种形式看作是“int[]a”,所以在add()方法体作累加操作时使用到了for循环语句,在循环中是根据数组a的长度作为循环条件的,最后将累加结果返回。
7.6 final关键词
final被译为”最后的“”最终的“,凡是被final关键词修饰过的内容都是不可改变的。
1、final变量
修饰变量——不能被改变(常量)
例如,在类中定义PI值,可以使用如下语句:
final double PI = 3.14;
当在程序中使用PI这个常量时,她的值就是3.14.如果在程序中再次对定义为final的常量赋值,编译器将不会接受。
2、final方法
修饰方法——不能被重写
将方法定义为final类型,可以防止子类修改父类的定义与实现方式,同时定义为final的方法的执行效率要高于非final方法。
因为打开电视这个方法是由final修饰的,子类无法重写。
3、final类
修饰类——不能被继承
如果将某个类设置为final类,则该类中的所有方法都被隐式设置为final方法,但是final类中的成员变量可以被定义为final或非final形式。
报错原因:类型Dad不能将最终类Baby子类化。
7.7 多态
利用多态可以使程序具有良好的扩展性,并可以对所有类对象进行通用的处理。
下面代码中的这种将子类对象视为父类对象的做法称为“向上转型”。
class Shape{} //图形类
class Square extends Shape{} //正方形类继承图形类
class Circular extends Shape{} //圆形类继承图形类
public class Demo5 {
public static void draw(Shape s) { //绘制方法
if(s instanceof Square) { //如果是正方形
System.out.println("绘制正方形");
}else if(s instanceof Circular) { //如果是圆形
System.out.println("绘制圆形");
}else { // 如果是其他类型
System.out.println("绘制父类图形");
}
}
public static void main(String[] args) {
draw(new Shape());
draw(new Square());
draw(new Circular());
}
}
运行结果:
7.8 抽象类与接口
1.抽象类
如果声明一个抽象方法,就必须将承载这个抽象方法的类定义为抽象类,不能在非抽象类中获取抽象方法。只要类中有一个抽象方法,此类就被标记为抽象类。
使用abstract关键字定义的类称为抽象类,使用这个关键字的方法称为抽象方法。
抽象方法:
修饰符 abstract 返回参数 方法名 (传入参数);
抽象方法没有方法体
抽象类 :有抽象方法的类一定是抽象类
public abstract void methodName();
假设父类是抽象类,子类是普通类,子类继承父类就需要被重写,如果不重写就会报错。
承载这个抽象方法的抽象类必须被继承,抽象类除了被继承没有任何意义。
作用:继承,制定规则 。
2.接口
所有方法都是抽象方法
修饰符 interface 接口名{
}
实现 implements
Java语言每个类可以实现多个接口,可以单继承,多实现。
Java中不允许出现多重继承,但使用接口就可以实现多重继承。一个类可以同时实现对各接口。
修饰符 class 类名 implements 接口1,接口2,...{
}
interface Paintable{ //可绘制接口
public void draw(); //绘制抽象方法
}
class Quadrangle2{ //四边形类
public void doAnything() {
System.out.println("四边形提供的方法");
}
}
//平行四边形,继承四边形类,并实现了可绘制接口
class Parallelogram extends Quadrangle2 implements Paintable{
public void draw() {
System.out.println("绘制平行四边形");
}
}
//正方形类,继承四边形类,并实现了可绘制接口
class Square2 extends Quadrangle2 implements Paintable{
public void draw() { //由于该类实现了接口,所以需要覆盖draw()方法
System.out.println("绘制正方形");
}
}
//圆形类,仅实现了可绘制接口
class Circular2 extends Quadrangle2 implements Paintable{
public void draw() {
System.out.println("绘制圆形");
}
}
public class Dome7 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Square2 s = new Square2();
s.draw();
s.doAnything();
Parallelogram p = new Parallelogram();
p.draw();
p.doAnything();
Circular2 c = new Circular2();
c.draw();
}
}
运行结果: