学习博客之Java继承多态接口

这一篇博客主要是对软工前一阶段学习的总结，主要是对Java的学习总结，包括三部分：Java的继承、多态和接口

Java的继承

继承是面向对象的三大特性之一，能够实现软件的复用。

Java子类继承父类的语法格式如下

class SubClass extends SuperClass
{
//类定义部分
}

Java继承的特点：

Java只有单继承，即每个子类都只有一个直接父类。

子类继承父类，可以获得父类全部成员变量和方法

子类不能获得父类的构造器

子类重写父类的方法

子类和父类的方法名，形参列一样

方法的重写遵循“两小一大”的原则，即子类返回值类型应比父类返回值类型更小或相等；子类方法声明抛出的异常应比父类方法声明抛出的异常更小或相等；子类方法的访问权限应比父类方法的访问权限更大或相等

当子类覆盖了父类方法后，子类的对象无法访问父类中被覆盖的方法，但可以在子类方法中调用父类中被覆盖的方法，使用super.方法名（被覆盖的如果是类方法， 则用父类类名）

调用父类构造器

子类构造器调用父类构造器用super调用来完成，且必须出现在子类构造器执行体中的第一行

父类构造器总是在子类构造器之前执行

下面是一个Java继承的简单例子，该例子中包含，类的继承、子类重写父类方法、super的使用

package example;

class Person{
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name) {
this.name=name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age=age;
}
public int getAge() {
return age;
}

public void sayHello() {
System.out.println("Hello,I am "+name);
}
}

class Student extends Person{
private int number;
private String school;
public void SetNumber(int number) {
this.number=number;
}
public int getNumber() {
return number;
}
public void setSchool(String school) {
this.school=school;
}
public String getSchool() {
return school;
}
public  Student(String name,int age,int number,String school) {
super(name,age);
this.number=number;
this.school=school;
}
public void sayHello() {
System.out.println("I am a student of "+school+"and my name is "+getName());
}

}
public class ExampleOfExtend {
public static void main(String[] args) {
Student stu=new Student("Xiao wang", 19, 123, "Fzu");
System.out.println(stu.getName());
System.out.println(stu.getAge());
System.out.println(stu.getNumber());
System.out.println(stu.getSchool());
stu.sayHello();
}
}

以上是我在学习Java继承中总结出来的一些知识点，还包括了自己写的一个例子。

Java的多态

Java允许把一个子类对象直接赋给父类引用变量，无需任何类型转换。如果子类对象赋给父类的引用变量，当运行调用该引用变量的方法时，其方法行为总是表现出子类方法的行为特征，而不是父类方法的特征，这就可能出现：相同类型的变量、调用同一个方法时呈现出不同的行为特征，这就是多态。

下面将结合一个例子来讲解多态

class BaseClass
{
public int book = 6;
public void base()
{
System.out.println("父类的普通方法");
}
public void test()
{
System.out.println("父类的被覆盖的方法");
}
}
class SubClass extends BaseClass
{
public String book = "Java";
public void sub()
{
System.out.println("子类的普通方法");
}
public void test()
{
System.out.println("子类的覆盖父类的方法");
}

}

public class ExampleOfPolymorphism {
public static void main(String[] args)
{
BaseClass pl= new SubClass();  //将子类对象赋给父类变量，可能发生多态
System.out.println(pl.book);  //访问的是父类对象的实例变量
pl.base();  //将执行从父类继承到的base()方法
pl.test();  //将执行从子类的test()方法
// pl.sub();这一行代码编译时将会出现错误，因为pl的编译类型是BaseClass，BaseClass类没有提供sub方法
}
}

上面程序定义了一个BaseClass类，有一个变量book，两个方法:base和test；一个子类SubClass，有一个同名变量book，两个方法:sub、改写父类方法的test。在主函数中声明了BaseClass类型的po，但实际赋给这个变量的是SubClass类型。通过pl.book调用的是父类的变量，表明对象的实例变量不具有多态性。其他执行时所调用的方法已经写在代码注释上，不再赘述。

还有一点要提的是引用类型的转换。子类的对象可以直接赋给父类的引用变量，无需经过任何转型（向上转型）。如果要将一个父类对象转换成子类类型，则这个对象必须实际上是子类实例才行。

以上就是我在学习Java多态时的总结和自己写的一个例子。

java接口

接口里不能包含普通方法，接口里的所有方法都是抽象方法，接口是从多个相似类中抽象出来的规范。Java8对接口进行了改进，允许在接口中定义默认方法，默认方法可以提供方法实现。

Java中接口的定义

[修饰符] interface 接口名 extends 父接口1,父接口2...{
零到多个常量定义...
零到多个抽象方法定义...
零到多个内部类、接口、枚定义...
零到多个默认方法或类方法定义...//Only in java8
}

对比类定义，接口定义少了初始化块和构造器，且接口成员变量只能是静态常量（成员变量总是是

public static final

来修饰，可以省略），接口方法只能是抽象方法、类方法或默认方法（方法总是用

public abstract

来修饰，可以省略）。接口里的变量都必须指定初始值，接口里普通方法不能有方法体实现，类方法和默认方法必须有方法体实现。一个Java文件最多只能有一个public修饰的接口，如果定义了一个public接口，需与主文件名一致。

下面是一个简单的接口定义和继承的例子

interface interfaceA{
int a=5;
void testA();
}
interface interfaceB extends interfaceA{ //interfaceB继承了interfaceA
int b=6;
void testB();
}

public class ExampleOfPolymorphism {
public static void main(String[] args)
{
System.out.println(interfaceB.a);
System.out.println(interfaceB.b);
}
}

以上是我学习Java接口中的一些总结和一个简单的例子。

总结

通过《软工》，自己在以前的基础上学习了Java，但是还是只停留在一个很浅的水平上，像Java的AWT编程和Swing编程还没学习，希望在接下去的半学期，自己能多多少少再学一些。