Java三大特性(封装,继承,多态)

Java中有三大特性,分别是封装继承多态,其理念十分抽象,并且是层层深入式的.

一.封装

概念:封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。在电子方面，封装是指把硅片上的电路管脚，用导线接引到外部接头处，以便与其它器件连接。(来自百度)

在将成员属性封装之后,我们应该提供相应的get/set方法进行访问此成员属性.

封装的好处是:属性进行了隐藏,不再是暴露在外的数据,使数据更加的安全可靠.

 1 class A{
 2     private int a;//此变量进行了封装
 3     //提供给外部访问的接口,实现了只读和只写
 4     public int getA(){
 5         return a;
 6     }
 7     public void setA(int a){
 8         this.a=a;
 9     }
10 }

提到封装就必须要提到private关键字,如上代码,private是一个权限修饰符,它可以将成员方法和成员属性私有化,使其只有类内部能够访问到.

权限修饰符有4种,分别是public->protected->default->private 其中private权限最严格

public:可以在全工程访问到      protected:只有这个类的子类可以访问     defaule:为默认,无须写出,类所在包下可以访问     private:仅仅只有本省类可以访问

 

提到了封装就不得不提到this关键字

概念:this关键字指这个当前对象的引用

this关键字有三种用法:

　　1.this.成员方法,这种方法用于给成员变量的赋值.

 1 class A{
 2     private int a;//此变量进行了封装
 3     //提供给外部访问的接口,实现了只读和只写
 4     public int getA(){
 5         return a;
 6     }
 7     public void setA(int a){
 8         this.a=a;
 9     }
10 }

　　因为就近原则,所以直接a=a;实际上并没有对成员属性进行赋值,所以需要使用this关键字对其进行访问.

　　2.调用构造方法,如:可以在空参构造方法中调用有参构造方法

 1 class A{
 2     private int a;//此变量进行了封装
 3     //提供给外部访问的接口,实现了只读和只写
 4     public int getA(){
 5         return a;
 6     }
 7     public void setA(int a){
 8         this.a=a;
 9     }
10     //空参构造
11     public A(){
12         this(1);
13     }
14     //全参构造
15     public A(int a){
16         this.a=a;
17     }
18 }

　　这个例子使用this在空参构造中调用了全参构造

　　使用this调用构造方法时需要注意:

　　　　1.this()必须在构造方法中的第一行,且只能够使用一次

　　　　2.this()不能够互相调用,因为会陷入死循环,如下:

 1 class A{
 2     private int a;//此变量进行了封装
 3     //提供给外部访问的接口,实现了只读和只写
 4     public int getA(){
 5         return a;
 6     }
 7     public void setA(int a){
 8        this.a=a;
 9     }
10     //空参构造
11     public A(){
12         this(1);
13         //this();错误
14     }
15     //全参构造
16     public A(int a){
17         //this();错误
18         this.a=a;
19     }
20 }

　　3.this可以当作返回值使用,this是当前对象的引用,所以返回的同样是一个A类型,可以使用一个新的A类型对象b进行接受,b会继承所有a的属性值,使用方法如下:

class A{
    private int a;//此变量进行了封装
    //提供给外部访问的接口,实现了只读和只写
    public int getA(){
        return a;
    }
    public void setA(int a){
        this.a=a;
    }
    //使用this当作返回值
    A b(){
        return this;
    }
    //空参构造
    public A(){
        this(1);
    }
    //全参构造
    public A(int a){
        this.a=a;
    }
}

 

二.继承

 概念:继承即从已有的类中派生一个新的类,已有的类成为父类(基类,超类),而派生的类成为子类(派生类).若类B继承了类A,则我们把类A称为类B的子类,反之同理,子类可以拥有自己本身的特有方法以及特有属性,而父类则必须是子类的共性抽取.如动物都有颜色,年龄,其颜色和年龄就是其共性

1 class A{
2     int a;
3     void a(){}
4 }
5 class B extends A{
6     //子类特有方法
7     void b(){
8     }
9 }

 

