Java小记（第三周）

面向对象编程（下）

继承、多态、抽象类与接口

一、继承

在Java语言中，一个类继承另一个类需要使用关键字extends使用方法如下：

class Child extends Parent{}

二、Object类

  在Java中，Object类是比较特殊的类，它是所有类的父类。下面详细讲述Object类中的几个重要方法。

1、Getclass()方法

  Getclass()方法会返回对象执行时的Class实例，然后使用此实例调用Getname()方法可以取得类的名称。语法如下：

getClass().getName();

2、toString()方法

  toString()方法的功能是将一个对象返回为字符串形式，它会返回一个String实例。例如以下代码：

public class Student {
     String name;
     int age;
    
  public Student(String naame,int age){
       this.name=name;
       this.age=age;
  }

  public String toString(){
       return"我叫"+name+"，今年"+age+"岁。";
  }

  public static void main(String[] args){
       Student s1 = new Student("张三",16);
       System.out.println(s1);
  }

}

  其结果如下：

我叫张三，今年16岁。

3、equals()方法

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

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 true;
        if(obj==null)                      //如果参数与本类类型不同
            return false;
        if(getClass()!=obj.getClass())
            return false;
        People other=(People)obj;          //将参数强转成本类对象
        if(id!=other.id)                   //如果两者的身份证号不相等
            return false;
        return true;
    }
    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.println(p1+"与"+o+"是否为同一人？");
        System.out.println(p1.equals(o));
    }
}

运行结果如下：

Tom与汤姆是否为同一个人？
equals()方法的结果：true
==运算符的结果为：false

Tom与张三是否为同一人？
false
Tom与java.lang.Object@1b6d3586是否为同一人？
false

三、对象类型的转换

1、向上转型

  向上转型可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果。

例如以下代码：

class People{}
class Teacher extends People{}
public class Demo3{
     public static void main(String[] args){
          Pepple tom =new Teacher();
     }
}

  上述实例通过向上转型，把Teach类的对象直接赋值给People类的对象tom。

2、向下转型

  向下转型可以理解为将父类类型的对象转换为子类类型的对象。但是如果通过向下转型把一个较为抽象的类的对象转换为一个较具体的类的对象常会出现错误。所以，向下转型是不安全的。

  因为向下转型是不安全的，所以要想实现向下转型，需要借助强制类型转换，语法如下：

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

四、final关键字

  final是Java语言中的一个关键字，凡是被final关键字修饰的内容都是不可改变的。

五、抽象类与接口

1、抽象类

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

public abstract class Parent{
     abstract void testAbstract();
}

2、接口

  接口是抽象类的延伸，接口中所有的方法都没有方法体。接口使用interface关键字进行定义，其语法如下：

public interface Paintable{
     void draw();
}

  在Java语言中，一个类可以通过使用implements关键字继承多个接口，其语法如下：

class 类名 implements 接口1,接口2,……，接口n

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

interface intf1{}
interface intf2 extends intf1{}

包和内部类

一、Java类包

  在Java中采用类包机制非常重要，类包不仅可以解决类名冲突问题，而且可以在开发大型应用程序时帮助开发人员管理，方便软件复用。

1、创建包

  在eclipse中创建包的详细步骤各大平台都有详细教程，在此不再叙述。

  定义包名的语法如下：

package 包名

2.导入包

①使用import关键字导入包，语法如下：

import com.mr.*;           //导入com.mr包中的所有类
import com.mr.Math         //导入com.mr包中的Math类

②使用import导入静态成员，语法如下：

import static 静态成员

二、内部类

1、成员内部类

  在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。其语法如下：

​
class OuterClass{
    class InnerClass{
    }
}

​

  在其他类中创建内部类对象的语法如下：

外部类 outer=new 外部类();
外部类.内部类 inner=outer.new 内部类();

2、匿名内部类

  匿名类是只在创建对象时才会编写类体的一种写法。其特点是“现用现写”。语法如下：

new 父类/父接口(){
    子类实现的内容
};