学而时习之,温故而知新.
 
java继承的概念
 
Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，
 
并能扩展新的能力,
 
继承使用的是extends
 
类的继承格式
 
class 父类 { }
 
class 子类 extends 父类 { }
 
 
 
继承的优点:
 
1 提高了代码的复用性
 
2 提高了代码的维护性
 
3 建立了类与类之间的关系，继承是多态的前提。
 
继承的缺点:
 
1 在一定程度上，造成类与类之间的强关联，即所谓的高耦合。
 
2 父类功能的改变对子类也会造成影响。
 
 
 
说下什么地方使用extends 
 
案例1
 
父类用的一些方法 子类中也使用到了,这个时候就没有必要 在子类中重新写一次
 
这个时候就可以 子类 extends 父类  不如 Andorid 中常用的就是继承BaseActivity 了
 
 
 
注意事项:
 
Java 不支持多继承
 
下面是错误的
 
 
如果想实现a和b里面的方法可以用实现implements 
 
 
 
下面是可以实现的
 
 
 
 
 

目录
 
前言
 
继承
 
继承的优点
 
重写和隐藏父类方法
 
重写父类中的方法
 
隐藏父类中的方法
 
方法重写和隐藏后的修饰符
 
子类访问父类私有成员
 
使用super关键字
 
使用super调用父类中重写的方法、访问父类中被隐藏的字段
 
使用super调用父类的无参数构造方法/有参数构造方法
 
最后
 

前言
 
继承是面向对象语法的三大特征之一。继承可以降低代码编写的冗余度，提高编程的效率。通过继承，子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法，如何修改从父类继承过来的子类的方法呢。今天我们开始学习有关Java继承的知识。
 
继承
 
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
 
继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。
 
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
 
class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}
 
例如：
 
class teacher{             //声明一个teacher类为父类
	String name;      	   //定义父类的成员变量name、age   
	int age;
	void show(){           //定义父类成员方法，将成员变量输出
		System.out.println(name); 	  
		System.out.println(age); 
	}
}
class Student extends teacher {     //声明一个Student类为子类并继承父类
}
public class myfirst {
	public static void main(String[] args) {
	System.out.println("学生");
	Student student=new Student();     //声明一个Student类的实例对象student
	student.name="Tom";                //子类调用父类的成员变量name并赋值
	student.age=19;                    //子类调用父类的成员变量age并赋值
	student.show();                    //子类调用父类的成员方法show
	}
}
 
运行结果为：
 
学生
Tom
19
 
注意：
 
子类不能选择性继承父类；
Java不支持多重继承，但一个类可以实现多个接口，从而克服单继承的缺点；
构造方法不会被子类继承，但可以从子类中调用父类的构造方法。
继承的优点
 
继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用；
在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段或方法；
可以在子类中声明一个在父类中没有的新字段和方法；
可以在子类中编写一个父类当中具有相同名的新实例方法，这称为“方法重写”或“方法覆盖”；
可以在子类中编写一个调用父类构造方法的子类构造方法，既可以隐式地实现，也可以通过使用关键字super来实现。
重写和隐藏父类方法
 
子类继承了父类中的所有成员及方法，但在某种情况下，子类中该方法所表示的行为与其父类中该方法所表示的行为不完全相同，例如，在父类语言中定义了说话这个方法，而在子类中说话的方法是不同的：外国人说英文，中国人说中文，这时我们就需要重写或隐藏父类的该方法。
 
重写父类中的方法
 
当一个子类中一个实例方法具有与其父类中的一个实例方法相同的签名（指名称、参数个数和类型）和返回值时，称子类中的方法“重写”了父类的方法。例如：
 
