Java中的继承及this，super的使用

一、代码块：用{ }括起来的代码

1、局部代码块：方法中出现

     作用：用于限制变量的生命周期，及早释放，提高内存利用率

public class CodeBlock {
	public static void main(String[] args) {
		{
			int n=10;
			System.out.println(n);
		}
	}
}

结果：10

2、构造代码块：类中的成员位置，每次调用构造方法执行前，都会先执行构造代码块

     作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化

class Code{
	{
		int x = 100;
		System.out.println(x);
	}
	public Code() {
		System.out.println("hello world");
	}
	{
		int y = 1000;
		System.out.println(y);
	}
}
public class CodeBlock {
	public static void main(String[] args) {
		Code c = new Code();
	}
}

结果：100 1000 hello

3、静态代码块：在类中的成员位置，用static修饰

作用：一般是对类进行初始化

class Code{
	{
		int x = 100;
		System.out.println(x);
	}
	public Code() {
		System.out.println("hello world");
	}
	static{
		int y = 1000;
		System.out.println(y);
	}
}
public class CodeBlock {
	public static void main(String[] args) {
		Code c = new Code();
	}
}

结果：1000 100 hello

执行顺序： 静态代码块（只执行一次） -- 构造代码块（ 每次都执行） -- 构造方法

4、同步代码块

二、继承：

多个类存在相同的属性和行为时，将这些内容抽取到一个单独的类中，那么多个类无需再定义直接继承这个类就行了

父类中定义一些共有的特性（成员变量，无参构造，带参构造，成员方法）
子类中定义无参构造，带参构造，子类特有的功能

1、格式：class 子类名 extends 父类名{ }

class Person{
	String name;
	int age;
	public Person(){}
	public void eat() {
		System.out.println("我喜欢吃");
	}
	public void sleep() {
		System.out.println("我也爱睡觉");
	}
}
class Student extends Person {}
class Teacher extends Person {}

public class ExtendDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.eat();
		s.sleep();
		System.out.println("---- 这是分割线 ----");
		Teacher t = new Teacher();
		t.eat();
		t.sleep();
	}
}

2、继承的优点：

（1）提高了代码的复用性

（2）提高了代码的维护性

（3)让类与类之间产生关系，是多态的前提

3、弊端：

     类的耦合性增强了

开发的原则： 低耦合，高内聚
耦合：类与类的关系
内聚：自己完成某件事的能力

4、继承的特点：

    （1）只支持单继承，不支持多继承

    （2）支持多层继承

多层继承：

class GrandFather{
	public void show1() {
		System.out.println("继承爷爷的");
	}
}

class Father extends GrandFather{
	public void show2() {
		System.out.println("继承爸爸的");
	}
}

class Son extends Father {}

public class ExtendDemo2 {
	public static void main(String[] args) {
		Son s = new Son();
		s.show2();
		s.show1();
	}
}

5、注意事项：

（1）子类不能继承父类的私有成员方法或变量，但子类可以通过访问父类非私有方法来访问私有变量
（2)子类不能继承父类的构造方法，但可以通过super关键字去访问父类的构造方法（super（方法名））
  (3)不要为了部分功能而继承

6、成员关系：

（1)继承中构造方法之间的关系：
      子类都会访问父类的无参构造
      默认存在语句super（）；
      子类的构造方法执行前默认先执行父类的无参构造方法，
      如果父类没有无参构造方法的话就会报错
      报错解决方法：
      在父类中给出无参构造
      在子类的无参构造中通过super(...)来访问父类的带参构造

（2）继承中成员方法之间的关系：
         通过子类调用方法:
         现在子类中找，有就使用，没有的话再去父类中寻找

继承：

class People{
	private String name;
	private int age;
	public People() {}
	public People(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void show() {
		System.out.println(name+"---"+age);
	}
}
class Student2 extends People{
	public Student2(String name,int age) {
		super(name,age);
	}
}

public class ExtendDeno4 {
	public static void main(String[] args) {
		Student2 s = new Student2("小明",3);
		s.show();
	}
}

三、super 和 this 关键字：

1、区别：

     this 代表本类对应的引用
     super代表父类存储空间的标识（可以理解为父类引用）

2、用法：

(1)调用成员变量：

    this.成员变量
    super.成员变量

(2)调用构造方法:

   this（方法名）   (调用本类的构造方法)
   super（方法名）(调用父类的构造方法)

(3)调用成员方法:

    this.成员方法   (调用本类的成员方法)
    super.成员方法 (调用父类的成员方法)

调用成员方法:

class NewFather{
	public int n = 10;
}
class Son1 extends NewFather{
	public int n = 20;
	public void show() {
		int n = 30;
		System.out.println(n);
		System.out.println(this.n);
		System.out.println(super.n);
	}
}
public class ExtendDemo3 {
	public static void main(String[] args) {
		Son1 s = new Son1();
		s.show();
	}
}

四、方法重写和方法重载：

1、方法重写：

    子类中出现和父类方法中方法声明一样的方法

    应用：需要父类的功能，子类又有自己有的内容时，沿袭了父类的功能，又有了子类自己特有的功能

    可以在重写的方法中用super.方法名（参数）来调用父类的方法。

    方法重写的应用：

class Clothes{
	public void show(String name) {
		System.out.println("我有一个"+name);
	}
}
class MoreClothes extends Clothes{
	public void show(String name) {
		super.show(name);
		System.out.println("又买了一个小短裤");
	}
}
public class ExtendDeno4 {
	public static void main(String[] args) {
		MoreClothes m = new MoreClothes();
		m.show("连衣裙");
	}
}

方法重写的注意事项：
（1)方法中的私有方法不能被重写
  (2)子类重写父类方法时，访问权限不能更低
（如：父类方法为public，子类重写是权限也应该是public及其以上，最好一致）

2、方法重载：
     本类中出现的方法名一样，但是参数列表不同的方法