Java面向对象个人学习和理解

一切世界上存在的事物都可以看成是一个对象,面向对象的思想更符合我们人的思考方式.每个对象都有自己的属性和功能,这对应了类的成员变量和类中的方法。面向对象的知识有继承、多态、抽象类、接口，在学习的过程中，要了解一个类的初始化过程，以及变量在内存中的位置(在堆还是在栈里还是其它的)。

Java中一个类的定义：

public class Baidu{private final String COMPANY_NAME =“百度”;//CEOprivate String president = “李彦宏”;private void setPresident(String name){This.president = name;}  private String getPresident(){return this.president; }    public String searchSomething(String what){      return “百度一下：”+what;   }}

一个类的成员变量一般都会将它定义为私有的即private，然后给外部提供了相应的set和get方法，这其实是一种封装的思想，这样做的好处是增强系统的安全性。就像笔记本一样，封装起来只提供一个USB接口，这样防止里面的零件被随意破坏。

一个类的继承：一个类只能继承一个类,也就是说一个类只能有一个父类，子类可以拥有父类的protected和public修饰的成员属性和方法，但是父类中的private修饰的属性和方法对子类是不可见的。就像日常生活中，你可以使用老爸的一些东西，但是老爸有些东西你是不知道的，他不能让你知道的，因为每个人都有自己的私人空间。当子类中的方法和父类一样时，子类在调用该方法时，运行的是子类自己的方法体。这就是常说的方法的重写。

说到了重写，经常一起说的是方法的重载。方法的重载是指，在一个类中，一个方法有多种形式。这些形式之间的参数类型，参数个数，参数顺序至少有一个不同，在这些基础上还可以是返回值类型不同，这种现象就称为方法的重载。

public class Test {public static void main(String[] args) {Son son = new Son();son.intrduction();//这三个方法根据需要随意调用哪个方法son.playSport();son.playSport("篮球");son.playSport("篮球",2);}}class Father{private String name = "Father";    public String getName() {return name;}public void setName(String name) {this.name = name;}public void intrduction(){System.out.println("嗨,我的名字是"+name);}}class Son extends Father{private String name ="Son";public String getName() {return name;}public void setName(String name) {this.name = name;}/** * 方法的重写 */@Overridepublic void intrduction() {System.out.println("哈罗,我的名字是"+name);}/** * 方法的重载,必须在参数不一样的情况下才可以让返回值不一样 */public void playSport() {System.out.println("我做运动");}public void playSport(String type) {System.out.println("我做"+type+"运动");}public void playSport(String type,int hour){System.out.println("我做"+type+"运动"+hour+"小时");}}

一个类的初始化过程：首先会对父类进行初始化,在类的构造方法的第一行,如果没有明确指定调用哪个父类初始化的方法时,会隐藏有一个super()语句,调用的是父类的无参构造方法，如果父类没有无参构造方法，而子类的构造方法有没有调用父类的有参构造方法,那么就会报错,无法通过编译。如果该类没有明确的父类，那么该类的父类就是Object。静态变量先于类而存在，所以类在初始化时,第一个初始化的是类中的静态成员变量，然后是静态代码块,然后是代码块,然后才是构造方法。

所以一个子类的初始化过程是：

   1.父类静态成员初始化

   2.父类静态代码块初始化

   3.子类静态成员初始化

   4.子类静态代码块初始化

   5.父类代码块初始化

   6.父类构造方法初始化

   7.子类代码块初始化