class A{
	public void sayHello() {                      //输出英文欢迎
		System.out.println("Hello,Welcome to Java!!!");
	}
	public void sayBye() {
		System.out.println("GoodBye,everyone");
	}
}
class B extends A {           
    public void sayHello() {                      //输出中文欢迎  
    	System.out.println("大家好，欢迎学习Java！！！");
    }
}
public class myfirst {
	public static void main(String[] args) {
	B b=new B();                                //创建子类B的一个实例对象，使用默认构造方法
	b.sayHello();                               //调用子类中重写的方法
	b.sayBye();                                 //调用父类中的方法
	}
}
 
运行结果为：
 
大家好，欢迎学习Java！！！
GoodBye,everyone
 
注意：重写的方法具有与其所重写的方法相同的名称、参数数量、类型和返回值。
 
隐藏父类中的方法
 
如果一个子类定义了一个静态类方法，而这个类方法与其父类的一个类方法具有相同的签名（指名称、参数格式和类型）和返回值，则称在子类中的这个类方法“隐藏”了父类中的该类方法。
 
当调用被重写的方法时，调用的版本是子类的方法；
当调用被隐藏的方法时，调用的版本取决于是从父类中调用还是从子类中调用。
class A{
	public static void sayHello() {             //静态类方法
		System.out.println("大家好，这是A的静态类方法");
	}
	public void sayHello2() {                   //实例方法
		System.out.println("大家好，这是A中的实例方法");
	}
}
class B extends A {    
    public static void sayHello() {             //静态类方法
    	System.out.println("大家好，这是B的静态类方法");
    }
    public void sayHello2() {                   //实例方法
    	System.out.println("大家好，这是B的实例方法");
    }
}
public class myfirst {
	public static void main(String[] args) {
	    B b=new B();                           //创建B类的实例对象b
	    A a=b;                                 //隐式对象类型转换
	    A.sayHello();                          //调用A类的静态类方法
	    a.sayHello();                          //调用a对象的静态类方法
	    B.sayHello();                          //调用B类的静态方法
	    a.sayHello2();                         //调用a对象的实例方法
	    b.sayHello2();                         //调用b对象的的实例方法
	    A a2=new A();                          //创建A类的实例对象a2
	    a2.sayHello2();                        //调用a2对象的实现方法
	}
}
 
运行结果为：
 
大家好，这是A的静态类方法
大家好，这是A的静态类方法
大家好，这是B的静态类方法
大家好，这是B的实例方法
大家好，这是B的实例方法
大家好，这是A中的实例方法
 
可以看出，得到调用的隐藏方法是父类中的方法，而得到调用的重写方法是子类中的方法。
 
方法重写和隐藏后的修饰符
 
在子类中被重写的方法，其访问权限允许大于但不允许小于被其重写的方法，例如：父类中一个受保护的实例方法(protected)在子类中可以是公共的(public)的，但不可以是私有的(private)。如果一个方法在父类中是static方法，那么在子类也必须是static方法；如果一个方法在父类中是实例方法，那么在子类中也必须是实例方法。
 
子类访问父类私有成员
 
子类继承其父类的所有public和protected成员，但不能继承其父类的private成员。那么如何在子类中访问到父类中的字段呢，我们可以在父类中提供用来访问其私有字段的public或protected方法，子类使用这些方法来访问相应的字段。例如：
 
class A{                     //父类A
	private int value=10;    //声明一个私有变量value并赋值为10
	public int getvalue() {  //声明一个公有成员方法getvalue，返回value
		return value;
	}
}
class B extends A{           //A的子类B
}
public class myfirst {    
	public static void main(String[] args) {
	  B b=new B();           //创建子类B的一个实例对象
	  System.out.println("子类通过父类提供的公共接口访问A中的私有字段value:"+b.getvalue());
	}
}
 
运行结果为：
 
子类通过父类提供的公共接口访问A中的私有字段value:10
 
使用super关键字
 
使用super调用父类中重写的方法、访问父类中被隐藏的字段
 
子类重写了父类中的某一个方法，隐藏父类中的字段，假如想在子类中访问到父类中被重写的方法和隐藏父类的字段，可以在子类中通过使用关键字super来调用父类中被重写的方法和访问父类中被隐藏的字段。例如：
 
