第七章总结

已于 2023-04-07 10:55:15 修改
阅读量36 收藏
点赞数
文章标签： java 开发语言
于 2023-04-04 19:06:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74168627/article/details/129937363
版权

7.1类的继承

继承在面向对象开发思想中是一个非常重要的概念

例题7.1:


class Paren {        //定义一个父类方法
	public Paren() {
		System.out.println("调用父类构造方法");
	}
}
class Child extends Paren{    //定义一个子类方法继承父类
	public Child() {
		System.out.println("调用子类构造方法");
	}
}

public class liti7_1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Child();
	}

}

代码结果：

子类继承父类之后可以调用父类创建好的属性和方法 

例题7.2：


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

public class liti7_2_2  extends liti7_2_1{//手机类继承电话类
	String screen = "screen:液晶屏";    //成员属性，液晶屏幕
	void call() {
		System.out.print("挂断电话");
	}
}

public class liti7_2_3 {

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

}

 代码结果：

7.2 Object类

Object类比较特殊，他是所以类的父类，类似原神世界树一样的存在，是java类层中的最高层类，用户创建一个类时，除非已经指定要从其他类继承，否则就是默认继承Object。

7.2.1 getClass()方法

用来查询类的名称

语法如下：

getClass().getname();

7.2.2 toString方法

将一个对象返回为字符串形式

例题7.3：

public class ilti7_3 {
	//成员变量
	String name;
	int age;
	public ilti7_3(String name,int age) {	//构造方法
		this.name = name;
		this.age = age;
	}
	public String toString() {
		return "我叫"+name+"，今年"+age+"岁。";//定义一个方法名为toString
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ilti7_3 s1 = new ilti7_3("张三",16);
		System.out.println(s1);
		ilti7_3 s2 = new ilti7_3("李四",19);
		System.out.println(s2);
	}

}

运行结果：

7.2.3 equals()方法

比较两个对象的实际内容是否相同

例题7.4：


public class liti7_4 {
	int di;
	String name;
	
	public liti7_4(int id, String name) {
		super();
		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;
		liti7_4 other = (liti7_4)obj;
		if(di != other.di)
			return false;
		return true;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		liti7_4 p1 = new liti7_4(220,"tom");
		liti7_4 p2 = new liti7_4(220,"汤姆");
		liti7_4 p3 = new liti7_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));
	}

}

运行结果：

7.3对象类型的转换

7.3.1向上转型

子类对象赋值给父类引用

Animal a = new Dog();

自动类型转换

例题7.5：

class People{}		//创建父类方法
class Tecacher extends People{}	//创建子类方法继承父类
public class liti7_5 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		People tom = new Tecacher();
	}

}

7.3.2向下转型

父类对象赋值给子类引用

Dog a = (Dog)new Animal();

强制类型转换

例题7.6

class Bird{};
class Pigeon extends Bird{};
public class liti7_6 {

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

}

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

 判断对象是否属于该其类或其子类

语法如下：

对象名 instanceof 类名；

判断对象是否属于该接口的实现类

对象名 instanceof 接口名

例题7.7：

class Quadrangle{}
class Square extends Quadrangle{}
class Circualr{}

public class liti7_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 Circualr);// 判断正方形是否为圆形的子类
	}

}

 因为四边形类和圆形类没有继承关系，因此上述代码会报错，运行不了

更改后为：

class Quadrangle{}
class Square extends Quadrangle{}
class Circualr{}

public class liti7_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);//判断正方形是否为四边形的子类
	}

}

 运行结果为：

 7.5方法的重载

方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或参数类型不同即可

例题7.8：

public class liti7_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;						//输出int参数值
	}
	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(1,8.0));
		System.out.println("调用add(double,int)方法："+ add(5.0,8));
	}

}

代码结果：

例题7.9使用不定长参数超载加法运算方法：

public class liti7_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) {//先int参数后double参数
		return a;						//输出int参数值
	}
	public static int 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) {
		// 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(1,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));
	}

}

代码结果：

 7.6final关键字

7.6.1final变量

final：最终的，最后的。它可以用来声明变量，一旦该变量被设定，就不可再改变我们称之为常量

例题7.10：


public class liti7_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;
	}

}

 因为我们已经把PI修饰成常量了，所以我们再此赋值时会报错，此代码运行不了。

 7.6.2final方法

final修饰方法————该方法不可被重写

例题7.11：


public class liti7_11 {
	public final void turnOnTheTV() {//定义一个父类方法用final修饰
		System.out.print("爸爸打开了电视");
	}
}
class Baby extends liti7_11{
	public final void turnOnTheTV() {//定义一个子类方法用final修饰
		System.out.print("宝宝也要打开电视");
	}
}

7.6.3final类

被final修饰的类不可被继承，不可被更改如果希望一个类不可被任何类继承，或更改，可以使用将这个类设置为final类。

语法如下：

final 类名{}

如果某个类被定义为final类，那么这个类9999里的所以方法都被隐式设置为final方法，但是这个类1中的成员变量可以被定义为final或者非final形式

7.7多态

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理，拥有多种结果都可以叫多态

例题7.12：

class Shape {}		//图形类
class Square extends Shape {}		//正方形类继承图形类
class Circular extends Shape {}		//圆形类继承图形类

public class phone {
	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抽象类与接口

7.8.1抽象类

仅用来描述特征且极具抽象性类，在java中被定义为抽象类

抽象类与方法使用abstract关键词定义

抽象方法语法：修饰符 abstract 返回参数 方法名 (传入参数);

与传统方法不同，抽象方法没有方法体，有抽象方法的类一定是抽象类,当父类是抽象类，有抽象方法时，它的子类要么重写父类的抽象方法，要么定义为抽象类（抽象方法重写之后就是普通方法了）

抽象类语法：修饰符 abstract class 类名{}

7.8.2接口

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中所有的方法都是抽象方法·，由于java语言每个类只能继承一个父类，因此接口的作用就凸显出来，一个类可以实现多个接口，可以看作一个类可以拥有多个父类（便于理解并不是官方意思）

接口使用interface关键词定义

接口语法：修饰符 interface 接口名

实现 implements

java语言每个类可以实现多个接口

实现语法：修饰符 class 类名 implements 接口1，接口2，...{}

例题7.13：

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 Square1 extends Quadrangle1 implements Paintable1{
	public void draw() {
		System.out.println("绘制正方形");
	}
}
//圆形类，仅实现了绘制接口
class Circular1 implements Paintable1{
	public void draw() {
		System.out.println("绘制圆形");
	}
}
public class liti7_13 {

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

}

代码结果：

 

 

总结：这章与上章都属于思想类的知识，尤为重要，需反复学习

卉冉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值