Java复习之知识点整理（三）

一.继承

1.抽象共性

2.多个类是子类，抽象类是父类（超类）

3.子类可以访问父类的非私有成员

4.通过extends继承

5.只能单重继承，一个子类只能有一个父类。但是一个父类可以有多个子类

6.提高了代码的重用性，为多态提供了前提

二、super

1.类内置的成员变量，指向父类对象自身的引用，并且只能在类的内部使用

2.主要应用于子类和父类的成员重名，并且想在子类中访问父类的同名成员的时候

三、super()

1.在子类中调用父类的构造函数，可以带参数。如果使用，必须是子类构造函数的第一条语句

四、方法重写（覆盖overwrite）

1.子类方法签名和父类相同（名称，参数列表）

2.父类的private方法无法覆盖

3.在子类中如果想使用父类的方法，使用super打点调用

4.子类重写的方法的权限要大于等于父类方法的权限

5.静态只能覆盖静态，非静态只能覆盖非静态

五、final关键字

1.可以修饰类，方法和成员

2.被修饰的类不能被继承，是终态类

3.被修饰的方法不能被重写

4.修饰字段不能修改赋值

六、类的成员

1.成员变量

2.成员函数

3.构造代码块：先于构造函数执行，可以将其看成构造函数的第一条语句，多个构造代码块按照从上到下顺序执行

4.构造函数

5.静态代码块

6.内部类

七、内部类

1.内部类只能访问外部类的final变量

2.内部类可以是静态的，静态内部类调用的话，使用外部类打点调用，但是此时new的实例为内部类的实例，不会走外部类的构造函数，与继承要区分开

3.如果想在内部类中访问外部类的同名变量，使用 外部类.this.同名变量

八.抽象类 abstract

1.不能实例化的类，只能被继承，但是继承者要实现所有的抽象方法

2.抽象类中可以有抽象方法和非抽象方法。但是抽象方法只能定义在抽象类中。抽象方法是没有方法体的方法，方法体要在子类中去实现。

九.final的作用

1.final表示最终的意思，可以修饰成员变量，成员方法和类

2.修饰成员变量，表示此变量赋值之后就不能再被修改，表示常量

3.修饰成员方法，表示此方法不能被子类重写

4.修饰类，表示此类不能被继承，终态类

十、练习1

继承实现以下功能

a.定义类

Animal <|- Cat--- <|- JiaFeiCat

| |

| |

| |--- <|- BosiCat

|-- <| - Dog--- <|- Jing8

|---- <|- ZangAo

b.JiaFeiCat是终态类，不能继承。

c.Cat中定义catchMouse方法,切该方法不能被覆盖。

d.ZangAo定义常量，Blood = "English" ;

e.Animal ,Dog,Cat都是抽象类.

代码展示：

public abstract class Animal {

	public String name;
	public String color;

	public abstract void run();
}

abstract class Dog extends Animal {
	public abstract void watchHome();
}

abstract class Cat extends Animal {
	public final void catchMouse() {
		System.out.println("捉老鼠~~~");
	}
}

final class JiaFeiCat extends Cat {
	public void run() {
		System.out.println("加菲猫在慢慢的奔跑~~~");
	}
}

class ZangAo extends Dog {
	public final String blood = "English";

	public void watchHome() {
		System.out.println("藏獒在看家~~~");
	}

	public void run() {
		System.out.println("藏獒在飞快的奔跑~~~");
	}
}

十一、练习2

实现内部类

a.外部类ChinaMap{ratio}

b.定义内部类,NashQunDaoMap{ratio}

代码展示

public class Ts02 {

	public static void main(String[] args) {
		ChinaMap china = new ChinaMap();
		System.out.println(china.ratio);
		ChinaMap.NashMap nash = new ChinaMap().new NashMap();
		System.out.println(nash.ratio);
		nash.showChinaRatio();
	}
}

class ChinaMap {

	public String ratio = "中国地图比例尺为1:10000";

	class NashMap {
		public String ratio = "南沙群岛比例尺为1:100";

		public void showChinaRatio() {
			System.out.println(ChinaMap.this.ratio);
		}
	}
}

十二、具体类中为什么不能有抽象方法

以为抽象方法没有代码主体，具体类是可以实例化的，如果实例化了一个实例，那么该实例调用抽象方法的时候，因为没有方法体，就不行了。

十三、内部类如何访问外部类中的方法以及外部类父类中的方法?

public class Ts03 {

	public static void main(String[] args) {
		new Benz().new Engine().fire();
	}
}

class Car {
	public String name = "Car";

	public void run() {
		System.out.println("Car run...");
	}
}

class Benz extends Car {
	public String name = "BenzCar";

	// public abstract void run();
	public void run() {
		System.out.println("BenzCar run...");
	}

	class Engine {
		public String name = "Engine";

		public void fire() {
			// 内部类中访问外部类的成员方法
			Benz.this.run();
			// 内部类中访问外部类的成员变量
			System.out.println(Benz.this.name + "点火");
			// 内部类中访问外部类父类的成员方法
			Benz.super.run();
			// 内部类中访问外部类父类的成员变量
			System.out.println(Benz.super.name + "点火");
		}
	}
}

十四、子类能否把父类中的具体方法覆盖成抽象方法？

可以，但是子类必须是抽象类

全文完！