package first;
class A{
    public String name="张飞";         //添加成员变量
	public void say() {                //添加成员方法say
		System.out.println("我是父类A成员方法say");
	}
}
class B extends A{
    public String name="关羽";         //与父类中同名的字段，隐藏父类
	public void say(){                 //重写方法say
		super.say();                   //使用super关键字调用父类中的方法
		System.out.println("我是子类B成员方法say");
        System.out.println("父类的name名字："+super.name); //使用super关键字访问父类中的变量
	}
}
public class myfirst {
	public static void main(String[] args) {
	  B b=new B();                     //创建子类的一个实例对象
	  b.say();                         //调用子类中重写的方法
	  System.out.println("子类的name名字："+b.name);   //调用子类中的name
	}
}
 
运行结果为：
 
我是父类A成员方法say
我是子类B成员方法say
父类的name名字：张飞
子类的name名字：关羽
 
使用super调用父类的无参数构造方法/有参数构造方法
 
子类不继承其父类的构造方法。
 
当使用无参数的super()时，父类的无参数构造方法就会被调用；
当使用带有参数的super()方法时，父类的有参数构造方法就会被调用。
例如：
 
class SuperClass {              //创建父类SuperClass
	  private int n;            //声明一个私有变量n
	  SuperClass(){             //父类无参数构造方法
	    System.out.println("这是父类SuperClass无参数构造方法");
	  }
	  SuperClass(int n) {       //父类有参数构造方法
	    System.out.println("这是父类SuperClass有参数构造方法");
	    this.n = n;
	  }
	}
	class SubClass extends SuperClass{     // SubClass类继承SuperClass类
	  private int n;                       //声明一个私有变量n
	  SubClass(){                          // 自动调用父类的无参数构造器
	    System.out.println("这是子类无参数构造方法");
	  }  
	  
	  public SubClass(int n){              //子类有参数构造方法
	    super(300);                        //调用父类中带有参数的构造器
	    System.out.println("这是子类有参数构造方法"+n);
	    this.n = n;
	  }
	}
public class myfirst {
	public static void main(String[] args) {
		    SubClass sc1 = new SubClass();      //创建子类SubClass实例对象，调用其无参数构造方法
		    SubClass sc2 = new SubClass(100);   //创建子类SubClass实例对象，调用其有参数构造方法
	}
}
 
运行结果为：
 
这是父类SuperClass无参数构造方法
这是子类无参数构造方法
这是父类SuperClass有参数构造方法
这是子类有参数构造方法100
 
注意
 
如果要初始化父类中的字段，可以在子类的构造方法中通过关键字super调用父类的构造方法；
对父类的构造放的调用必须放在子类构造方法的第一行；
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器；
如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表；
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。
最后
 
好了，有关Java继承的知识讲到这里了，谢谢观看！！！
 
我们下篇文章再见！！！
 
成功不是将来才有的，而是从决定去做的那一刻起，持续累积而成。

java继承
 
1.什么是继承
 是一种java的机制，子类可以继承父类的所有属性和方法；当子类继承父类时。可以重复使用父类中的属性和方法，也可以添加新的属性和方法，
 示例
 
class B{
    ……
    }
}
class A extends B{
    ……
    }
}
 
extends关键字用于继承，中文意思延伸，可以理解为，class A extends B;表示A 是B的延伸 ，含义是添加新的功能，在java中被继承的类称为父类或超类，新类叫做子类
 上例代码中，A是父类，B是子类。
 
 
2.继承的优点
 可以重用代码，提高代码的重用性
 3.分类，
 单继承，多级继承，分层继承
 ①单一继承
 
 
class Animals{
    void output(){
        System.out.println("this is a animal");
    }
}
class Dog extends Animals {
    void output1(){
        System.out.println("this is a dog");
    }
}

