第七章总结

目录

一、类的继承

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

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

代码如下:

第七章总结_第1张图片

 第七章总结_第2张图片

运行结果:

第七章总结_第3张图片

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

运行结果:

第七章总结_第4张图片

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

运行结果:

第七章总结_第5张图片

 三、对象类型的转换

对象之间的类型转换在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;//某只鸟是一只鸽子
	}
 
}

将会出现报错:

第七章总结_第6张图片

 需要借助强制类型转换,语法如下:

子类类型  子类对象  =(子类类型)父类对象;

将例题中第八行的代码修改为:

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

将会出现报错:

第七章总结_第7张图片

因为四边形类与圆形类没有继承关系,所以不能用 instanceof 来比较;当我们删除或者注释掉那行代码;运行结果如下:

第七章总结_第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));
 
	}
 
}

运行结果:

第七章总结_第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 

运行结果:

第七章总结_第10张图片

六、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修饰的变量报错:

第七章总结_第11张图片

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

运行结果:

第七章总结_第12张图片

 八、抽象类与接口

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

}

运行结果:

第七章总结_第13张图片

 

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

1.将普通类改成抽象类

2.将没写的方法重写

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

你可能感兴趣的:(jvm)