继承

1. 继承 ：inherit

2. 关键字： extends

		格式： class 子类 extends 父类{ } 

3. 继承的好处：

提高代码的复用性。

  package com;
/**类
  1.学生 
  2.工人
  3.老师
*
*/
public class 继承 {
   public static void main(String[] args) {
   	Student  st =new Student();
   	st.name ="张三";
   }
}
class  Person{
   String name;
   int age;
   public void eat() {
   	System.out.println("吃饭。。。");
   }
}
//继承关系
class Student extends Person{
   public void study() {
   	System.out.println("goodgoodstudy");
   }
   
}
class Worker{
   String name;
   int age;
   public  void programmer() {
   	System.out.println("coding");
   }
   public void eat() {
   	System.out.println("吃饭");
   }
}
class Teacher{
   String name;
   int age;
   public void teaching() {
   	System.out.println("teaching");
   }
   public void eat() {
   	System.out.println("吃饭");
   }
}

4.父类子类

父类： superclass 超类
子类： subclass

5. 继承的成员关系：

子类可以继承父类所有的成员，但是除了private修饰的和构造方法。但是都可以进行调用。

package com;
/**
    1.继承的成员：
       不能被继承：
        ① private:不能被继承，但是可以通过方法使用。
        ② 构造方法:不能被继承，但是可以调用
 *
 */
public class 继承的成员关系 {
	public static void main(String[] args) {
		ZiM  m =new ZiM();
		m.setA(15);
		System.out.println(m.getA());
		
	}
}
class  M {
	private int a;
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;
	}
}
class ZiM extends M{
	public void fun() {
		System.out.println(getA());
	}
	/*public void setA(int a) {
		this.a = a;
	}*/
}

6. 方法的重写：override

在具有继承关系的子父类中，父类的方法对于子类来说，不合适，子类就需要重写父类的方法： 方法名称相同，参数列表相同，返回值也是相同。子类的权限修饰要大于等于父类。

package com;
public class 方法的重写 {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.eat();
		Dog d=new Dog();
		d.eat();
	}
}
class Animal{
  public void eat() {
		System.out.println("吃");
	}
}
class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

7.方法重写的检验：

     绿色小三角

8.关键字： super

当同一个类中，如果局部变量与全局变量重名时，根据就近原则：局部优先，如果想使用全局变量(属 性)，用this指代当前类的当前对象，格式： this.属性名称
当子父类中，如果子类重写了父类的方法，如果又需要调用父类的方法时，由于子父类方法重名，根据 就近原则，直接使用表示子类方法，如果需要调用父类的方法，用super指代当前类的当前对象的父类引 用：super.属性/方法(参数)

package com;
public class 手机来电显示 {
	public static void main(String[] args) {
		 PhoneI  pi =new PhoneI();
		 pi.display();
		 PhoneII pii =new  PhoneII();
		 pii.display();
	}
}
class  PhoneI{
	public void display() {
		System.out.println("电话号码");
	}
}
class PhoneII extends PhoneI{
	public void display() {
		super.display();//super
		System.out.println("大头贴");
		System.out.println("来电铃声");
	}
}

9.继承的成员重名问题

当子类与父类属性/方法重名时，super指代当前对象的父类的引用，this指代当前对象。 如果子类的属性与父类重名，当使用super时，从父类的位置开始找起，如果是使用this，从子类this的 位置开始找起。 但是 如果子类中没有与父类重名的，this从子类this的位置开始找起，向上找，直到找到为止。
总结：
this指代当前类的当前对象，从当前的类开始找，如果当前类没有，就找直接父类的，依次向上找。
super:指代当前类的当前对象的父类引用，从当前类的父类开始查找，依次向上。 如果子父类的属性或方法重名，通过super代表父类的。
注意：
1 this与super都不能直接放在静态方法中使用。
2 super只能在子类中使用。

package com;
public class 继承的成员重名问题 {
	public static void main(String[] args) {
		ZiAF  zf =new ZiAF();
		zf.fun();
	}
}
class AF {
	int a=30;
	public void s() {
		System.out.println("1111111");
	}
}
class ZiAF extends AF{
//	int a =20;
	public void fun() {
		System.out.println(super.a);
		System.out.println(this.a);
		this.s();
	}
	public void s() {
		System.out.println("2222");
	}
	/*public static void sf() {
//		this与super都不能直接放在静态方法中使用。
		System.out.println(this.a);
	}*/
}

10.继承的特点：

① 单继承：对于一个子类来说，有且只有一个直接父类
② 多层/重继承：爷爷辈

package com;

public class 继承的特点 {

}
class M1 {
	public void fun() {
		
	}
}
//单继承：直接父类只有一个
class K extends M1{
	
}
//多重继承：
class ZiK extends K{
	
}