2.3_Java面向对象编程_继承性

1.面向对象

面向对象的三大特性：

• 封装性
• 继承性
• 多态性

2.封装性

• 封装性：引入的目的就是为了复用代码
• extends关键字
  • 语法
    class 父类{}
class 子类 extends 父类{}
• 类中名字的格式
  • 类的名字：首字母大写；例如class Student
  • 类中方法的名字：首个单词小写，第二个单词首字母大写；例如 public void setSchool() {}
• System.out.println("school = "+school+"; age = "+age)语法理解
  • .理解的时候注意："school =" + school + "; age =" + age
• override：子类继承父类的方法，也可以覆写
  • 子类中的方法，和父类中的方法名字参数返回值一样，但是内容不一样；（即重写了父类了方法）

示例代码如下：

/*Ext3*/

class Person {
	private int age;

	public void setAge(int age) {
		if (age < 0 || age > 200)
			age = 0;
		else {
			this.age = age;
		}
	}

	public int getAge() {
		return age;
	}	

	public void printInfo() {
		System.out.println("age = "+age);
	}
}

class Student extends Person{
	private String school;/*子类的私有属性*/

	public void setSchool(String school) {
		this.school = school;
	}

	public String getSchool() {
		return school;
	}	

	/*构造方法*/
	public Student(String school) {
		this.school = school;
	}

	/* override */
	public void printInfo() {
		System.out.println("school = "+school+"; age = "+getAge());
	}
	
}

public class Ext3 {
	public static void main (String args[]) {
		Student stu = new Student("ustc");

		stu.setAge(10);

		System.out.println(stu.getAge());
		System.out.println(stu.getSchool());
		stu.printInfo();
	}
}

3.构造函数的继承和调用

• 实例化子类对象时，先调用父类的构造方法，再调用子类的构造方法
  • 如果父类中有很多构造函数，那么在实例化子类对象时，会默认调用父类的不带参数的构造函数

  • • 子类的构造函数{
      	Super();//表示调用父类不带参数的构造函数,写不写都一样
      	子类的构造函数其他内容；
      }
      

  • 子类的构造函数也可以调用父类中带有参数的构造函数

  • • 子类的构造函数{
      	Super(5);//表示调用父类带参数的构造函数，参数为5
      	子类的构造函数其他内容；
      }
      

示例代码：

/*Ext4*/

class Person {
	private int age;

	public void setAge(int age) {
		if (age < 0 || age > 200)
			age = 0;
		else {
			this.age = age;
		}
	}

	public int getAge() {
		return age;
	}	

	public void printInfo() {
		System.out.println("age = "+age);
	}
	/*构造方法1*/
	public Person () {System.out.println("Person ()");}
	/*构造方法2*/
	public Person (int age) {
		System.out.println("Person (int age)");
		this.age = age;
	}
	
}

class Student extends Person{
	private String school;

	public void setSchool(String school) {
		this.school = school;
	}

	public String getSchool() {
		return school;
	}	

	/*构造方法*/
	public Student(String school) {
		/* will call the super() */
		//super();
		super(5); //注意这里会调用父类的构造方法2
		System.out.println("Student(String school)");
		this.school = school;
	}

	/* override */
	public void printInfo() {
		System.out.println("school = "+school+"; age = "+getAge());
	}
	
}

public class Ext4 {
	public static void main (String args[]) {
		Student stu = new Student("ustc");

		//stu.setAge(10);

		System.out.println(stu.getAge());
		System.out.println(stu.getSchool());
		stu.printInfo();
	}
}

4.final关键字

• final类不能有子类
• final方法不能被覆写
• final变量变成常量，不能被修改

5.继承的限制

• 看不到父亲的私房钱：私有属性不能被子类访问
  • 子类不能直接调用父类的私有属性（private变量），但是可以通过父类的public方法来操作和获得父类的私有属性
• 看不到父亲的绝招：私有方法不能被子类访问
  • 子类不能调用父类的私有方法（private方法）
