第七章总结

类的继承：

Java语言每一个类只能继承一个父类。叫做单继承；
extends（继承），
父类的写法；
public class 父类类名 (){
}
子类的写法
public  class 子类类名 extends 父类类名；

所有类的构造方法第一行都有一个隐藏的“super();"作用是在执行该构造方法之前调用其父类构造方法

子类重写父类的方法：

返回参数相同方法名相同传入参数相同只有方法体不同

7.1例题

public class Parent{

 public Parent(){

 System.out.println("调用Child类结构方法");

        }

}

public class Child extends Parent {

public Child(){

System.out.print("调用Child类结构方法");

         }

}

7.2例题

代码：

public class Telephone {//电话类

        String button = "button:0~9";//成员属性，10个按键

         void call() {//拨打电话功能

        System.out.println("开始拨打电话");

class Mobile extends Telephone{//手机类继承电话类

         String screen = "screen.液晶屏";//成员属性，液晶屏幕

}

public class Demo2 { public static void main(String[] args) {

// TODO Auto-generated method stub

        Mobile motto =new Mobile();

        System.out.print(motto.button);//子类调用父类属性

        System.out.print(motto.screen);//子类调用父类没有的属性

        motto.call();//子类调用父类方法

         }

}

Object类：

所有类都可以继承Object类；
getClass方法是Object类定义的方法，它会返回对象执行的Class实例。
toString方法的功能是将一个对象放回为字符串类型，它会返回一个String实例。

getCess()方法

getClass方法是Object类定义的方法。它会返回对象执行时的 Class实例，然后使用此实例调用Name()方法可以取得类的名称。语法如下，

getclass().getname();

可以将geClas0方法与toSring0方法联合使用。

2. toSming0方法

toSrng0方法的功能是将个对象返回为字符审形式， 它会返回一个String实例。在实际的应用常重写wSring0方法， 为对象提供 个特定的输出模式。 当这个类转换为字符串或与字符串连接

7.3例题

public class Student {

String name;

        int age;

        public Student(String name,int age) {

        this.name = name;

t        his.age = age;

}

        public String toString() {

        return "我叫" + name+", 今年" + age + "岁。";

}

public static void main(String args) {

        Student s1 = new Student("张三", 16);

        System.out.println(s1);

        Student s2 = new Student("李四", 19);

        System.out.println(s2);

         }

}

7.4例题

public class People {

int id;//身份证号

String name;//名字

public People(int id,String name) {

this.id = id;

this.name =name;

}

public boolean equals(Object obj) {//重写Object类的equals()方法

if(this ==obj)//如果参数与本类是同一个对象

        return false;

if(obj ==null)//如果参数是null

        return false;

if(getClass()!=obj.getClass())//如果参数与本类类型不同

        return false;

People other =(People)obj;//将参数强转成本类对象

if(id!=other.id)//如果两者的身份证号不相等

         return false;

         return false;

}

public String toString() {//重写Object类的toString()方法

return name;//只输出名字

}

public static void main(String[] args)

{

People p1 =new People(220,"tom");

People p2 =new People(220,"汤姆");

People p3 =new People(330,"张三");

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.println(p1+"与"+p3+"是否为同一人？"); System.out.println(p1.equals(p3));

System.out.print(p1+"与"+o+"是否为同一人？");

System.out.println(p1.equals(o));

        }

}

对象类型的转换：

向上转型

clone=克隆；
equals=相同；
finalize=相等；
toSteing=

子类对象赋值给父类引用 

Animal a = newDog();

自动类型转换

7.5例题

class People{}

class Teacher extends People{}

public class Demo3{

        public static void main(String[]args){

People tom = new Teacher();

         }

}

向下转型

父类对象赋值给子类引用

 Dog a = new Animal( );

强制类型转换

7.6例题

class Bird {}

class Pigeon extends Bird{}

public class Demo4{

public static void main(String[] args){

        Bird bird = new Pigeon();//某只鸽子是一只鸟

         Pigeon pigeon = bird;//某只鸟是一只鸽子

         }

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

对象名 instanceof 类名 作用：

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

7.7例题

class Quadrangle{}

class Squar extends Quadrangle{}

class Circular{}

public class Demo5{

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 Quadeangle);//判断正方形是否为四边形的子类         System.out.println(q instanceof Circular);//判断正方形是否为圆形的子类

         }

}

方法的重载

方法名相同 参数不同

7.8例题

ublic class OverLoadTest {

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

      }  

}

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

