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

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

Java中一个类的定义：

public class Baidu{
private final String COMPANY_NAME =“百度”;
//CEO
private 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;
	}
	
	/**
	 * 方法的重写
	 */
	@Override
	public 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);
	}

	@Override
	public 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{
	
	@Override
	public 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{

	@Override
	public 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();
	}

	/**
	 * 在该方法中操作传递过来的数据
	 */
	@Override
	public void onClick(String content) {
		System.out.println("传递过来的内容是"+content);
	}
}

运行结果：

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

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