第七章总结

丑丑又哪错了啊啊啊

已于 2023-04-07 11:26:51 修改

阅读量60

点赞数

文章标签： java jvm 开发语言

于 2023-04-04 15:44:36 首次发布

本文链接：https://blog.csdn.net/cc3993/article/details/129864466

版权

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

一、类的继承

在Java语言中每个类只能继承一个父类（单继承）

extends（继承）

父类与普通类写法相同

public class 父类类名（）{

...

}

子类

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

...

}

运行时会把父类、子类都执行，会先执行父类，再执行子类

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（）；”，作用是在执行该构造方法之前调用其父类构造方法

子类调用成员方法遵循就近原则，先看子类，没有再看父类，再没有看父类的父类，以此类推，如果到最后还是没有，则报错

子类重写父类的方法（以父子关系存在为前提）

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();//子类调用父类方法
	}
}

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

二、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
}
}

3、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));
 }
 }

三、向上转型

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

Animal a = new Dog();

自动类型转换

四、向下转型

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

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

Dog a = (Dog) new Animal():

报错原因：父类对象不能直接赋予子类对象

强制类型转换

语法

子类类型子类类型=（子类类型）父类对象；

class Bird {}
class Pigeon extends Bird{}
	public  class Parent{
		public static void main (String[]args) {
			Bird bird=new Bird();//某只鸽子是一只鸟
			Pigeon pigeon=(Pigeon)bird;//某只鸟是一只鸽子
		
	}
}

五、方法的重载

方法名相同参数不同（返回参数不同，传入参数不同）

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

报错原因：不兼容的条件操作数类型四边形和圆形

因为四边形类与圆形类没有继承关系，因此两者不能使用instanceof关键字进行比较，否则会发生“不兼容”错误

八、多态jiu

继承父类所形成的多种结果，使用多个方法、变量、类，只要结果不同就是多态

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

class Shape{}//图形类
class Square extends Shape{}//正方形类继承图形类
class Circular extends Shape{}//圆形继承图形类
public class Parent {
	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());
		
	}

九、抽象类与接口

1、抽象类

普通方法：修饰符返回参数方法名（传入参数）{

方法体

}

抽象方法：修饰符 abstract 返回参数方法名（传入参数）；

没有方法体，用abstract修饰，用“ ；”结尾，有抽象方法的类一定是抽象类

普通类：修饰符 class 类名{ }

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

子类继承父类，如果父类是抽象类，子类是普通类，那么子类不能继承父类的抽象方法，只有通过重写才可以使普通子类继承抽象类父类

2、接口

接口是抽象类的延申，接口中的所有方法都没有方法体

一个类所有方法都是抽象方法,java语言是单继承，使用接口就可以实现多重继承

接口使用interface关键字进行定义

修饰符 interface 接口名{

}

实现implements关键字，Java语言每个类可以实现多个接口

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

}

interface Paintable{//可绘制接口
	public void draw();//绘制抽象方法
}
class Quadrangle{//四边形类
	public void doAnhything() {
		System.out.println("四边形提供的方法");
	}
}
//平行四边形类，继承四边形类，并实现了可绘制接口
class Parallelogram extends Quadrangle implements Paintable{
	public void draw() {//由于该类实现了接口，所以需要覆盖draw（）方法
		System.out.println("绘制平行四边形");
	}
}
//正方法类，继承四边形类，并实现了可绘制接口
class Square extends Quadrangle implements Paintable{
	public void draw() {
		System.out.println("绘制正方形");
	}
}
//圆形类，仅实现了可绘制接口
class Circular implements Paintable{
	public void draw() {
		System.out.println("绘制圆形");
	}
}
public class Parent{
	public static void main(String[] args) {
		Square s=new Square();
		s.draw();
		s.doAnhything();
		Parallelogram p=new Parallelogram();
		p.draw();
		p.doAnhything();
		Circular c=new Circular();
		c.draw();
	}
}