第七章总结-CSDN博客

本文链接：https://blog.csdn.net/hj920885623/article/details/129938234

类的继承

在Java中，子类继承父类需要使用一个关键字——extends，并且Java只支持单继承，一个子类只能有一个父类

父类写法与普通类相同
public class 父类类名（）{
}

子类
public class 子类类名 extends 父类类名（）{
}

在Java中class可以有无限个，public class只能有一个

例题7.1：

package qidanyuan;

	class Parent{
		public Parent() {
		System.out.println("调用父类构造方法");
	}
}
class child extends Parent{
	public child() {
		System.out.println("调用子类构造方法");
	}
}
public class jicheng7_1{
	public static void main(String[] args) {
		new child();
	}
}

运行结果如下：

例题7.2

package qidanyuan;


class Telephone{
	String button = "bubutton:0-9";//成员属性
	void call() {
		System.out.print("开始拨打电话");//开始拨打电话
	}
}

class Mobile  extends Telephone{//手机类继承电话类
	String screen = "screen:液晶屏";    //成员属性，液晶屏幕
}

public class jicheng7_2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Mobile motto = new Mobile();
		System.out.println(motto.button);//子类调用父类属性
		System.out.println(motto.screen);//子类调用父类没有的属性
		motto.call();        //子类调用父类方法
	}

}

运行结果如下：

Object 类

Object是比较特殊的类，它是所有类的父类

在Object类中，有许多方法，其最主要的四种方法分别为：clone（）、equals（）、finalize（）、toString（）

其中最常用的两中方法为：toString（）和 equals（）

重写：

子类重写父类的方法（只有子类才能重写父类方法，必须要有继承关系）

方法的重写：返回参数相同方法名相同传入参数相同只有方法体不同

toString（）的重写

例题7.3

package qidanyuan;

public class jicheng7_3 {
	String name;
	int age;
	public jicheng7_3(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public String toString() {
		return"我叫"+name+"，今年"+age+"岁。";
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		jicheng7_3 s1 = new jicheng7_3("张三",16);
		System.out.println(s1);
		jicheng7_3 s2 = new jicheng7_3("李四",19);
		System.out.print(s2);
	}

}

运行结果如下：

equals（）的重写

例题7.4：

package qidanyuan;

public class jicheng7_4 {
	int di;
	 String name;
	 
	 public jicheng7_4(int id, String name) {
	  this.di = id;
	  this.name = name;
	 }
	 public boolean epuals(Object obj) {
	  if(this == obj)
	   return true;
	  if(obj == null)
	   return false;
	  if(getClass() != obj.getClass())
	   return false;
	  jicheng7_4 other = (jicheng7_4)obj;
	  if(di != other.di)
	   return false;
	  return true;
	 }
	 public String toString() {
		 return name;
	 }
	 public static void main(String[] args) {
	  // TODO Auto-generated method stub
	  jicheng7_4 p1 = new jicheng7_4(220,"tom");
	  jicheng7_4 p2 = new jicheng7_4(220,"汤姆");
	  jicheng7_4 p3 = new jicheng7_4(330,"张三");
	  Object o = new Object();
	  
	  System.out.println(p1+ "与"+p2+"是否为同一个人");
	  System.out.println("equals()方法的结果："+ p1.epuals(p2));
	  System.out.println("==运算符的结果："+(p1 == p2));
	  
	  System.out.println();
	  System.out.print(p1+"与"+p3+"是否为同一个人");
	  System.out.println(p1.epuals(p3));
	  
	  System.out.println();
	  System.out.print(p1 + "与" + o + "是否为同一个人");
	  System.out.println(p1.epuals(o));
	 }
}

运行结果如下：

对象类型的转换

向上转换：

将子类类型的对象转换为父类类型的对象，也就是向上转型

如下：

Animal a = new Animal();
将子类对象赋值给父类引用
Animal a = new Dog();
自动类型转换

例题7.5

package qidanyuan;
class People{}
class Teacher extends People{}
public class jicheng7_5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		People tom = new Teacher();
	}

}

向下转型：

与向上转型相反，是父类转子类
Dog a = (Dog)new Animal();
因为是强制类型转换所有向下转型是不安全的

例题7.6

package qidanyuan;
class Pigeon extends jicheng7_6{}
public class jicheng7_6 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		jicheng7_6 bird = new Pigeon();//某只鸽子是一只鸟
		Pigeon pigeon = bird;//某只鸟是一只鸽子
	}

}

会有报错显示：

因此需要借助强制类型转换，将

Pigeon pigeon = bird;

转换为

Pigeon pigeon = (Pigeon) bird;

使用instanceof关键字判断对象类型

instanceof前面是对象名，后面是类名，作用是判断前面的对象是否属于该类或其子类

对象名 instanceof 类名

instanceof前面是对象名，后面是接口名，作用是判断前面的对象是否属于该接口的实现类

例题7.7

package qidanyuan;
class Quadrangle{}
class Square extends Quadrangle{}
class Circular{}
public class jicheng7_7 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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.8

