浅谈面向对象(java)

面向对象有对象，类，抽象类，接口等概念，还有封装，继承，多态等特征。

对象是一样具体的东西，一个人，一件事等都可以称为是对象，因此对象是一样具体的东西。类是抽象的东西，抽象类比类更抽象，而接口是比抽象类更抽象的东西。

类是什么？比如说人类，狗类，是指一类事物，对象又是这一类是物理的一个具体的东西。下面定义了一个类A

class A{

public void study(){

   }

}

抽象类又是什么？抽象类的作用又是什么呢？当我们编写一个类的时候，常常会为该类定义方法体，这些方法用来描述该类的行为方式，这些方法都有具体的方法体。

但是在某些特殊的情况下，某个父类只知道子类应该包含怎样的方法，但无法知道子类如何实现这些方法。例如，定义了一个Shape类，这个类提供了一个计算周长的方法

cal();但是不同Shape子类（不同形状）对周长计算方法不一样。也就是说Shape无法准确知道子类计算周长的方法。那么如何才能让Shape既包含cal()方法，又无须提供其具体实现呢？抽象类就是用来解决这类问题的。下面定义了一个抽象类B.其中抽象类里的方法必须加上abstract关键字。

public abstract class B {

     public abstract void study();
}

接口又是什么？接口的作用又是什么呢？

通常我们挂在嘴边的接口是AGP，PCI接口等，因此很多人认为接口是等同于主板机上的插槽，这是一个误区，当我们说接口是指那个插槽遵循了PCI,AGP规范，

而具体的插槽只是PCI接口的实例。接口定义了某一批类所需要遵循的规范，他不关心里面的具体实现过程，他只规定这批类里面必须提供某些方法，接口不提供任何实现，

接口让实现和规范分离开来，这是它的好处之一。通俗的说，接口像是一些规章制度，行为规范。

     1： 接口比抽象类还要抽象，接口里不能包含普通方法，接口里所有的方法都是抽象方法。定义接口使用的关键字是interface.接口前面的修饰符可以省略，如果省略了，就会默认采用包权限访问控制符，即只有在相同包结构下才可以访问该接口。接口可以有多个直接父接口，接口只能继承接口，不能继承类。例如：(public) interface C extends 父接口1  ，父接口2........接口直接继承多个接口。

     2：接口里不能包含构造器和初始化块定义。例如：在下面加上这个构造方法public C(){}会报接口里不能有构造器错误。

     3： 接口里的成员变量会自动的变成静态常量。例如：int  MAX_SIZE=100;等价于public static final int MAX_SIZE=100;也就是说在接口里定义的 成员变量会自动加上public static final.接口里的方法只能是抽象实例方法，类方法，或者默认方法（default）,接口里还可以有内部类（内部接口，枚举）。

    4： 定义接口里的普通方法不管是否使用public abstract关键字，系统都会自动加上public abstract。接口里的普通方法不能有实现，但类方法，默认方法都必须有方法体。接口里定义的内部类，内部接口，枚举默认采用public abstract 关键字修饰。(public abstract )void c();

    5：接口还可以定义默认方法，必须实现，默认方法必须使用dafault关键字来修饰，不能使用static（不能static default修饰），并且默认方法默认是public，由于默认方法不能使用static，因此默认方法不是接口的，需要使用接口的实现类来调用默认方法。（public）default void c(){}

   6：接口里还可以定义类方法,必须实现，所以类方法必须要用static修饰，默认是public，类方法可以直接用接口调用。（public）static void c(){}

(public) interface C {
 
 public （abstract）void study();
}

封装是面向对象的三大特征之一，他指的是将对象的信息隐藏在对象内部，不允许外部程序直接访问修改对象的内部信息，而是通过该类提供的方法来访问或修改对象的内部信息。封装的好处有很多，例如：隐藏类的实现细节，进行数据检查，保护对象，便于修改，程序可读性，可维护性，把方法暴露出来等等。简言之，就是把该隐藏的隐藏，改暴露的暴露。java提供了四个访问级别控制符public(公共访问权限)>protected(子类访问权限)>default(包访问权限)>private(当前类访问权限)。

继承通过关键字extends  来实现，实现继承的类被称为子类，被继承的类称为父类。

修饰符  class Sub_A  extends A{}Sub_A是子类，A是父类。extends的意思是扩展的意思，这很好的表达了子类和父类的关系，子类对父类的扩展。c++里面一个类允许有多个

直接父类，这就相当于一个人有还几个亲爸爸，这显然不符合常识并且难以理解。在java里面一个类最多只有一个直接父类，例如class A extends B,C{}在java里这是一种错误的写法。java里可以有多个间接父类这点也很符合常识，例如一个人有爸爸，还有爷爷，老爷爷,祖先。等等。java.lang.Object是所有类的父类 ,他是祖先。

重写（override）父类的方法：大多数时候，子类以父类为基础，添加额外的新的成员变量和方法。但有一种情况特殊，子类需要重写父类的方法。例如：

定义一个鸟类，有方法”飞“，但鸵鸟不会飞，此时就要重写父类的方法。

public class Bird{

public void  fly(){

    System.out.println("我会飞");

  }

}

public class Ostrich extends Bird{

public void fly(){

Sysytem.out.println("我不会飞")；

public static void main(String[]args){

Ostrich os=new Ostrich();

os.fly();//输出我不会飞

}

}

}

方法的重写要遵循方法名相同，形参列表相同，子类的返回值类型应该比父类的返回值类型要小或相等，子类声明抛出的异常应该要比父类声明抛出的异常要小或相等，子类的修饰符访问控制权限要比父类要大或相等。重写方法和被重写的方法要么都是类方法，要么都是实例方法。

当子类的方法覆盖了父类的方法，子类无法访问父类的被覆盖的方法，但是可以通过super关键字调用父类的方法。例如上例中要调用父类的方法，可以在子类加上super.fly();

如果父类的访问权限是private,那么子类无法重写父类方法。super不能出现在static修饰的方法中.

自动转型：子类对象自动转换为父类对象B b=new A();（B是父类，A是子类）优先调用子类方法,每次调用都会检测子类重写了没有，若没有重写，调用父类的方法。

多态：java引用变量有两个类型，编译时类型，运行时类型，编译时类型由声明该变量是使用的类型决定，运行时类型有实际赋给该变量的对象决定。当这两者不一致时，多态发生。 例如：

public class Bird{//父类

public void  fly(){

    System.out.println("我会飞");

  }

public void run(){

}

}

public class Ostrich extends Bird{//子类

public void fly(){

Sysytem.out.println("我不会飞")；

}

public void eat(){

}

public static void main(String[]args){

Ostrich os=new Ostrich();//编译时类型和运行时类型一样

os.fly();//输出我不会飞

Bird b=new Bird();//编译时类型和运行时类型一样

b.fly();输出我会飞

b.run();正确

b.eat()错误

Bird osb =new  Ostrich();//编译时类型和运行时类型不一样，多态发生。

osb.fly()//输出我不会飞

osb.eat()编译错误

osb.run();正确

}

}