第七章总结

肖知云

已于 2023-04-07 13:57:26 修改

阅读量64

点赞数

文章标签： ui xhtml 前端

于 2023-04-04 22:00:52 首次发布

本文链接：https://blog.csdn.net/xy164914506/article/details/129463981

版权

一、类的继承

继承在面对对象开发思想中是一个非常重要的概念，它使整个程序架构具有一定的弹性。继承在人类个体之间说的是物质的继承，那么在Java中类与类之间的继承也类似于此，类在继承关系中分为两种

一种是父类，属于是被继承类

继承关键词：extends

父类和普通类的写法相同：

public class 父类类名{

}

一种是子类，属于是继承类，如果某一个类继承了另一个类，那么该类就是子类

子类写法：

public class 子类类名 extends 父类类名{

}

被继承的类就是父类。Java语言每个类只能继承一个父类/单继承，在Java语言中，一个类继承另

所有类的构造方法第一行都有一个隐藏的“super（）；

作用是在执行该构造方法之前调用其父类构造方法。子类在继承父类之后，创建子类对象的同时也会调用父类的构造结果。

举例7.1代码


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构造方法
 
	}
 
}

运行结果

2. 在电话类基础上衍生出手机类：

public class Parent {//电话类
	String button="button:0~9";//成员属性，10个按键
	void call() {//拨打电话功能
		System.out.print("开始拨打电话");
	}
}
public class Child extends Parent {//手机类继承电话类
	String screen="screen:液晶屏";//成员属性，液晶屏幕
}
public class Demo {
 
	public static void main(String[] args) {
		Child motto=new Child();
		System.out.println(motto.button);//子类调用父类属性
		System.out.println(motto.screen);//子类调用父类没有的属性
		motto.call();//子类调用父类方法
	}
}

运行结果

所有类的构造方法第一行都有一个隐藏的“super（）；”，作用是在执行该构造方法之前调用其父类构造方法

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

Java虽然不允许同时继承两个父类，但不代表没有多继承的关系，可以通过类似“祖父>父亲>儿子>孙子”之类的方式实现多代继承

二、Object类

Object类是所有类的父类，在Object类中，主要包括clone（），finalize（），equals（），toString（）等方法 clone 是克隆的含义

1、getClass（）方法：

语法：getClass（）.getname（）;

可以将getClass（）方法与toString（）方法使用

2、toString（）方法：
to String（）的功能是加一个对象返回为字符串形式，它会返回一个String实例，在实际的应用中通常写to String（）方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的to String（）方法

.让学生自我介绍：

public class Parent {//创建类
	String name;//定义name变量
	int age;//定义age变量
	public Parent(String name,int age) {//定义构造方法
		this.name=name;//传入参数
		this.age=age;
	}
	public String toString() {//重写toString()
		return"我叫"+name+",今年"+age+"岁。";//返回值
	}
	public static void main(String[] args) {
		Parent P1=new Parent("张三",16);//新建对象P1
		System.out.println(P1);//输出P1
		Parent P2=new Parent("李四",19);//新建对象P2
		System.out.println(P2);//输出P2
}
}

运行结果

equals（）方法：

在java语言中，有两种比较对象的方式，分别为q运算符与equals（）方法，两者的区别在于：

“==”比较的是两个对象引用内存地址是否相同，而equals（）方法比较的是两个对象的实际内容

public class Parent{
 int id;//身份证
 String name;//名字
 public Parent(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;
  Parent other=(Parent) obj;//将参数强转成本类对象
  if(id!=other.id)//如果两者的身份证号不相等
   return false;
  return true;
 }
 public String toString() {//重写Object类的toString()方法
  return name;//只输出名字
 }
 public static void main(String[] args) {
	 Parent p1=new Parent(220,"tom");
	 Parent p2=new Parent(220,"汤姆");
	 Parent p3=new Parent(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));
 }
 }

运行结果

3.对象类型的转换

向上转型：

将子类对象赋值给父类引用

自动类型转换

如：Animal a = new Dog();

四、向下转型

运用向下转型，如果把一个较抽象的类的对象转化为一个叫具体的类的对象，这样的转换通常会出现错误，因此，向下转型是不安全的

父类转子类，父类对象赋值给子类引用

Dog a = (Dog) new Animal():

例题7.6

这样写则会报错，因为父类对象不能直接赋值给子类对象。如果想要告诉编译器“某只鸟就是一只鸽子”，则需要强制类型转换。因此，要实现强制转换则将第八行代码修改为以下就好了

5，方法的重载

重载：

方法名相同，参数不同

7.编写不同形式的加法运算方法：

public class Parent{
	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[]) {
		System.out.println("调用add（int，int）方法："+add(1,2));
		System.out.println("调用add（double,doouble）方法："+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));
	}
}

六、final关键字

1、final变量

final关键字用于变量声明，一旦该变量被设定，就不可以在改变该变量的值，final关键字定义的变量必须在声明时对其进行赋值操作

语法：Final double Pi=3.14；

final修饰变量——不能被改变（常量）

public class Parent{//创建Parent
	static final double Pi=3.1415926;//定义圆周率Pi
	public static void main(String[] args) {
		System.out.print("圆周率的值为："+Pi);//输出圆周率Pi
		System.out.print("半径为3的园的周长为："+(2*3*Pi));//输出周长
		//尝试修改Pi的值
		Pi=3.1415926;
	}
}

报错原因是：Pi不允许被修改（不能对Final字段Parent.Pi赋值）

2、final方法

可以防止子类修改父类的定义与现实方法，执行效率高于非final方法

语法：private final void test（）{

...//省略一些程序代码

}

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

3、final类

使用final类可以使该类不被任何类继承，并且不允许其他人对这个类进行任何改动

语法：final 类名{}

Final修饰类——不能被继承

final class FinalClass{//被FinalClass修饰的类
	
}
public class FinalTest extends FinalClass{//强行继承FinalClass
 
}

报错原因：类型 FinalTest 不能对最终类 FinalClass 进行子类化

使用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);//判断正方形是否为园形的子类
	}
}