   8.子类构造方法初始化

public class Test{public static void main(String[] args) {     Son son = new Son(2);     /**      *这里可以看到控制台打印的是son print.....2,验证了之前的子类重写父类方法,那么子类在调用方法时,会执行的      *是子类中的方法,因为在子类中已经找到了该方法,所以不会再往上找了。      */     son.print();          Father father = new Son(3);     father.print();     }}class Father{    //父类属性初始化    private int num = 6;    public Father() {System.out.println("Father构造方法........."+num);    }    /**     * 静态代码块,先于类存在     */    static{    System.out.println("father静态初始化.....");    }    /**     * 初始化代码块     */    {    System.out.println("father初始化块....."+num);    }    public void print(){    System.out.println("Father print........."+num);    }}class Son extends Father{//本类成员初始化private static int num;public Son(int num) {    /**     * 这里隐藏了一个语句super(),子类在初始化的时候,必须要调用父类的构造方法,因为父类先于子类存在,没有老爸哪有儿子。     * 如果父类没有无参构造方法,那么必须调用其中的一个构造方法     */     super();     System.out.println("Son构造方法");//     使用this的话不太妥当,因为静态成员先于类存在,而this代表的正是本类//     this.num = num;     Son.num = num;}/** * 静态代码块,先于类存在 */static{System.out.println("son静态初始化....."+num);num = 9;}/** * 初始化代码块 */{     System.out.println("son初始化块....."+num);}@Overridepublic void print(){     System.out.println("son print....."+num);}}

运行结果：

对于多态：多态就是一个对象多种形态,在代码中的体现就是父类的引用指向子类对象。Father father = new Son();在这个引用调用方法的时候，如果该方法是重写的方法，那么使用的是子类的方法体。在这里我说一下我的理解，为什么调用的是子类的方法体。在类的一个方法中,如果该方法的局部变量和类的成员变量重名了，那么我们会在类的成员变量前加上this.来加以区分。因为编译器会默认是局部变量，假如不加以区分的话。变量和方法的归类的时候,总是基于一种就近原则，就是从它所在的地方向上一直寻找，直到找打明确的宿主。比如说一个方法有一个变量是name，那么它会先在该方法中寻找是否定义有name这个变量，如果有那么停止寻找，将name归属于该方法中的name,如果该方法中没有找到name这个变量的定义,那么编译器会到类成员变量中寻找，如果找到，将该变量归为成员变量。如果该类中没有继续向上，到达父类。在父类的成员public和protected中寻找，如果没找到就报错。若要加以区分则this.表示的是本类成员，super.表示的是父类的成员

 

成员变量和局部变量的区别:

  1.成员变量定义作用域是整个类,用来给类对象初始化属性。成员变量随着类对象的消亡而消失。

    局部变量作用于是方法内部,当方法调用结束,变量就不存在了。

  2.当成员变量和局部变量同名时,需要用this关键字区分,this.变量名表示的是成员变量。在方法内部，如果不加this区分

    编译器会首先使用的是局部变量,如果方法内部没有该变量,再往上一级(类成员变量中)找。

  3.成员变量有默认初始化,而局部变量没有默认初始化

 

 

---抽象类

  抽象类是指不具体的类，是对一些事物共有的属性的一种封装。比如说Animal类，动物这个类是不具体的，因为动物有非常多的类别。

  抽象类的关键词：abstract

抽象类不能实例化，因为它是不具体的，只有抽象类的子类才可以被实例化。这就是父类的引用指向子类对象的一种使用。

abstract class Animal{public void  describe() {System.out.println("有生命的物体");}public abstract void voice() ;}class Dog extends Animal{@Overridepublic void voice() {System.out.println("汪汪");}}public class Test{public static void main(String[] args) {Dog dog = new Dog();dog.describe();dog.voice();}}

抽象类中可以包含抽象方法和非抽象方法，抽象方法的子类必须覆盖抽象类的所有抽象方法。抽象方法是指没有方法体的方法,抽象方法的定义public abstract void voice() ;

---接口

接口是一种特殊的抽象类，接口的关键字是interface，接口中只能包含抽象方法。接口的实现类使用关键字implements，接口通常用来监听某些事件是用来传递数据，从而达到更新界面的操作

接口的定义和它的实现类:

public interface OnClickListener{public abstract void click(String content); }//接口的实现类class TextClickListener implements OnClickListener{@Overridepublic void click(String content) {}}

接口的使用步骤：

 1.定义一个接口

 2.在要使用接口传递数据的地方，定义一个接口的引用对象，并且提供set接口方法

 3.在要触发传递数据的地方调用接口对应的方法，在这里应该做一个判空的操作

 4.在接口点实现这个接口,然后就可以在实现的方法中操作传递过来的数据了

/** * 定义一个接口 * */public interface OnClickListener{public abstract void onClick(String content); }/** *  *接口交互类，用来测试触发接口操作 */class Caculate{//定义一个接口的引用private OnClickListener onClickListener;//提供set接口方法public void setOnClickListener(OnClickListener onClickListener){this.onClickListener = onClickListener;}public void autoAdd() {   int i=0;   while(true){   i=i+1;   //i为9时触发接口操作，传递数据   if(i==9){   if(onClickListener != null){   onClickListener.onClick("自增多次后i的值为"+i);   }   break;   }   }}}public class Test implements OnClickListener{public static void main(String[] args) {Caculate caculate = new Caculate();caculate.setOnClickListener(new Test());caculate.autoAdd();}/** * 在该方法中操作传递过来的数据 */@Overridepublic void onClick(String content) {System.out.println("传递过来的内容是"+content);}}

运行结果：

可以看到数据真的传递过来了。这就是接口的简单使用了。

一个类只能继承自一个父类，但是可以实现多个接口。简记就是Java的一个类是单继承，多实现。