黑马程序员 JAVA-面向对象（一）

                   -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

      在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！

JAVA语言-----面向对象

面向对象的概念：

      面向对象和面向过程都是一种思想，面向对象是相对面向过程而言的。面向过程是强调功能行为，而面向对象是将功能分装进对象，强调具备了功能的对象。面向对象基于面向过程的。

面向对象的特点： 

（1）是一种符合人们思考习惯的思想；

（2）可以将复杂的事情简单化；

（3）将程序员从执行者转化成了指挥者；

（4）完成需求时：先要去找具有所需功能的对象来用；如果该对象不存在，那么创建一个具有所需功能的对象；这样简单开发并提高复用。

面向对象的特征：封装（encapsulation）、继承（inheritance）、多态（polymorphism）。

类与对象的关系：

      Java中描述事物通过类的形式体现，类是具体事物的抽象，对象时该类事物实实在在存在的个体。

      生活中描述事物无非就是描述事物的属性和行为，而Java中用class来描述事物也是如此：

       （1）属性：对应类中的成员变量。

       （2）行为：对应类中的成员函数。

       定义类其实在定义类中的成员（成员变量和成员函数）。

注：成员变量和局部变量的区别？

       成员变量：成员变量定义在类中，在整个类中都可以被访问。成员变量随着对象的建立而建立，存在于对象所在的堆内存中。成员变量有默认初始化值。

       成员函数：局部变量只定义在局部范围内，如：函数内、语句内等；局部变量存在于占内存中；其作用的范围结束，变量空间会自动释放；局部变量没有默认初始化值。

 Java练习代码：

class   Car 
{
   String  color  = "red";//定义车子颜色
   int  num  =  4;//定义车轮数量
  void   show()//定义一个show方法
  {
       System.out.println("color="+color+".."+"num="+num);//打印颜色和数量
   }    
}

class CarDemo
{
    public static void main (String  args[])
    {
         Car  c  =  new Car( ) ;//实例化一个对象
         c.color  =  "black";//对对象的属性进行修改
         c.show()；//使用对象的功能
    }
}

知识点：匿名对象：是对象的简化形式。

               匿名对象的使用情况：当对对象方法仅进行一次调用时；匿名对象作为实际参数进行传递时。

面向对象（封装）

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：（1）将变化隔离；

           （2）便于使用；

           （3）提高复用性；

           （4） 提高安全性。

封装原则：将不需要对外提供的内容都隐藏起来；把属性都隐藏，提供公共方法对其访问。

构造函数：

特点：（1）函数名与类名相同；（2）不用定义返回值类型；（3）不可以写return语句。

作用：给对象进行初始化。

注：（1）默认构造函数的特点;(2)多个构造函数是以重载的形式存在的。

java练习代码：

person (String name,int age)为类Person构造函数。

class Person 
{
	private String name;
	private int age;

	Person (String name ,int age)
	{
	   this.name = name;//this代表对象p
	   this.age =age;
	   speak();
	}
	public void speak ()//定义一个speak方法
	{
	   System.out.println("name="+name+".."+"age="+age);
	}
}

关键字：private（私有）、this、static（静态）

private关键字：是一个权限修饰符，用于修饰成员（成员变量和成员函数）。其中被私有化的成员只在本类中有效。

常用之一：将成员变量私有化，对外提供对应的set ,get 方法对其进行访问。提高对数据访问的安全性。

Java练习代码：

class person
{
	private String name;//姓名
	private int age;//年龄
	private String sex;//性别

	person(String name,String sex,int age)//构造函数
	{
	   this.name = name;

	   this.sex = sex;

	   this.age = age;	
	}

	public void speak()//方法，打印信息
	{
	   System.out.println(this.name+" "+this.sex+" "+this.age);
	}
}

class PersonDemo
{
	public static void main(String[] args) 
	{
	      person p = new person();
          
		  p.name = "jolin";//设置姓名
 
   		  p.sex = "woman";//设置性别

		  p.age = "36";//设置年龄

		  speak();//调用speak方法

	}
}

this关键字特点：this代表其所在函数所属对象的引用。换言之，this代表本类对象的引用。

注：什么情况下使用this关键字？

            当在函数内需要用到该函数的对象时，就用this。

Java练习代码：

class Person 
{
	private String name;
	private int age;

	Person (String name ,int age)
	{
	   this.name = name;//this代表对象p
	   this.age =age;
	   speak();
	}
	public void speak ()
	{
	   System.out.println("name="+name+".."+"age="+age);
	}
}

class  PersonDemo
{
	public static void main(String[] args) 
	{
		Person p = new Person("lina",36);//实例化对象，并设置属性
		
	}
}

static关键字：是一个修饰符，用于修饰成员（成员变量和成员函数）。

被修饰后的成员具备以下特点：

 （1）随着类的加载而加载；

 （2）优先于对象存在；

 （3）被所有对象所共享；

 （4）可以直接被类名调用。

注：静态方法只能访问静态成员；

       静态方法中不可以写this，super关键字(因为静态变量优先于对象存在)；主函数是静态的。

 实例变量和类变量的区别：

   （1）存放位置：类变量随着类的加载而存在于方法区中; 实例变量随着对象的建立而存在于堆内存中。

   （2）生命周期： 类变量生命周期最长，随着类的消失而消失； 实例变量生命周期随着对象的消失而消失。

