7.1 类的继承
Java语言中每个类只能继承一个父类
extends 继承
父类 写法与普通写法相同
public class 父类类名(){
}
子类
public class 子类类名 extends 父类类名(){
}
【例】 创建子类对象,观察构造方法执行顺序
父类Parent和子类Child都各自有一个无参的构造方法 ,在main()方法中创建子类对象时,Java虚拟机会先执行父类的构造方法,然后再执行子类的构造方法。
public class Parent {//引入类
public Parent() {
System.out.println("调用Paren类构造方法");//输出
}
}
public class Child extends Parent {//引入类
public Child() {
System.out.print("调用Child类构造方法");//输出
}
}
public class Demo {//引入类
public static void main(String[] args) {
new Child();//调用Child构造方法
}
}
所有类的构造方法第一行都有一个隐藏的“super();”
作用是在执行该构造方法之前调用其父类构造方法
【例】在电话类基础上衍生出手机类
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();//子类调用父类方法
}
}
方法的重写(子类重写父类方法):返回参数相同,方法名相同,传入参数相同,只有方法体不同
7.2 Object类
Object类:所有类的父类,Java类层中的最高层类。
1.getClass()方法
getClass()方法是Object类定义的方法,它会返回对象执行时的Class实力,然后使用此实例调用getName()方法可以取得类的名称。语法如下:
getClass().getname();
可以将 getClass()方法与toString()方法联合使用。
2.toString()方法
toString()方法的功能是将一个对象返回为字符串形式,它会返回一个String实例。在实际的应用中通常重写toString()方法,为对象提供一个特定的输出模式。当这个类型转换为字符串或与字符串连接时,将自动用重写的toString()方法。
【例】让学生自我介绍
创建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 People{
int id;//身份证
String name;//名字
public People(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;
People other=(People) obj;//将参数强转成本类对象
if(id!=other.id)//如果两者的身份证号不相等
return false;
return true;
}
public String toString() {//重写Object类的toString()方法
return name;//只输出名字
}
public static void main(String[] args) {
People p1=new People(220,"tom");
People p2=new People(220,"汤姆");
People p3=new People(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 对象类型的转换
7.3.1 向上转型
子类对象赋值给父类引用
Animal a=new Dong();
自动类型转换
7.3.2 向下转型
父类对象赋值给子类引用
Dog a=(Dog)new Animal();
强制类型转换
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 类名
对象名 instanceof 类名
判断对象是否属于该类或子类
对象名 instanceof 类名
判断对象是否属于该接口的实现类
class Quadrangle{}//创建四边形类
class Square extends Quadrangle{}//创建正方形类继承四边形类
class Circular{}//创建圆形类
public class FinalTest{
public static void main(String args[]) {
Quadrangle q=new Quadrangle();//四边形对象
Square s=new Square();//正方法对象
System.out.println(q instanceof Square);//判断四边形是否为正方形的子类
System.out.println(s instanceof Quadrangle);//判断正方形是否为四边形的子类
System.out.println(q instanceof Circular);//判断正方形是否为园形的子类
}
}
因为四边形类与圆形类没有继承关系,因此两者不能使用instanceof关键字进行比较,否则会发生“不兼容”错误
7.5 方法的重载
重载
方法名相同,参数不同
方法重载:让方法名相同而形参不同的构造方法同时存在。
【例】编写不同形式的加法运算方法
public class OverLoadTest{
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.6 final关键字
7.6.1 final变量
final修饰变量——不能被改变(常量)
final关键字用于变量声明,一旦该变量被设定,就不可以在改变该变量的值,final关键字定义的变量必须在声明时对其进行赋值操作
语法:Final double Pi=3.14;
7.6.2 final方法
可以防止子类修改父类的定义与现实方法,执行效率高于非final方法
语法:private final void test(){
...//省略一些程序代码
}
final修饰方法—— 不能被重写
7.6.3 final类
使用final类可以使该类不被任何类继承,并且不允许其他人对这个类进行任何改动
语法:final 类名{}
Final修饰类——不能 被继承
7.7 多态
class Shape{}//图形类
class Square extends Shape{}//正方形类继承图形类
class Circular extends Shape{}//圆形继承图形类
public class Demo2 {
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 Shape());
draw(new Circular());
}
}
7.8 抽象类与接口
7.8.1 抽象类
一般将父类定义为抽象类,需要使用这个父类进行继承与多态处理。
抽象方法
修饰符 abstract 返回参数 方法名(传入参数);
注释:没有方法体,要用abstract来修饰
public abstract void methodName();
抽象类 有抽象方法的类一定是抽象类
修饰符 abstract class 类名{
}
当父类为抽象类子类为普通类时,要继承父类必须重写父类中的所有方法,不然会报错,或者将子类改为抽象类
7.8.2 接口
接口:所有方法都是抽象方法且没有方法体
Java语言中每个类只能继承一个父类,但是每个类可以实现多个接口,所以出现了接口。
修饰符 interface 接口名{
}
实现 implements
Java语言每个类可以实现多个接口
修饰符 class 类名 implements 接口1,接口2,接口3,...{
}
一个类继承一个父类的同时再实现一个接口:
修饰符 class 类名 extends 父类名 implements 接口名{
}
注释:先继承再实现
一个接口可以继承另一个接口 :
interface intf1{}
interface intf2 extends intf1{}//接口继承接口
【例】将绘画方法设为接口方法
将图形对象的绘图方法剥离出来,作为Paintable可会直接口中的抽象方法。创建四边形类作为平行四边形和正方形的父类,同时让这两个子类实现Paintable接口。创建圆形类实现Paintable接口,但不继承四边形类。
package seven;
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();
}
}