package qidanyuan;

public class jicheng7_8 {
	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 int add(int a,double b) {//先 int 参数，后 double 参数
			return a;//输出 int 参数值
		}
		public static int add(double a,int b) {//先 double 参数，后 int 参数
			return b;
		}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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

package qidanyuan;

public class jicheng7_9 {
	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 int add(int a,double b) {
		return a;
	}
	public static int add(double a,int b) {
		return b;
	}
	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) {
		// TODO Auto-generated method stub
		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));
		//调用不定长参数方法
		System.out.println("调用不定长参数方法："+ add(1,2,3,4,5,6,7,8,9));
		System.out.println("调用不定长参数方法："+ add(1));
	}

}

运行结果如下：

final关键字

final变量

用final修饰的变量就不可以在改变该变量的值

final修饰变量——不可改变的量（常量）

例题7.10

package qidanyuan;

public class jicheng7_10 {
	static final double PI = 3.1415926;
	 public static void main(String[] args) {
	  // TODO Auto-generated method stub
	  System.out.print("圆周率为："+PI);
	  System.out.print("半径3的原的周长为："+ (2*3*PI));
	  //尝试修改PI的值
	  PI = 3.1415927;
	 }
}

如果改变用final修饰的变量代码会报错

final方法

final修饰方法——不能被重写

例题7.11

package qidanyuan;

public class jicheng7_11 {
	public final void turnOnTheTV() {
		System.out.print("爸爸打开了电视");
	}
}
class Baby extends jicheng7_11{
	public final void turnOnTheTV() {
		System.out.print("宝宝也要打开了电视");
	}
}

如果用 final修饰则子类不可以重写父类的方法，代码报错，如图：

final类

final修饰类——不能被继承

如果不希望一个类被任何类继承，只需要在类的前面加上final就行

多态

多态可以使程序具有良好的扩张性，可以对所有类对象经行通用的处理

拿图形类举例：图形里有正方形、圆形、三角形，这些都是图形类的子类，这就是图形类的多态

例题7_12

package qidanyuan;

class Shape{}//图形类
class Square1 extends Shape{}//正方形类继承图形类
class Circular1 extends Shape{}//圆形类继承图形类
public class jicheng7_12 {
	public static void draw(Shape s) {//绘制方法
		if(s instanceof Square1) {//如果是正方形
			System.out.println("绘制正方形");
		}else if (s instanceof Circular1) {//如果是圆形
			System.out.println("绘制园形");
		}else {//如果是其他形
			System.out.println("绘制父类图形");
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		draw(new Shape());
		draw(new Square1());
		draw(new Circular1());

	}

}

运行结果如下：

抽象类与接口

抽象类

使用 abstract 关键字定义的类称为抽象类，而被 abstract定义的方法称为抽象方法

抽象类：有抽象方法的类一定是抽象类

抽象方法：没有方法体，在修饰符后面加 abstract

抽象类一般用作于父类，类似于一种规则

假如子类是一个普通类，但它的父类是抽象类，父类里有抽象方法，那子类就必须重写父类的抽象方法，不管子类需不需要使用父类的抽象方法

抽象类的语法如下：

修饰符 abstract class 类名{ }

抽象方法的语法如下：

修饰符 abstract 返回参数方法名（传入参数）;

接口

实现关键字——implements

接口是抽象类的延伸，可以看成是纯粹的抽象类，它与抽象类不同，它的代码里只会有抽象方法，换句话说：所有方法都是抽象方法才是接口

它使Java语言中每个类都可以实现多个接口，无论你的类有多少个接口只要你重写了接口里的所有抽象方法，你的类都不会报错

定义接口的语法如下：

修饰符 interface 接口名{ }

实现多个接口的语法如下：

修饰符 class 类名 implements 接口名1，接口名2，...{ }

列题7_13

package qidanyuan;

interface Paintable1{		//新建一个接口
	public void draw();		//绘制对象方法
}
//四边形类
class Quadrangle1{
	public void doAnything() {
		System.out.println("四边形提供的方法");
	}
}
//平行四边形类，继承四边形类，，并实现了绘制接口
class Parallelogram1 extends Quadrangle1 implements Paintable1{
	public void draw() {
		System.out.println("绘制平行四边形");
	}
}
//正方形类，继承四边形类，，并实现了绘制接口
class Square2 extends Quadrangle1 implements Paintable1{
	public void draw() {
		System.out.println("绘制正方形");
	}
}
//圆形类，仅实现了绘制接口
class Circular2 implements Paintable1{
	public void draw() {
		System.out.println("绘制圆形");
	}
}
public class jicheng7_13 {

	public static void main(String[] args) {
		
		Square2 s1 = new Square2();
		s1.draw();
		s1.doAnything();
		Parallelogram1 p = new Parallelogram1();
		p.draw();
		p.doAnything();
		Circular2 c = new Circular2();
		c.draw();
	}

}

运行结果如下：