1. 继承需要注意的点

　　(1)继承是类在继承,而不是对象在继承

　　(2)子类无条件继承父类的所有成员属性及成员方法

　　(3)若方法出现重写,属性出现重复,则优先使用子类的方法和属性(就近原则).

　　(4)继承不继承父类的构造方法

2.java中继承的特点

　　(1).java不支持多继承,但是可以通过接口实现多继承        多继承,即子类继承自多个父类

　　(2).java支持多重继承        多重继承,即子类继承父类,父类继承他的父类,即子类相当于其孙子辈

class A{
    int a;
    public A(){
        //super();这里有一个默认的super()方法
    }
    public A(int a){
        //super();这里有一个默认的super()方法
    }
    void a(){}
}
class B extends A{
    //子类的特有属性
    int b;
    //子类特有方法
    void b(){
        //调用父类的成员属性
        System.out.println(super.a);
        //调用父类的成员方法
        super.a();
    }
    public B(){
　　　　//调用父类的有参构造
        super(1);
    }
}

 

提到继承就必须提到super关键字,super关键字指父类的引用,super关键字最重要的是每个类的构造方法都有其默认的一个super()方法,我们知道所有的类都是继承自Object类,而super()这个方法其实是调用到Object处进行空间的申请.

super关键字的使用

　　1.访问父类成员方法和成员属性     super.成员方法()       super.成员属性

　　2.访问父类的构造方法        super(参数)

 

 1 abstract class Animal{
 2     private String color;
 3     private int numOfLegs;
 4     abstract void eat();
 5     public String getColor() {
 6         return color;
 7     }
 8     public void setColor(String color) {
 9         this.color = color;
10     }
11     public int getNumOfLegs() {
12         return numOfLegs;
13     }
14     public void setNumOfLegs(int numOfLegs) {
15         this.numOfLegs = numOfLegs;
16     }
17     public Animal(String color, int numOfLegs) {
18         super();
19         this.color = color;
20         this.numOfLegs = numOfLegs;
21     }
22     public Animal() {
23         super();
24     }
25     
26 }
27 class Dog extends Animal{
28     Dog(){
29         super();
30     }
31     Dog(String color,int numOfLegs){
32         super(color,numOfLegs);
33     }
34     @Override
35     void eat(){
36         System.out.println(super.getNumOfLegs()+"条腿"+super.getColor()+"的狗在啃骨头");
37     }
38     void lookHome(){
39         System.out.println(super.getNumOfLegs()+"条腿"+super.getColor()+"的狗在看家");
40     }
41 }
42 class Porrot extends Animal{
43     Porrot(){
44         super();
45     }
46     Porrot(String color,int numOfLegs){
47         super(color,numOfLegs);
48     }
49     @Override
50     void eat(){
51         System.out.println(super.getNumOfLegs()+"条腿的"+super.getColor()+"鹦鹉在吃小米");
52     }
53     void say(){
54         System.out.println(super.getNumOfLegs()+"条腿的"+super.getColor()+"鹦鹉在说你好,丑八怪");
55     }
56 }

提到继承当然也不能不提到抽象类,定义一个抽象类使用是这样的:public abstract class Animal(){}

当你想要创建一个动物类时,你知道动物都会吃,但是你不知道动物的子类吃是如何具体实现的,如:猫吃鱼,但是狗吃的是骨头同样的子类,但是其方法的实现却是不同的,这个时候就需要使用抽象类了.

抽象类的注意点:

　　1.抽象类必须在类中使用abstract关键字进行修饰,

　　2.抽象类中可以没有抽象方法,

　　3.抽象类不能够实例化,如果想要实例化的话则需要子类将其所有的抽象方法重写

 

 1 interface A{
 2     int b=0;//默认有public static final;
 3     void a(){}//默认有public abstract;
 4 }
 5 interface B{
 6 }
 7 class Father{
 8 }
 9 class Son extends Father implements A,B{
10     //方法的实现
11     public void a(){
12     }
13 }

 

