java继承与多态

继承的基本概念

生活中的继承指的是，晚辈得到了长辈的一些事物或者特性

         如：小孩继承了父母的一些特性，眼睛像妈妈，鼻子像爸爸等等

面向对象的语言也引入的类似的概念

Java语言通过extends关键字来表明两个类之间的继承关系

子类通过继承能够得到父类的属性和方法

子类也可以添加自己特有的属性和方法

         如：小女孩可以长得像妈妈，但是比妈妈更漂亮

 

再论public，protected和private

Public 修饰的属性和方法可以在类的外部被访问

Protected和private修饰的属性和方法不能在类的外部被访问

Protected和private的区别是

Protected修饰的属性和方法是可以被子类继承的

Private修饰的属性和方法不能被子类所继承

 

class Parent{

         protectedString car;

         protectedint money;

 

         publicParent(){

                  

                   car= "AUDI A4";

                   money= 1000000;

         }

         publicString getCar(){

                   returncar;

         }

         publicint getMoney(){

                   intret=0;

                   if(money>0){

                            ret=100;

                            money=ret;

                   }

                   returnret;

         }

}

 

class Child extends Parent

{

         publicvoid showCar(){

                   System.out.println(String.format("Ihave a %s",car));

         }

         publicvoid showMoney(){

                   System.out.println(String.format("Ihave %d",money));

         }

}

public class Test{

         publicstatic void main(String[] args){

                   Childc=new Child();

                  

                   System.out.println(c.getCar());

                   System.out.println(c.getMoney());

                   c.showCar();

                   c.showMoney();      

 

         }

        

}

 

 

 

继承与多态

Super和this

JAVA中的类自动隐含了两个常量关键字super和this

Super主要用于访问父类中定义的属性和方法

This主要用于访问本类中定义的属性和方法

问题：为什么需要他们

Super主要用于在子类中定义了与父类相同的属性的属性或方法，但是却依然需要访问父类中的属性或者方法的时候

This主要用于方法的参数与本类中定义的属性同名的时候

 

 

class Parent{

        

         protectedString car;

         protectedint money;

 

         publicParent(){

                   car="AUDIA4";

                   money= 1000000;

         }

 

         publicString getCar(){

                   returncar;

         }

 

         publicint getMoney(){

                   intret=0;

                   if(money>0)

                   {

                            ret=100;

                            money-=ret;

                   }

 

                   returnret;

         }

}

 

class Child extends Parent{

        

         protectedint money =0;

        

         publicvoid  earnMoney(int money)

         {

                   this.money+=money;

 

         }

 

         publicvoid fetchMoney(int money){

                   if(super.money>money)

                   {

                            super.money-=money;

                            this.money+=money;

                   }

         }

 

         publicint parentMoney(){

                   returnsuper.money;

         }

                  

         publicint selfMoney(){

                   returnmoney;

         }

}

 

public class Main{

         publicstatic void main(String[] args)

         {

                   Childc =new Child();

                  

                   c.earnMoney(1000);

                   c.fetchMoney(500);

                   System.out.println(c.selfMoney());

                   System.out.println(c.parentMoney());

                   System.out.println(c.getCar());

 

         }

 

}

 

 

JAVA中的变量遵守遵守作用域原则

当作用域重叠的时候，默认内层作用域的变量将首先被访问        

Super和this关键字可用于打破这个规则，明确指出访问的变量

 

 

JAVA引用数据类型

JAVA中的数据类型可以分为基本数据类型和引用数据类型两大类

Int、float、char和boolean等都是基本数据类型

类类型都是引用数据类型

引用数据类型类似C语言中的指针，多个引用数据类型可以引用同一个对象

基本数据类型的变量都有自己的一份值拷贝

从类的划分上可以知道，子类其实是一种特殊的父类

对于类的使用者而言，使用父类对象的地方完全可以使用子类对象代替

在JAVA中表现为，父类的引用变量可以直接指向子类对象，而不需要强制类型转换

相反，父类对象不能直接赋值给子类的引用对象，需要强制类型转换

当使用父类类型的变量指向子类对象的时候，该变量能访问属性和方法只能是父类中的声明为public的属性和方法

 

继承和多态

多态

多态发生的条件

子类和父类中有完全相同的方法，即子类重写了父类的方法

利用父类引用变量调用这个方法

根据引用的实际对象的类型来确定调用哪一个方法

 

代码如下

class MobilePhone{

         publicint number =138;

         publicvoid call(){

                   System.out.println("UseMobliePhone to call some one");

         }

         publicint myNumber(){

                   returnnumber;

         }

}

 

class Motorola extends MobilePhone{

         publicint number=131;

 

         publicvoid call(){

                   System.out.println("UseMotorola to calss someone");

         }

 

         publicvoid call(int number){

                   System.out.println("UseMotorola to call"+number);

         }

 

         publicint myNumber(){

                   returnnumber;

         }

}

 

public class Main{

         publicstatic void main(String[] args){

                   MobilePhonephone = new Motorola();

 

                   System.out.println(phone.number);

                   System.out.println(phone.myNumber());

                   phone.call();

         }

 

}

 

输出结果如下

138

131

Use Motorola to calss someone

 

JAVA中的多态只能发生于方法，子父类间完全相同的属性不会发生多态

子父类间完全相同的属性通过引用的类型而不是实际对象的类型确定访问哪一个

函数重载不是多态，通过引用的类型确定调用哪一个

 

 

 

特殊的类

我们都知道生活中，有些家族需要子女继承家业，不管子女是否愿意

在生活中的“丁克”一直不想要小孩，自然也不想有人继承自己的东西

那么如何在JAVA表示这些特殊的类？

Abstract表示必须被继承的类

Final不能够被继承的类

 

JAVA中的抽象类是用abstruct修饰的类，这些类必须有至少一个用abstract修饰的只声明未实现的方法

抽象类是一种必须被继承的类，否则无法生成对象的类

可以定义抽象类的引用，并且使其引用任意一个子类的对象

为什么要有抽象类？因为我们生活中就有这样的概念

如：汽车这个类其实就是一个抽象类，我所能看到摸到的车都是有品牌型号和生产厂家的，而汽车却是一个抽象的概念，原指需要人驾驶以汽油为动力的四轮交通工具

 

JAVA中终极类是用final修饰的类，这种类不能被继承

Final关键字也可以用于修饰方法，表示该方法不能被子类重写

Final关键字修饰类的属性的时候，表示该属性为常量，这时子类依然可以自定义一个完全相同的属性

Final修饰的类可以是其他类的子类

 

特殊类示例

 abstract class Shape{
private float x=0;
private float y=0;

public Shape(float x,float y){
this.x=x;
this.y=y;
}

public final float getX(){
return x;
}


public final float getY(){
return y;
}


public abstract float area();
}


final class Rectangle extends Shape{
private float width =0;
private float height = 0;


public Rectangle(float x,float y,float width,float height){
super(x,y);
this.width =width;
this.height=height;
}


public float area(){
return width*height;
}
}


final class Circle extends Shape{
protected float radius =0;
public Circle(float x,float y,float radius){
super(x,y);
this.radius =radius;
}


public float  area(){
return 3.14f*radius*radius;
}
}


public class Main{
public static void main(String[] args){
Shape r=new Rectangle(2,4,5,10);
Shape c=new Circle(9,10,5);


System.out.println(r.getX());
System.out.println(r.getY());
System.out.println(r.area());
System.out.println();
System.out.println(c.getX());
System.out.println(c.getY());
System.out.println(c.area());
}


}