7.9例题

public class OverLoadTest2 {

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<a.length;i++) {//根据参数个数做循环操作

s +=a[i];//将每个参数累加

}

return s;//将计算机结果返回

}

public static void main(String[] args) {

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

System.out.println("调用不定长数方法："+ add(1,2,3,4,5,6,7,8,9));

System.out.println("调用不定长数方法："+ add(1));

         }

}

子类重写父类的方法：

返回参数相同 方法名相同 传入参数相同 只有方法体不同

final关键字

final变量：

final修饰变量----不可改变的量（常量）

7.10例题

public class FinalData {

static final double PI = 3.1415926;

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println("圆周率的值为:"+PI); System.out.println("半径为3的圆的周长为:"+(2*3*PI));//尝试修改PI的值

PI = 3.1415927;

final方法：

final修饰方法----不可被重写

7.11例题

class Dad {

public final void turnOnTheTV() {

System.out.println("爸爸打开了电视");

         }

}

class Baby extends Dad{

public final void turnOnTheTV() {

System.out.println("宝宝也要打开电视");

         }

}

final类：

final修饰类----不能被继承

final类无法被继承

final class FinalClass{

}

public class FinalTest extends FinalClass {

}

7.7多态

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

假如现在要编写一个绘制图形的方法draw（），如果传入正方形对象将绘制正方形，如果传入圆形对象就绘制圆形，这种场景可以使用重载来实现，定义如下：

public void draw(Square s){

//绘制正方形的方法

}

public void draw(Circular c){

//绘制圆形方法

}

例题7.12

class Shape{} //图形类

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

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

public class Demo6 {

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抽象类

抽象方选没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继系。实际上抽象类除了被继承没有任何意义。定义抽象类的语法如下：

 ublic abstract class Parent{

abstract void testAbstract(); //定义抽象方法

}

只要类中有一个抽象方法，此类就被标记为抽象类。

抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称、参数列表和返回值类型创建出非抽象方法，当然也可以是抽象方法。下图说明了抽象类的继承关系

7.8.2接口

接口所有方法都是抽象方法

修饰符inter face 接口名{}

实现implements

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

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

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。对于7.8.1节中遗留的问题，可以将draw0方法封装到一个接口中，使需要draw0方法的类实现这个接口，同时也继承图形类，这就是接口存在的必要性。在图7.11中，描述了各个子类继承图形类后使用接口的关系。

接口使用 interface 关键字进行定义，其语法如下

public interface Paintable{

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

}

ublic:接口可以像类一样被权限修饰符修饰，但public关键字仅限于接口在与其同名的文件中被定义。

interface:定义接口关键字。

Paintable:接口名称。

一个类继承一个父类的同时再实现一个接口，可以写成如下形式：

public class Parallelogram extends Quadrangle implements Paaintable{
  ...
}

 

例题7.13

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) {
		Square s = new Square();
		s.draw();
		s.doAnything();
		Parallelogram p=new Parallelogram();
		p.draw();
		p.doAnything(); 
		Circular c=new Circular();
		c.draw();
		
	}
}

 

 

实现多个接口的语法：

class 类名 implements 接口1，接口2，接口3...

一个接口可以继承另一个接口，语法如下：

interface intf1{}
interface intf2 extends intf1{}   //接口继承接口