第七章总结

目录

一、类的继承

二、Object类

1.getClass()方法

2.toString()方法

3.equals()方法

 三、对象类型的转换

1.向上转型

2.向下转型

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

五、方法的重载 

不定长参数：

六、final关键字

1.final变量

 2.final方法

3.final类

---

一、类的继承

定义：

继承在人类个体之间说的是物质的继承，那么在Java中类与类之间的继承也类似于此，类在继承关系中分为两种，一种是父类，属于是被继承类，一种是子类，属于是继承类；

如果某一个类继承了另一个类，那么该类就是子类，被继承的类就是父类；

Java中一个类继承另一个类，需要使用到关键字extends。

使用方法：

class Child extends Parent {} //类Child 继承于类 Parent

注意:

在Java中只支持单继承，一个子类只能拥有一个父类，但是一个父类可以拥有多个子类；不允许多继承，但是允许多重继承。

错误代码如下：

class C extends A,B {}

允许多重继承：

class A{}
class B extends A{}
class C extends B{
}

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

代码如下：

 

运行结果：

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

二、Object类

Object类是Java中的顶级父类，在Java中所有类都直接或间接的继承与Object类，它是所有类的父类；主要包括clone（）、finalize（）、equals（）、toString（）等方法；

由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。（注意Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些都被定义为final类型。）

下面详细讲述Object类中的几个方法：
 

1.getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的class实例，然后使用此实例调用getName()方法可取的类的名称；可以将getClass()方法与toString()方法联合使用。

语法如下：

getClass().getName();

调用方式：

类名.toString();

2.toString()方法

toString()方法的功能是将一个对象返回为字符串形式，它会返回一个String实例；

在实际的应用中通常重写toString()方法，为对象提供一个特定的输出模式；当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法。

举例代码：

class student{
    String name;
    int age;
 
    public student() {
    }
 
    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
 //重写了父类中的toString()方法
    @Override
    public String toString(){
        return "姓名："+this.name+"，年龄："+this.age;
    }
}
 
public class Demo_3 {
    public static void main(String[] args) {
        student s1=new student("小明",18);
        System.out.println(s1.toString());
    }
}

运行结果：

3.equals()方法

在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals()方法。两者的区别在于：“==”比较的是两个对象的引用内存地址是否相等，而equals()方法比较的是两个对象的实际内容。 

注意：

在使用equals() 方法比较自行编写的类对象时，那么需要先重写equals方法，因为每个类判相等的规则都是不一样的。而且如果没有重写的话，那么系统会自动调用Object中的equals方法。

举例代码：

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) {    //重写Object类的equals()方法
	  if(this == obj)
	   return true;
	  if(obj == null)         //如果参数是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() {        //重写Object类的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));
	 }
}

运行结果：

 三、对象类型的转换

对象之间的类型转换在Java编程中还是很常见的；类型转换分为向上转型与向下转型。

注意：

只有具备继承关系得类与类之间才能进行对象类型转换，非继承关系之间不能进行类型转换。

1.向上转型

而向上转型就是将子类对象赋值给父类对象；可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型对象直接赋值给父类类型的对象；
格式为： 父类 对象名 = (父类) 子类对象;

举例代码：

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();
	}
 
}

注意：在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法；只能调用从父类中继承下来的属性与方法。

2.向下转型

向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。；但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类， 而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。

举例代码：

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 =(Pigeon)birl;    //通过强制类型转换，告诉编译器“某只鸟就是一只鸽子”

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

instsnceof的语法格式如下：

myobject instanceof ExampleClass

myobject：某类的对象引用。

ExampleClass：某个类。

误区警示：instanceof是Java语言的关键字，Java语言中的关键字都为小写。

例题代码：

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 来比较；当我们删除或者注释掉那行代码；运行结果如下：

五、方法的重载 

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

重载与重写不同但又十分相似；重写是：返回参数相同 方法名相同 传入参数相同 只有方法体不同；重载则是：方法名相同 参数不同

重载和重写的区别在于：重载必须要有继承关系才能使用，而重写只要在同一个类里就能使用

例题代码：

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

运行结果：

不定长参数：

在谈到参数个数可以确定确定两个方法是否具有重载关系时，会想到定义定义不定长参数方法；

语法如下：

返回值  方法名（参数数据类型...参数名称）

例题代码：

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 

运行结果：

六、final关键字

1.final变量

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

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

例题代码：

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修饰的变量报错：

 2.final方法

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

例题代码：

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

若用 final修饰则子类不可以重写父类的方法 ，代码将报错。

3.final类

final修饰类——不能被继承

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

七、多态

同一方法或同一个地方出现不同的形态就叫多态；

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

定义如下：

public void draw(Square s){  //绘制正方形的方法
}
public void draw(Cicular c){  //绘制圆形的方法
}

例题代码：

class Shape{}
class Square extends Shape{}
class Circular extends Shape{}

public class Demo6 {

 public static void draw(Shape s) {
  // TODO Auto-generated method stub
   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 类名{

  ... ...

}

public abstract class Parent{
    abstract void testAbstract();  //定义抽象方法
}

将抽象方法写入普通类中会报错；有两种方法改变 :

1.将abstract移除加上方法体

2.将普通类改成抽象类

2.接口

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

语法如下：

public interface Paintable {
    void draw();  //定义接口方法可省略public abstract 关键字
}

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

}

例题代码：

interface Paintable {
	public void draw();
}
class Quadrangle{
	public void doAnything() {
		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 Demo7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Square s = new Square();
		s.draw();
		s.doAnything();
		Parallelogram p = new Parallelogram();
		p.draw();
		p.doAnything();
		Circular c = new Circular();
		c.draw();
	}

}

运行结果：

 

假设接口有三个方法，但是普通类只写了两个情况该怎么解决：

1.将普通类改成抽象类

2.将没写的方法重写

对象名+instanceof+接口名（判断对象是否属于这个接口的实现类）