public class ex {
    public static void main(String[] args) {
        Dog s1 = new Dog();
        s1.output();
        s1.output1();
    }
}
 
结果
 
this is a animal
this is a dog

Process finished with exit code 0

 
②多级继承
 
 
class Animals{
    void output(){
        System.out.println("this is a animal");
    }
}
class Dog extends Animals {
    void output1(){
        System.out.println("this is a dog");
    }
}
class Dogbaby extends Dog{
    void output2(){
        System.out.println("this is a Dogbaby");
    }
}

public class ex {
    public static void main(String[] args) {
        Dogbaby s1 = new Dogbaby();
        s1.output();
        s1.output1();
        s1.output2();
    }
}
 
结果
 
this is a animal
this is a dog
this is a Dogbaby

Process finished with exit code 0

 
分层继承
 
 
class Animals{
    void output(){
        System.out.println("this is a animal");
    }
}
class Dog extends Animals {
    void output1(){
        System.out.println("this is a dog");
    }
}
class Cat extends Animals{
    void output2(){
        System.out.println("this is a cat");
    }
}

public class ex {
    public static void main(String[] args) {
        Dog s1 = new Dog ();
        Cat s2 = new Cat();
        s1.output();
        s1.output1();
        s2.output();
        s2.output2();
    }
}
 
结果
 
this is a animal
this is a dog
this is a animal
this is a cat

Process finished with exit code 0

 
4，java中的类不支持多继承
 多继承：指一个类继承多个类的特性，可以理解为一个父类可以产生许多子类（分层继承），但是一个子类不能有许多个父类产生,(这里我的理解就好比高中数学里面的映射，可以一对一，一对多，但是不能多对一）
 
 java中不能对继承的原因
 为了编程语言简单化，少出错，假设有三个类分别A,B,C，B是A父类，C也是A的父类，如果C,B类中有同名的属性或者方法，当A类的对象调用这个同名方法时会存在歧义，又因为编译错误总比运行时错误要好的多如若继承两个类，编译器就会报错。
 错误代码：
 
class Animals{
    void output(){
        System.out.println("this is a animal");
    }
}
class Dog {
    void output1(){
        System.out.println("this is a dog");
    }
}
class Dogbaby extends Animals{
    void output2(){
        System.out.println("this is a Dogbaby1");
    }
}
class Dogbaby extends Dog{
    void output3(){
        System.out.println("this is a Dogbaby2");
    }
}
public class ex {
    public static void main(String[] args) {
        Dogbaby s1 = new Dogbaby ();
        s1.output();
        s1.output2();

    }
}
 
编译错误
 

继承，java 三大特性之一
 继承是面向对象最显著的一个特性。 继承是从已有的类中派生出新的类， 新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
 
 
 
简单来说，就是你父亲有的东西，你就不用再自己去创建了；减少不必要的创建，实现拿来主义的最好证明。
 
 
继承优点：
 
 
 
1、子类拥有父类非 private 的属性、方法。
 2、子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
 3、子类可以用自己的方式实现父类的方法。
 4、Java 的继承是可以单继承和多重继承，也可以不同类的继承组成兄弟关系，同一个源头不同的个人。
 
 
继承缺点：
 
 
 
耦合度高，因为继承了父类的东西，所以想分开就很难了，藕断必定丝连。增减的代码维护难度，尤其是多重继承和兄弟关系继承，毕竟家族历史长
 
 
继承的使用和认识：
 
1、继承是怎么实现的？
 使用extends 和 implements 关键字
 extends 继承的都是对象
 implements 继承实现并实现的是接口
 2、在继承的场景下，同一样东西，怎么区分是你老爹的还是你自己的？
 使用super 与 this 关键字
 super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
 this关键字：指向自己的引用。
 3、父类的某些方法不想被子类继承，怎么处理？
 对方法或属性进行 private 关键字或final关键字修饰
 private 关键字修饰，子类无法使用和继承
 final关键字修饰，无法继承，但是否可以被使用需要看权限属性