提到抽象类就一定要提到接口

接口:接口其实相当于一个规范,当你定义一个接口时,实现接口的类必须实现接口中的所有的方法.举个现实中的例子,比如我们的手机充电借口,基本很少发生改变,因为他已经是规定死了的,使用接口等于制定一个规范,等于是所有的实现此接口的类都必须实现此规范,这样就可以用接口来实现不同类的比较等操作.

接口的注意点:

　　1.接口中的成员属性必须都是public static final的,不修饰会自动加上,接口中的成员方法必须都是public static修饰的,且不可以使用其他的权限修饰符

　　2.接口不可以被实例化,必须使用子类 explements 接口,然后实现接口中的方法.

　　3.一个类可以实现多个接口,可以在实现抽象类的同时实现多个接口或单个接口

 

三.多态

概念:同一个行为,对于传入不同的对象,实现不同的动作              多态需要记住的一个概念:父类引用指向子类对象

多态的好处:提高了代码的可复用性.

多态的坏处:无法使用子类所特有的方法.因为编译时看的是右边.

多态的实现必须有三要素  1.继承(实现)  2.重写  3.向上转型(缺一不可!!!)

 1 public class Test{
 2     public static void main(String[] args){
 3         show(new Dog());
 4         show(new Cat());
 5     }
 6     public static void show(Animal a){
 7         a.eat();
 8     }
 9 }
10 abstract class Animal{
11     abstract void eat(){
12     }
13 }
14 class Dog extends Animal{
15     public void eat(){
16         System.out.println("在吃骨头");
17     }
18 }
19 class Cat extends Animal{
20     public void eat(){
21         System.out.println("在吃鱼");
22     }
23 }

多态基于继承的实现如上.

public class Test01{
    public static void main(String[] args){
        show(new Dog());
        show(new Cat());
    }
    public static void show(Animal a){
        a.eat();
    }
}
interface Animal{
    abstract void eat();
}
class Dog implements Animal{
    public void eat(){
        System.out.println("在吃骨头");
    }
}
class Cat implements Animal{
    public void eat(){
        System.out.println("在吃鱼");
    }
}

接口的实现如上

 

提到多态就需要提到一个例子:

public class Test01{
    public static void main(String[] args){
        A a1=new A();
        A a2=new B();
        B b=new B();
        C c=new C();
        D d=new D();
        
        a1.show(b);// a and a
        a1.show(c);//a and a
        a1.show(d);//a and d
        a2.show(b);//b and a
        a2.show(c);//b and a
        a2.show(d);//a and d
    }
    /*public static void show(Animal a){
        a.eat();
    }*/
}
class A{
    void show(A a){
        System.out.println("a and a");
    }
    void show(D d){
        System.out.println("a and d");
    }
}
class B extends A{
    void show(A a){
        System.out.println("b and a");
    }
    void show(B b){
        System.out.println("b and b");
    }
}
class C extends B{
}
class D extends C{
}

我们先看a2.show(c),首先a2是一个a类型的引用类型,在a2种寻找show(c)参数为c类型的方法,没有找到c类型的方法,于是到a2的超类寻找其方法,由于a类的超类是Object,也并没有show(c)这个方法,于是将c类型进行了提升,变成了b类型,b类型在a中也不存在,于是便转换成了a类型,a类型与A类中找到了方法,并由于A类型的show方法于B类型中进行了重写,于是便输出了b and a

其寻找的顺序是:this.show(O)  super.show(O)  this.show(super(O))  super.show(super(O))

 

当使用了上述方法进行了多态的实现之后,其子类就会自动将其的特有方法给丢弃掉了,然而我们现在想调用这个对象的特有方法怎么办?

答案是使用使用强制类型转换,而使用强制类型转换则会有可能出现类型转换异常,这个时候就需要使用instanceof运算符,使用方法:父类对象  instanceof  子类,若父类引用时子类类型时返回true,则可以使用强制类型转换

这种实现过程叫做向下转型