静态利弊：利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份，可以直接被类名调用。

           弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)

什么时候使用静态变量和方法：

1、当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

 2、当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。 

     

Java练习代码：

class Person
{
	String name;
	static String country = "CN";//country被静态修饰，被p和p1共享；
	public void show()
	{
	   System.out.println("name="+name+"..."+"country="+country);
	}
}

class  PersonDemo2
{
	public static void main(String[] args) 
	{
		Person p =new Person();//实例化一个p对象
		p.name = "lina";
		p.show();
		Person p1 =new Person();//实例化一个盘对象
		p1.name = "zhangguoli";
		p1.show();
	}
}

注：静态成员变量除了可以被对象调用外，还可以直接被类名调用。格式：类名.静态成员变量。

       用上一个例子做示例：System.out.println(person.country);

静态的应用：

  

        每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。

        虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。发现了问题：
        1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
        2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。

       这时就考虑，让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。

       将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。

Java代码如下：

<pre name="code" class="java">    /**
	这是一个对数组进行操作的工具类，该类中提供了获取最值、排序等功能。
	@author  宋泽文
	@version V1.0
	*/
public class ArraysTool
{
	private ArraysTool(){}
	/**
	获取整形数组中的最大值。
	@param arr 接受一个int类型的数组
	@return 返回该数组中的最大值。
	*/
    public static int getMax(int[] arr)
    {
		int max = 0;
		for(int x=1;x<arr.length;x++)
		{
			
			if(arr[x]>arr[max])
				max = x;
		}
		return arr[max];
    }
	/**
	获取整形数组中的最小值。
	@param arr 接受一个int类型的数组
	@return 返回该数组中的最小值。
	*/

	public static int getMin(int[] arr)
	{
		int min = 0;
		for(int x=1;x<arr.length;x++)
	    {
			

			if(arr[x]<arr[min])

				min = x;
		}
		return arr[min];
	}
	/**
	给int数组进行选择排序
	@param arr 接受一个int类型的数组
	*/

	public static void selectSort(int[] arr)
	{
	     for(int x=0;x<arr.length-1;x++)
		 {
		    for(int y=x+1;y<arr.length;y++)
		    {
			    if(arr[x]>arr[y])
				{
				  swap(arr,x,y);
				}
			}
			
		 }
		 printArray(arr);
	}
	/**
	给int数组进行冒泡排序
	@param arr 接受一个int类型的数组
	*/

	public static void bubleSort(int[] arr)
	{
	   for(int x=0; x<arr.length;x++)
		{
	      for(int y=0; y<arr.length-x-1;y++)
			{
			  if(arr[y]>arr[y+1])
		      {
                  swap(arr,y,y+1);    
			  }		      
		    }		
	    }
		printArray(arr);
	}
	/**
	给数组中的元素进行位置的置换。
	@param arr 接受一个int类型的数组。
	@param a 要置换的位置
	@param b 要置换的位置
	*/

	private static void swap(int[] arr,int a,int b)
    {
	   int temp =arr [a];
	   arr[a] =arr[b];
	   arr[b] =temp;
	}
	/**
	用于打印数组中的元素，打印形式[element1, element2,..]

	*/
	public static void printArray(int[] arr)
	{
	   System.out.print("[");
	   for(int x=0;x<arr.length;x++)
	   {
		   if(x!=arr.length-1)
			   System.out.print(arr[x]+", ");
		   else
			   System.out.println(arr[x]+"]");

	    
	   }
	}
}

class ArraysToolDemo 
{
	public static void main(String[] args) 
	{
		int[] arr = {1,5,8,0,9};

		int max = ArraysTool.getMax(arr);//直接用类名调用
		System.out.println("max="+max);

		int min = ArraysTool.getMin(arr);//直接用类名调用
		System.out.println("min="+min);

	    ArraysTool.selectSort(arr);

		ArraysTool.bubleSort(arr);
		/*

		ArraysTool tool= new ArraysTool();
           
		int max = tool.getMax(arr);
		System.out.println("Max="+max);

		int min = tool.getMin(arr);
		System.out.println("Min="+min);

        tool.bubleSort(arr);		
	    tool.selectSort(arr);*/
	}
}

静态代码块：

格式：

static

{

    静态代码块的执行语句

}

静态代码块的特点：随着类的加载而执行，只执行一次，并优先于主函数执行。用于给类进行初始化。

<pre name="code" class="java"><pre name="code" class="java">class StaticCode
{
	static//静态代码块‘a’
	{
	    System.out.print('a');
	}
}
class StaticCodeDemo  
{
	static//静态代码块‘b’
	{
	    System.out.print('b');
	}
	public static void main(String[] args) //main函数
	{
		new StaticCode();
		System.out.println("Hello World!");
	}
	static//静态代码块‘c’
	{
	    System.out.print('c');
	}
}

输出结果：bcaHello Word！

知识点：

主函数：

 主函数是一个特殊的函数。作为程序的入口，可以被jvm调用。

   public：代表着该函数访问权限是最大的。

   static：代表主函数随着类的加载就已经存在了。

   void：主函数没有具体的返回值。

   main：不是关键字，但是是一个特殊的单词，可以被jvm识别。

 （String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

 主函数是固定格式的是为了jvm识别。jvm在调用主函数时，传入的是new String[0];