Java面向对象_继承

继承： 是指类与类之间关系的一种描述，继承是类间的关系而不是对象之间的关系；

继承特点：1 提高了代码的复用性；

                    2 让类与类之间产生了关系，有了关系，才有了多态的特性；

继承的前提：必须是类与类之间有所属关系，满足is--a的关系

继承支持单继承，不支持多继承，但是可以实现多层继承；

 

继承中变量的特点：

         1>如果子类出现非私有的同名变量、方法时，子类要访问本类的变量用this，要访问父类中的变量用super

继承中的函数:

        1>当子类出现和父类一摸一样的函数时，当子类调用该函数时，会运用子类的函数内容

继承中构造函数：

        1>在对子类的对象进行初始化时，父类的构造函数也会执行，因为子类的构造函数的第一行默认有一条隐式的super()语句；

        2>super()  一定定义在子类的构造函数中

       3>当父类的没有空参构造函数时，子类必须通过super语句()形式来制定要访问类中的构造函数；

重写（覆盖）方法：1、子类覆盖父类必须保证子类权限大于父类的权限；

                                 2、静态只能覆盖静态；

                                 3、子类和父类的方法要一模一样才可以重写；

final：一个修饰符，可以修饰类、函数、变量；

          被final修饰的类，不可以被继承

         被final修饰的方法不可以被重写

         被final修饰的变量是一个常量，值赋值一次(常量的所用字母都大写 例 ：final double PI = 3.14;)

抽象类的特点：  抽象的方法一定定义在抽象类中；

                           抽象类和抽象方法都必须用abstract修饰；

                           抽象方法不可以被new创建新对象；

                          抽象方法要被使用必须由子类重写所有的抽象方法，如果只重写一部分，那么该子类地抽象类；

 

什么时候使用抽象方法？

当多个类中出现相同功能但是功能的主体不同，这时可以向上抽取，指抽取定义而不抽取主体；

 

介绍一种模板方法：

       定义功能时一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时将不确定的部分暴露出去，有该类的子类完成；

举例代码：

 

<span style="font-size:18px;"><strong>public abstract class Demo {
	
	public void getTime(){
	long start = System.currentTimeMillis();
	run();
	
	long end = System.currentTimeMillis();
	System.out.println("毫秒" + (end - start));
	}
	public abstract void run();
}

public class Demo1 extends Demo{
	
  public static void main(String[] args) {
	new Demo1().getTime();  
}
 
  public void run(){
	  
	  for(int i = 0; i < 1000; i++){
		  System.out.println(i);
	  }
  }

}</strong></span>

 上面的理论在下面的代码体现：

<span style="font-size:18px;"><strong>public class Person {
	
	String name;
	 int age = 20;
	public Person(int age){
		this.age = age;
		System.out.println("父类带参数的构造函数");
	}
	
	public Person(){
		
		System.out.println("父类不带构造函数");
	}
	 void show(){
		
		System.out.println("调用父类方法");
	}

}

public class Student extends Person {

	public Student(){
		//隐藏的的super();	
		System.out.println("子类不带参数构造函数");
	}
	public Student(int age){
		super(age);//父类中已经定义过，子类不用再定义可以直接用
		System.out.println("子类带参数的构造函数");
	}
	
	void show(){
		super.show();//父类中定义过得方法，子类直接用
		System.out.println("调用子类方法：-->" + "子类的年龄" + this.age);
		System.out.println("调用子类的方法:-->" + "父类的年龄" + super.age);
	}
}

public class TextDemo{
	
	public static void main(String[] args) {
		
		Student s = new Student();
		s.show();
		System.out.println(s.age);
		
		Student s1 = new Student(3);
		s1.show();
		System.out.println(s1.age);
		
	}
}</strong></span>