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编程还没学习，希望在接下去的半学期，自己能多多少少再学一些。