• 不能把祖传的招式私吞了：子类覆写的方法不能缩小权限
  • 子类可以继承父类中的public方法；
  • 或者override这个方法；
  • 但是不能把这个public方法变为子类的私有方法（private）
• 父类中含有私有方法func1，如果子类中public方法的名字和父类的这个私有方法func1同名，那么这里不能称子类对父类的override，因为子类不知道父类有这样的一个方法

示例代码如下：

/*Ext5*/

class Father {
	private int money;	/*私有属性*/

	public int getMoney() {return money; }
	public void setMoney(int money) {this.money = money; }

	public void printInfo() {System.out.println("This is Father");}

	private void printInfo2() {System.out.println("This is Father");}	/*私有方法*/
}

class Son extends Father{
	public void printInfo() {System.out.println("This is son");}		/*override */

	public void printInfo2() {System.out.println("This is Father");}	/*this is not override*/
	
}

public class Ext5 {
	public static void main (String args[]) {
		Son son = new Son();
		son.setMoney(100);
		//son.printInfo();
	}
}

6.抽象类

• 语法

  •  abstract class 类名 {
     			属性;
     			普通方法 { }
     
     			// 抽象方法
     			访问权限  abstract 返回值类型 方法名 (参数) ; /* 只需要声明，不需要实现 */
     }
    

• 作用：规定子类必须实现的方法，起“模板”作用
• 抽象类不能够实例化对象

  •   Class abstract father{}
      Father f1 = new father();//这句话会出错
    

• 所以说如果要使用抽象类，就必须让它的子类实现抽象类的所有抽象方法

示例代码：

/*Ext6*/

abstract class Father {
	private int money;	

	public int getMoney() {return money; }
	public void setMoney(int money) {this.money = money; }

	public abstract void study();/*abstract function*/
}

class Son extends Father{
	public void study() {System.out.println("I am study"); } /*implement abstract function*/
	
}

public class Ext6 {
	public static void main (String args[]) {
		//Father f = new Father();
		Son son = new Son();
		son.study();

	}
}

7.接口

• 作用：跟抽象类相似，起“模板”作用；子类可以继承多个接口，突破“单继承”的限制

• 语法和例子：

  •   // 接口由全局常量、公共的抽象方法组成
      interface 接口名称 {
      		全局常量;
      		抽象方法;
      }
         		
      interface A {
      		public static final i = 10;
      		public abstract int getNumber( );
      }
    
      interface B {
      		public static final String name = "www.100ask.net";
     			public abstract int getName( );
      }
    
      class C implements A,B {
      		//覆写A中方法
      		public int getNumber () { return i; }
    
      		//覆写B中方法
      		public int getName () { return name; }
      }
    

• 一个子类可以实现多个接口；但是子类必须实现接口里面的所有抽象方法

• 接口里面的属性全部都是常量，不是变量，所以不能被修改

  • 抽象类里面的属性可以为常量，也可以为变量；抽象类也可以含有并实现普通方法

• 子类可以在继承多个接口的同时，继承一个父类或者抽象类

示例代码：

/*Ext7*/

/*abstract class*/
abstract class Father {
	private int money;					/*private */

	public int getMoney() {return money; }
	public void setMoney(int money) {this.money = money; }

	public abstract void study();		/*abstract function*/
}

interface A {							/*interface */
	public static final int i = 10;		//只能是常量，无论怎么定义
	public abstract int getNum();		/*abstract function*/
}

interface B {
	public static String name = "InterfaceB";	//只能是常量，无论怎么定义
	public abstract String getName();	/*abstract function*/
}

/*extends father class, and implements interface */
//子类可以在继承多个接口的同时，继承一个父类或者抽象类		
class Son extends Father implements A,B{
	public int getNum() {return i;}								/*implements abstract function*/
	public String getName() {return name;}						/*implements abstract function*/
	public void study() {System.out.println("I am study"); }	/*implements abstract function*/
	
}

public class Ext7 {
	public static void main (String args[]) {
		Son son = new Son();
		System.out.println(son.getName());
		son.study();
	}
}