Java中有三大特性,分别是封装继承多态,其理念十分抽象,并且是层层深入式的.
一.封装
概念:封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为(或功能)相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。在电子方面，封装是指把硅片上的电路管脚，用导线接引到外部接头处，以便与其它器件连接。(来自百度)
在将成员属性封装之后,我们应该提供相应的get/set方法进行访问此成员属性.
封装的好处是:属性进行了隐藏,不再是暴露在外的数据,使数据更加的安全可靠.
1 classA{2 private int a;//此变量进行了封装3 //提供给外部访问的接口,实现了只读和只写
4 public intgetA(){5 returna;6 }7 public void setA(inta){8 this.a=a;9 }10 }
提到封装就必须要提到private关键字,如上代码,private是一个权限修饰符,它可以将成员方法和成员属性私有化,使其只有类内部能够访问到.
权限修饰符有4种,分别是public->protected->default->private 其中private权限最严格
public:可以在全工程访问到 protected:只有这个类的子类可以访问 defaule:为默认,无须写出,类所在包下可以访问 private:仅仅只有本省类可以访问
提到了封装就不得不提到this关键字
概念:this关键字指这个当前对象的引用
this关键字有三种用法:
1.this.成员方法,这种方法用于给成员变量的赋值.
1 classA{2 private int a;//此变量进行了封装3 //提供给外部访问的接口,实现了只读和只写
4 public intgetA(){5 returna;6 }7 public void setA(inta){8 this.a=a;9 }10 }
因为就近原则,所以直接a=a;实际上并没有对成员属性进行赋值,所以需要使用this关键字对其进行访问.
2.调用构造方法,如:可以在空参构造方法中调用有参构造方法
1 classA{2 private int a;//此变量进行了封装3 //提供给外部访问的接口,实现了只读和只写
4 public intgetA(){5 returna;6 }7 public void setA(inta){8 this.a=a;9 }10 //空参构造
11 publicA(){12 this(1);13 }14 //全参构造
15 public A(inta){16 this.a=a;17 }18 }
这个例子使用this在空参构造中调用了全参构造
使用this调用构造方法时需要注意:
1.this()必须在构造方法中的第一行,且只能够使用一次
2.this()不能够互相调用,因为会陷入死循环,如下:
1 classA{2 private int a;//此变量进行了封装3 //提供给外部访问的接口,实现了只读和只写
4 public intgetA(){5 returna;6 }7 public void setA(inta){8 this.a=a;9 }10 //空参构造
11 publicA(){12 this(1);13 //this();错误
14 }15 //全参构造
16 public A(inta){17 //this();错误
18 this.a=a;19 }20 }
3.this可以当作返回值使用,this是当前对象的引用,所以返回的同样是一个A类型,可以使用一个新的A类型对象b进行接受,b会继承所有a的属性值,使用方法如下:
classA{private int a;//此变量进行了封装//提供给外部访问的接口,实现了只读和只写
public intgetA(){returna;
}public void setA(inta){this.a=a;
}//使用this当作返回值
A b(){return this;
}//空参构造
publicA(){this(1);
}//全参构造
public A(inta){this.a=a;
}
}二.继承
概念:继承即从已有的类中派生一个新的类,已有的类成为父类(基类,超类),而派生的类成为子类(派生类).若类B继承了类A,则我们把类A称为类B的子类,反之同理,子类可以拥有自己本身的特有方法以及特有属性,而父类则必须是子类的共性抽取.如动物都有颜色,年龄,其颜色和年龄就是其共性
1 classA{2 inta;3 voida(){}4 }5 class B extendsA{6 //子类特有方法
7 voidb(){8 }9 }
1. 继承需要注意的点
(1)继承是类在继承,而不是对象在继承
(2)子类无条件继承父类的所有成员属性及成员方法
(3)若方法出现重写,属性出现重复,则优先使用子类的方法和属性(就近原则).
(4)继承不继承父类的构造方法
2.java中继承的特点
(1).java不支持多继承,但是可以通过接口实现多继承 多继承,即子类继承自多个父类
(2).java支持多重继承 多重继承,即子类继承父类,父类继承他的父类,即子类相当于其孙子辈
classA{inta;publicA(){//super();这里有一个默认的super()方法
}public A(inta){//super();这里有一个默认的super()方法
}voida(){}
}class B extendsA{//子类的特有属性
intb;//子类特有方法
voidb(){//调用父类的成员属性
System.out.println(super.a);//调用父类的成员方法
super.a();
}publicB(){
//调用父类的有参构造super(1);
}
}提到继承就必须提到super关键字,super关键字指父类的引用,super关键字最重要的是每个类的构造方法都有其默认的一个super()方法,我们知道所有的类都是继承自Object类,而super()这个方法其实是调用到Object处进行空间的申请.
super关键字的使用
1.访问父类成员方法和成员属性 super.成员方法() super.成员属性
2.访问父类的构造方法 super(参数)
1 abstract classAnimal{2 privateString color;3 private intnumOfLegs;4 abstract voideat();5 publicString getColor() {6 returncolor;7 }8 public voidsetColor(String color) {9 this.color =color;10 }11 public intgetNumOfLegs() {12 returnnumOfLegs;13 }14 public void setNumOfLegs(intnumOfLegs) {15 this.numOfLegs =numOfLegs;16 }17 public Animal(String color, intnumOfLegs) {18 super();19 this.color =color;20 this.numOfLegs =numOfLegs;21 }22 publicAnimal() {23 super();24 }25
26 }27 class Dog extendsAnimal{28 Dog(){29 super();30 }31 Dog(String color,intnumOfLegs){32 super(color,numOfLegs);33 }34 @Override35 voideat(){36 System.out.println(super.getNumOfLegs()+"条腿"+super.getColor()+"的狗在啃骨头");37 }38 voidlookHome(){39 System.out.println(super.getNumOfLegs()+"条腿"+super.getColor()+"的狗在看家");40 }41 }42 class Porrot extendsAnimal{43 Porrot(){44 super();45 }46 Porrot(String color,intnumOfLegs){47 super(color,numOfLegs);48 }49 @Override50 voideat(){51 System.out.println(super.getNumOfLegs()+"条腿的"+super.getColor()+"鹦鹉在吃小米");52 }53 voidsay(){54 System.out.println(super.getNumOfLegs()+"条腿的"+super.getColor()+"鹦鹉在说你好,丑八怪");55 }56 }提到继承当然也不能不提到抽象类,定义一个抽象类使用是这样的:public abstract class Animal(){}
当你想要创建一个动物类时,你知道动物都会吃,但是你不知道动物的子类吃是如何具体实现的,如:猫吃鱼,但是狗吃的是骨头同样的子类,但是其方法的实现却是不同的,这个时候就需要使用抽象类了.
抽象类的注意点:
1.抽象类必须在类中使用abstract关键字进行修饰,
2.抽象类中可以没有抽象方法,
3.抽象类不能够实例化,如果想要实例化的话则需要子类将其所有的抽象方法重写
1 interfaceA{2 int b=0;//默认有public static final;
3 void a(){}//默认有public abstract;
4 }5 interfaceB{6 }7 classFather{8 }9 class Son extends Father implementsA,B{10 //方法的实现
11 public voida(){12 }13 }提到抽象类就一定要提到接口
接口:接口其实相当于一个规范,当你定义一个接口时,实现接口的类必须实现接口中的所有的方法.举个现实中的例子,比如我们的手机充电借口,基本很少发生改变,因为他已经是规定死了的,使用接口等于制定一个规范,等于是所有的实现此接口的类都必须实现此规范,这样就可以用接口来实现不同类的比较等操作.
接口的注意点:
1.接口中的成员属性必须都是public static final的,不修饰会自动加上,接口中的成员方法必须都是public static修饰的,且不可以使用其他的权限修饰符
2.接口不可以被实例化,必须使用子类 explements 接口,然后实现接口中的方法.
3.一个类可以实现多个接口,可以在实现抽象类的同时实现多个接口或单个接口
三.多态
概念:同一个行为,对于传入不同的对象,实现不同的动作 多态需要记住的一个概念:父类引用指向子类对象
多态的好处:提高了代码的可复用性.
多态的坏处:无法使用子类所特有的方法.因为编译时看的是右边.
多态的实现必须有三要素 1.继承(实现) 2.重写 3.向上转型(缺一不可!!!)
1 public classTest{2 public static voidmain(String[] args){3 show(newDog());4 show(newCat());5 }6 public static voidshow(Animal a){7 a.eat();8 }9 }10 abstract classAnimal{11 abstract voideat(){12 }13 }14 class Dog extendsAnimal{15 public voideat(){16 System.out.println("在吃骨头");17 }18 }19 class Cat extendsAnimal{20 public voideat(){21 System.out.println("在吃鱼");22 }23 }多态基于继承的实现如上.
public classTest01{public static voidmain(String[] args){
show(newDog());
show(newCat());
}public static voidshow(Animal a){
a.eat();
}
}interfaceAnimal{abstract voideat();
}class Dog implementsAnimal{public voideat(){
System.out.println("在吃骨头");
}
}class Cat implementsAnimal{public voideat(){
System.out.println("在吃鱼");
}
}接口的实现如上
提到多态就需要提到一个例子:
public classTest01{public static voidmain(String[] args){
A a1=newA();
A a2=newB();
B b=newB();
C c=newC();
D d=newD();
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();
}*/}classA{voidshow(A a){
System.out.println("a and a");
}voidshow(D d){
System.out.println("a and d");
}
}class B extendsA{voidshow(A a){
System.out.println("b and a");
}voidshow(B b){
System.out.println("b and b");
}
}class C extendsB{
}class D extendsC{
}我们先看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,则可以使用强制类型转换
这种实现过程叫做向下转型
