继承剖析
1 若是要直接调用父类的构造方法，不调用子类的方法则需要使用的是super()关键字
Publicclass Child extends Parent
{
Public Child()
{
Super(1);//此方法是显示的调用父类的方法，不会再采用默认的方法机制
System.out.println(“child!”);
}
Public static void main(String[] args)
{
Child child = new Child();
}
}
ClassParent
{
Public Parent(int i)
{
System.out.println(“Parent!”);
}
}
2 当生成子类的时候，Java默认先调用父类的不带参数的构造方法，然后再执行子类的构造方法，生成子类对象
3super关键字:super表示对父类对象的引用
4 如果子类使用的是super()显式调用父类的某个构造方法，那么在执行的时候就会寻找与super()所对应的构造方法而不会去寻找父类的不带参数的构造方法，与this一样，sueper
也必须作为构造方法的第一条执行语句，前面不能有其他可执行语句
例子程序；
Publicclass InhertanceTest
{
Public static void main(String[] args)
{
Apple apple = new Apple();
System.out.println(apple.name);
}
}
ClassFruit
{
String name=”fruit”;
}
ClassApple extends Fruit
{
String name=”apple”;
}
5 关于继承的三点：
(a) 父类有的，子类也有
(b) 父类没有的，子类也可以增加
(c) 父类有的，子类可以改变他
6 关于继承的注意事项
(a) 构造方法不能被继承
(b) 方法和属性可以被继承
(c) 子类的构造方法隐式调用父类的不带参数的构造方法
(d) 当父类没有不带参数的构造方法的时候，子类需要使用super()来显式的调用父类的构造方法 ,super指的是对父类的引用
(e) Super关键字必须是构造方法的第一行语句
继承举例:
public class InheritanceTest
{
Public static void main(String[] args)
{
Dog dog = new Dog();
Dog.run();
}
}
ClassAnimal
{
Public void run()
{
System.out.println(“animal is running!”);
}
}
ClassDog extends Animal
{
Public void run()
{
System.out.println(“dog is running!”);
}
/*我采用这种方式来写代码看看执行的结果是什么*/
Public void run(int I )
{
System.out.println(“dogis running!”)
}
}
6方法重写(Override):子类与父类的方法返回类型一样,方法名称一样,参数一样,这样我们说子类与父类构成了重写关系
7 方法的重写和方法重载的关系:重载发生在一个类内部的两个或者多个方法，重写发生在父类和子类之间。【重写一定伴随着继承发生的】
8super关键字:super表示对父类对象的引用
9如果子类使用super()显式调用父类的某个构造方法,那么在执行的时候就会寻找与super()所对应的构造方法而不会再去寻找父类的不带参数的构造方法 与this一样 super也要作为构造方法里的第一句所执行的代码
继承肯定生成了多个对象，比如儿子继承父亲，那一定生成2个对象
10
当两个方法构成重写关系的时候,可以在子类方法中通过super.run()形式调用父类的run()方法,其中super.run()不必放在第一句语句,因此此时父类的对象已经构造完毕,先调用父类的run()方法还是先调用子类的run()方法是根据程序的逻辑顺序所决定的
11 在定义一个类的时候，若是没有显式的调用某个父类，那么该类就会继承于java.lang.Object类（JDK提供的一个类,Object类是Java中所有类的直接或间接的父类）
Publicclass InheritenceTest3
{
Public static void main(String[] args)
{
Son son=new Son();
}
}
ClassGrandpa
{
Public Grandpa()
{
System.out.println(“gandpa”);
}
}
ClassFather extends Grandpa
{
Public Father()
{
System.out.println(“father”);
}
}
ClassSon extends Father
{
Father()
{
System.out.println(“Son”);
}
}///继承了3次 所以应该会生成3个对象 依次从上往下进行构造
12 多态(Polymorphsim)
Publicclass PolyTest
{
Public static void main(String[] args)
{
// Rose rose = new Rose();
Flower rose =new Rose();//多态的应用 父类型的引用可以指向子类的对象---》多态
Rose.sing();
}
}
ClassFlower
{
Public Flower()
{
}
Public void sing()
{
System.out.println(“floweris singing !”);
}
}
ClassRose extends Flower
{
Public Rose()
{
}
}
JavaSE 多态
1 多态；
2 public class PolyTest
3 {
Public static void main(String[] args)
{
Parent parent = newParent();
Parent.sing();
Child child = new Child();
Child.sing();
Parent p = new Parent(); //父类引用指向子类对象
p.sing();//指向谁就会调用谁的方法
}
4 }
5 Class Parent
6 {
7 Public void sing()
{
System.out.println(“parent is singing!”);
}
8 }
ClassChild extends Parent
{
Public void sing()
{
System.out.println(“child issinging!”);
}
}
2 对象转型
Publicclass PolyTest2
{
Public static void main(String[] args)
{
Animal a = new Dog();
Dog dog = Dog(a);//父类型的引用强制转化成了子类型的引用，因为a实际指向的是dog类型的对象所以可以将a强制转化成Dog类型
dog.sing();
}
}
ClassAnimal
{
Public void sing()
{
System.out.println(“animalis singing!”);
}
}
ClassDog extends Animal
{
Public void sing()
{
System.out.println(“Dog is singing!”);
}
}
ClassCat extends Animal
{
}
多态是一种运行期的行为，而不是编译期的行为
一共有2种类型的强制转化:
1 向上类型的强制转化 (upcast) 比如：Cat类型转化成Animal类型【将子类型转化成父类型】Cat转化成Animal类型，不需要显式的指定
//向上类型转化
Catcat = new Cat();
Animalanimal = (Animal)cat;
Animal.sing();//子类就是父类 cat is singing
2 向下类型转换(downcast) 比如:将Animal类型转化成Cat类型,即将父类型转化成子类型，对于向下类型转化，必须要显式指定（必须要使用强制类型转换）
//向下类型转换
Animal a = new Cat();
Cat cat = (Cat)a;
Cat.sing();
向下类型转换使用的条件：当父类和子类所拥有的方法个数不同的时候，要使用子类所特有的方法，则用强制类型转换。
Publicclass PolyTest3
{
Public static void main(String[] args)
{
Fruit f = new Fruit();
f.run();
Pear p = new Pear();
p.run();
System.out.println(“----------------------------------”);
//下面的用法是错误的不使用强制类型转化的时候会出现找不到该方法
Fruit f = new Pear();
f.grow();
///下面使用强制类型转化的方法来写程序就是对的
Fruitf = new Fruit();
Pear p = (Pear)f;
p.grow();
}
}
ClassFruit
{
Public void run()
{
System.out.println(“fruit isrunning!”);
}
}
ClassPear extends Fruit
{
Public void run()
{
System.out.println(“pear isrunning!”);
}
Public void grow()
{
System.out.println(“fruitis running!”);
}
}
体会多态是运行期的行为例子程序:
Public class PolyTest4
{
Public staticvoid main(String[] args)
{
Publicstatic void main(String[] args)
{
Aa = null;
///通过命令行来传参数,接收用户的参数
If(args[0].equals(“1”))
{
a = new B();
}
Else if(args[0].equals(“2”))
{
a = new C();
}else if(args[0].equals(“3”))
{
A = new D();
}
a.method();
}
}
}
Class A
{
Public voidmethod()
{
System.out.println(“A”);
}
}
class B extends A
{
Public voidmethod()
{
System.out.println(“B”);
}
}
Class C extends B
{
Public voidmethod()
{
System.out.println(“C”);
}
}
Class D extends A
{
Publicvoid mthod()
{
System.out.println(“D”);
}
}
Publicclass PolyTest5
{
/*原先的写法:*/
/*Publicvoid run(BMW bmw)
{
Bmw.run();
}
Public voidrun(QQ qq)
{
qq.run();
}
*/
///一个方法可以搞定所有的方法多态特性
//声明一个父类型的对象作为参数然后根据实际情况new对象
Public void run(Car car)
{
Car.run();
}
Public static void main(String[] args)
{
//先前写法的调用方式
/* PolyTest5test = new PolyTest5();
BMW bmw = new BMW();
Test.run(bmw);
QQ qq = new QQ();
Test.run(qq);
*/
//改进过后的调用方式
PolyTest5 test = new PolyTest5();
Carcar = new Car();
Test.run(car);
QQqq = new QQ();
Test.run(qq);
}
}
ClassCar
{
Public void run()
{
System.out.println(“car isrunning!”);
? ?}
}
}
ClassBMW
{
Public void run()
? ?{
? ?System.out.println(“BMWis running”);
?}
}
ClassQQ extends Car
{
Public void run()
{
Public void run()
{
System.out.println(“QQ isrunning”);
? ? ? ?}
? ?}
}