一：基本概念同C++一致
二：继承演示
1.将共同点提取出来，即形成了父类/基类/超类
–Parent class/Base class/Super class
2.而其他类则自动成为子类/派生类
–Child class/Derived cla
(一)父类Human
public classHuman {public voidsay() {
System.out.println("Hello World");
}public voideat() {
System.out.println("eat food");
}
}
(二)子类Women
public classWomen extends Human{public voidweave() {
System.out.println("women is weaving");
}
}
(三)子类Men
public classMen extends Human{public voidplough() {
System.out.println("Men is ploughing");
}
}
(四)继承演示
public classHumanTest {public static voidmain(String args[]) {
Women w=newWomen();
w.eat(); //方法继承于父类
w.say(); //方法继承于父类
w.weave();
Men m=newMen();
m.eat(); //方法继承于父类
m.say(); //方法继承于父类
m.plough();
}
}
eat food
Hello World
womenisweaving
eat food
Hello World
Menis ploughing
结果
二：信息隐藏
1.Man extends Human 表示Man继承于Human2.Human是父类，Man是子类3.子类继承父类所有的属性和方法(但不能直接访问private成员)4.根据信息隐藏原则：子类会继承父类所有的方法。可以直接使用。5.子类也会继承父类的父类的所有的属性和方法(但不能直接访问private成员)
三：单根继承(不同于C++)
1.单根继承原则：每个类都只能继承一个类
2.如果不写extends，Java类都默认继承java.lang.Object类
3.class Human extends java.lang.Object
4.Java所有类从java.lang.Object开始，构建出一个类型继承树
5.Object类里面默认就有clone, equals, finalize, getClass,
hashCode, toString等
C++允许继承多个父类
四：this和super
(一)this
1.this是对象方法中的隐藏参数们可以用于调用对象中的各个方法和变量。
2.this可以实现调用其他构造方法
classPerson {
String name, department;intage;public Person(String n){ name =n; }public Person(String n, int a){ name = n; age =a; }public Person(String n, String d, inta) {//doing the same as two arguments version of constructor//including assignment name=n,age=a
department=d;
}
}
Which expression can be added at the"doing the same as..." part of the constructor?
A.Person(n,a);
B.this(Person(n,a));
C.this(n,a);
D.this(name,age);
(二)super
默认调用：
每个子类的构造函数的第一句话，都默认调用父类的无参数构造函数super()，除非子类的构造函数第一句话是super，而且super语句必须放在第一条，不会出现连续两条super语句。
public classHuman {publicHuman() {
System.out.println("Human construct exec");
}public voidsay() {
System.out.println("Hello World");
}public voideat() {
System.out.println("eat food");
}
}
Human 父类
public classMen extends Human{publicMen() {
System.out.println("Men construct exec");
}public voidplough() {
System.out.println("Men is ploughing");
}
}
Men子类
public classHumanTest {public static voidmain(String args[]) {
Men m=newMen();
}
}
Human construct exec //先执行父类构造
Men construct exec //再执行子类构造
显式调用：
public classHuman {publicHuman() {
System.out.println("Human construct exec");
}public Human(inta) {
System.out.println("Human construct exec"+a);
}public voidsay() {
System.out.println("Hello World");
}public voideat() {
System.out.println("eat food");
}
}
Human父类
public classMen extends Human{publicMen() {
super(5);
System.out.println("Men construct exec");
}public voidplough() {
System.out.println("Men is ploughing");
}
}
Human子类
public classHumanTest {public static voidmain(String args[]) {
Men m=newMen();
}
}
Human construct exec5
Men construct exec
注意：父类只有含参构造，则子类必须显式调用super(参数)
注意：super只能调用可以由父类继承过来的方法和成员
classTestA{private inti;public TestA(inti) {this.i=i;
}publicString toString() {
System.out.println("i="+i);return " "+i;
}protected voidsay() {
System.out.println("super can call me");
}private voidsay2() {
System.out.println("super can`t call me");
}
}interfaceTestTable{public int s=11; //接口声明的成员默认都是常量,必须赋初值,不允许默认值,而且继承的类不允许修改该变量
}public classTest extends TestA implements TestTable{public Test(inti){
super(i);//super.i 不能继承，故super不能调用
//super.say2() 不能继承，故super不能调用
super.say();
}public static voidmain(String[] args) {//TODO Auto-generated method stub
}
}
五：重写和重载
(一)重载：overload
多个方法：相同名字，不同参数，便产生了重载。编译器会通过参数去判断具体执行哪一个方法。叫做重载解析
public classMen extends Human{publicMen() {
System.out.println("Men construct exec");
}public Men(inta) {
System.out.println("Men construct exec");
}public Men(int a,intb) {
System.out.println("Men construct exec");
}public voidplough() {
System.out.println("Men is ploughing");
}public void plough(inta) {
System.out.println("Men is ploughing");
}
}
(二)重写/覆盖
子类同样实现了父类的方法，相同名字和参数，将父类方法覆盖。调用子类对象时会先在该子类中去寻找，向上查找，在当前子类查找成功，就不会继续向上。
Men construct exec
Menis eating
(三)重写规则《重点》
(1)重写方法不能比被重写方法限制有更严格的访问级别。
现有public classParent{public void change (intx){
}
}public classChild extends Parent{
／／覆盖父类change方法
}
下列哪个声明是正确的覆盖了父类的change方法？
A.public void change (intx){}
B.protected void change (int x){} //比父类限制更加严格是不对的
重写方法限制更加宽松是可以的(前提是该方法可以继承)
(2)参数列表必须与被重写方法的相同。
(3)返回类型必须与被重写方法的返回类型相同
(4)重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。
注意：这种限制只是针对检查异常，至于运行时异常RuntimeException及其子类不再这个限制之中。
(5)不能重写被标识为final的方法。
(6)如果一个方法不能被继承，则不能重写它。如private方法
(7)子类不能用 静态方法重写父类的非静态方法
(8)子类不能用非静态方法重写父类的静态方法
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
