java笔记-面向对象-匿名对象、说明文档、单例设计模式

面向对象是基于面向过程的，将功能封装进对象，强调了具备功能。

面向对象的三个特征：封装，继承，多态。

以后的开发就是找对象使用，没有对象开发对象，并维护对象的关系。

类和对象的关系：

类是对现实事物的描述，对象是现实事物实实在在的个体。

对象的描述：提取对象的共性内容，包括属性和行为。

属性对应类中的变量，行为对应类中的函数。属性和行为称为类中的成员（成员变量和成员方法）；

在java中，描述就是class定义的类，具体对象就是对应java在堆内存中用new实例化的类。

成员变量和局部变量：

成员变量作用于类中；

局部变量作用于函数或者语句中；

成员变量存在堆内存中，局部变量存在栈内存中。

匿名对象：

匿名对象是对象的简化形式，当对象的方法只调用一次时，则用匿名对象；将匿名对象做为实参传递给方法调用。

new Car();

/*
** 匿名化对象的使用；
*/
class Car{
	int num;
	String color;
	public void run(){
		System.out.println(color+".."+num);
	}
}
public class  object{
	public static void main(String[] args){
		//Car c=new Car();	//实例化对象；
		show(new Car());	//使用匿名对象，匿名对象做为实际参数传递；
							//匿名对像存在堆内存中，无栈内存；
	}
	public static void show(Car c){
		c.num=3;
		c.color="black";
		c.run();
	}
}

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

好处：将变化隔离，便于使用，提高重用性，提高安全性。

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

/*
** privat:私有，权限修饰符，只在本类中有效；
** 私有只是封装的一种表现形式，还有别的方式；
** 之所以对外提供访问方式，就可以在访问方式中加入逻辑判断语句；
** 对访问的数据进行合理性判断，提高代码的强壮性；
*/
class Person{
	private int age;	//private age;存储在堆内存中。
	//获取属性值；
	public int getAge(){	
		return age;	
	}
	//设置属性值；
	public void setAge(int newAge){
		if((newAge>=0)&&(newAge<=130)){
			age=newAge;
		}
		else{
			System.out.println("Illegal age!");
		}		
	}
	void speak(){
		System.out.println("age="+age);
	}
}
class PersonDemo{
	public static void main(String[] args){
		Person p=new Person();
		//p.age=20;		//建立对象后，属性被直接访问；
		p.setAge(32);
		p.speak();
	}
}

构造函数

特点：函数名与类名相同；不定义返回值类型；不可以写reurn语句；多个构造函数是以重载的形式存在的。

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

若将所有构造函数进行私有化private，则该类不能创建对象。

注意构造代码块

/*
** 构造函数一旦建立，就会调用与之对应的构造函数；
** 作用：可对对象进行初始化；
** 没有定义构造函数时，系统默认给该类添加一个空参数构造函数；
** 当自定义构造函数时，系统默认的构造函数就没有了。
** 何时定义构造函数：当分析事物时，事物本身存在一些固定的属性和方法。
*/
class Person{
	private String name;
	private int age;
	public String getName(){
		return name;
	}
	public void setName(String newName){
		name=newName;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int newAge){
		age=newAge;
	}
	/*
	** 构造代码块：给对象进行初始化；对象一旦建立就运行，优先于构造函数执行。
	** 和构造函数的区别：构造代码块是给所有对象统一初始化(初始化共性特征)。
	** 构造函数是给对应的对象进行初始化。
	*/
	{
		System.out.println("Cry...(Person code run.)");
	}
	
	/*
	** 以下为三个构造函数。
	*/
	Person(){
		System.out.println("name ="+name+",age="+age+".");
	}
	
	Person(String newName){
		name=newName;
		System.out.println("name ="+name+",age="+age+".");
	}
	Person(String newName,int newAge ){
		name=newName;
		age=newAge;
		System.out.println("name ="+name+",age="+age+".");
	}
}	
class Construction{
	public static void main(String[] args){
		Person per=new Person();	
		Person per_1=new Person("mike");
		Person per_2=new Person("like",23);	
	}
}

this关键字

/*
** 构造函数一旦建立，就会调用与之对应的构造函数；
** 作用：可对对象进行初始化；
** 没有定义构造函数时，系统默认给该类添加一个空参数构造函数；
** 当自定义构造函数时，系统默认的构造函数就没有了。
** 何时定义构造函数：当分析事物时，事物本身存在一些固定的属性和方法。
*/
class Person{
	private String name;
	private int age;
	public String getName(){
		return name;
	}
	public void setName(String newName){	
		name=newName;					
	}
	public int getAge(){
		return age;
	}
	public void setAge(int newAge){
		age=newAge;
	}
	/*
	** 构造代码块：给对象进行初始化；对象一旦建立就运行，优先于构造函数执行。
	** 和构造函数的区别：构造代码块是给所有对象统一初始化(初始化共性特征)。
	** 构造函数是给对应的对象进行初始化。
	*/
	{
		System.out.println("Cry...(Person code run.)");		//该语句每次在新建对象时都会执行；
	}
	
	/*
	** 以下为三个构造函数。
	*/
	Person(){
		System.out.println("name ="+name+",age="+age+".");
	}
	Person(int age){
		this.age=age;
	}
	Person(String name){
		//name=name;		//若在此处设置name，则堆内存中的name不能赋值，为null
		this.name=name;		//若在此处设置name，则堆内存中的name可赋值。
							//this用于区分局部变量和成员变量。
							//this代表它所在函数对象的引用。
							//哪个对象调用this所在的函数，则this就代表该对象。
		System.out.println("name ="+name+",age="+age+".");
	}
	Person(String name,int age ){
		//this.name=name;
		//Person(name);		//构造函数间调用只能用this语句
		this(name);			//该语句将name值传递给单参数的构造函数Person（String name）;
							//this语句只能放在构造函数的第一行。
		this.age=age;
		System.out.println("name ="+name+",age="+age+".");
	}
	public boolean Compare(Person p){	//将对象做为实参传递；
		return this.age==p.age;			//哪个对象调用this所在的函数，则this就代表该对象。
	}
}	
class Construction{
	public static void main(String[] args){
		Person per=new Person();	
		Person per_1=new Person("mike");
		Person per_2=new Person("like",23);	
		Person p_1= new Person(20);
		Person p_2=new Person(23);
		System.out.println("compare age:"+p_1.Compare(p_2)+".");
		
	}
}

static关键字：

/*
** 当成员被静态static修饰后，该成员可用类名直接调用；
** 被static修饰的成员变量和成员方法独立于该类的任何对象；
** 它不依赖于特定的实例，被类的所有实例共享；
** static的成员变量和方法可以在任何对象创建之前访问，无需引用任何对象；
** 类的所有实例共享该static变量。
** 什么时候使用静态？
** 从两方面入手：
** 1.定义静态变量：当对象中出现共享数据时。
** 2.定义静态函数：当功能函数没有访问到非静态数据（对象的特有数据）时；即：静态方法访问静态数据。
*/
class Person{
	/*属性*/
	String name;
	static String country="CN";
	/*公共接口*/
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getCountry(){
		return country;
	}
	public void setCountry(String country){
		this.country=country;
	}
	public void show(){
		System.out.println(name+":::"+country);
	}
	public static void show_1(){
		//System.out.println(name+":::"+country);		//该语句访问到了非静态数据，不能编译；
		System.out.println("国家："+country);			//该语句只访问了静态数据；
	}
}
class staticDemo{
	public static void main(String[] args){
		Person p=new Person();
		Person p1=new Person();
		p.show();
		Person.country="EA";	//用类名直接访问。
		p.show();
		p.setCountry("HK");
		p.show();				//类中的所有实例共享该static变量，p和p1都打印出“HK”.
		p1.show();				//类中的所有实例共享该static变量，p和p1都打印出“HK”.
		Person.show_1();		//静态方法；
		
	}
}

main函数：

/*
** 主函数，是一个特殊的函数，是程序的入口，可以被jvm调用。
** 主函数的定义：
** public：代表访问权限最大；
** static：代表主函数随着类的加载就已经存在了。
** void：主函数没有具体的返回值；
** main：不是关键字；是一个特殊的可以被jvm识别。
** 函数参数：String[] args
** 参数类型是一个数组，数组中的元素是一个字符串。
** 主函数是固定格式的，
** jvm在调用主函数时，传入是new String[0];
*/
class mainDemo{
	public static void main(String[] args){		//jvm只能识别该特定格式的main函数；
												//函数具有重载性，还有无参和多参的main函数。
		System.out.println(args.length);

	}
}

private和static的应用：

工具类的构建及说明文档的制作：

文档名称：ArrayTool.java

/**
** 数组类工具；
** @author cs.Ing
** @version v1.0
*/

public class ArrayTool{
	/*
	** 空参数构造函数；
	*/
	//private ArrayTool(){};		//使用该语句可禁止构建类对象。
	/**
	 * 获取数组中元素的最大值；
	 * @param arr 整型数组;
	 * @return 整型数组的最大值；
	*/
	public static int getMax(int[] arr){	//该方法未使用类中非静态变量，所以将其static
		int max=0;
		for(int x=0;x<arr.length;x++){
			if(arr[x]>arr[max]){
				max=x;
			}
		}
		return arr[max];
	}
	/**
	 * 获取数组中元素的最小值；
	 * @param arr 整型数组；
	 * @return 数组中的最小值；
	*/
	public static int getMin(int[] arr){	//该方法未使用类中非静态变量，所以将其static	
		int min=0;
		for(int x=0;x<arr.length;x++){
			if(arr[x]<arr[min]){
				min=x;
			}
		}
		return arr[min];
	}
	/**
	 * 选择排序（从小到大）；
	 * @param arr 整型数组；
	 */
	public static void selectSort(int[] arr){	//该方法未使用类中非静态变量，所以将其static
		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);
				}
			}
		}
	}
	/** 
	 * 冒泡排序（从小到大）；
	 * @param arr 整型数组；
	*/
	public static void bubbleSort(int[] arr){	//该方法未使用类中非静态变量，所以将其static
		for(int x=0;x<arr.length-1;x++){
			for(int y=0;y<arr.length-x-1;y++){
				if(arr[y]>arr[y+1]){
					swap(arr,y,y+1);
				}
			}
		}
	}
	/**
	 * 数组打印；
	 * @param arr 整型数组；
	*/
	public static void PrintArray(int[] arr){	//该方法未使用类中非静态变量，所以将其static
		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]+"]");
		}
	}
	/*
	 * 数组中两个元素数据交换；
	 * 此部分为private 不提供说明；
	*/
	private static void swap(int[] arr,int a,int b){		//该方法只在本类中使用，所以限制其权限为private
															//无法从静态上下文中引用非静态方法，这里的方法也要static。
		int temp;
		temp=arr[a];
		arr[a]=arr[b];
		arr[b]=temp;
	}
}

说明文档的制作：

在dos窗口运行：

javadoc -d myhelp -author -version ArrayTool.java

执行完毕会在当前目录的myhelp文件夹下构建说明文档。

使用上面的工具类：

/*
** 工具类的使用。
*/
class ArrayToolDemo{
	public static void main(String[] args){
		int[] arr=new int[]{3,32,31,4,8,2,9,12};
		ArrayTool ArrT=new ArrayTool();		//此处构建对象，在堆内存中分配了空间，没有必要。
											//由于类中成员均为静态方法，可直接使用类名访问静态方法；
		int Max=ArrT.getMax(arr);
		System.out.println("Max is "+Max);
		int Min=ArrT.getMin(arr);
		System.out.println("Min is "+Min);
		//打印排序前数组；
		ArrT.PrintArray(arr);	
		//选择排序；
		ArrT.selectSort(arr);
		//打印排序后数组；
		ArrT.PrintArray(arr);
		//冒泡排序；
		ArrT.bubbleSort(arr);
		//打印排序后数组；
		ArrT.PrintArray(arr);
		
	}
}

在编译时，可直接编译上面的ArrayToolDemo.java文件，虚拟机会在编译时自动查找引用的工具类并编译，也可以分开编译。
单例设计模式：

/* 单例设计模式：
** 保证对象唯一；
** 禁止其它程序建立该类对象；
** 在本类中自己定义对象；
** 对外提供对该类对象的访问接口。
** 如何实现：
** 1.将该构造函数私有化；
** 2.在类中创建一个本类对象；
** 3.提供一个方法获取到该类对象。
*/
class Single{
	private int num;
	public int getNum(){
		return num;
	}
	public void setNum(int num){
		this.num=num;
	}
	/*
	** 单例设计模式-饿汉式
	** 类一进内存就创建好了对象。
	*/
	/*饿汉式：
	private Single(){};						//私有化构造函数，禁止在其它类中构建对象；
	private static Single s = new Single();	//2.构建私有对象，并静态化，
	public static Single getInstance(){		//1.由于不能构建对象，只能通过类名访问，类名的访问需要静态方法；
											//该类类似接口类，该方法也需要静态化；
		return s;
	}
	*/
	/*
	** 单例设计模式-懒汉式（一般不常用）
	** 对象在方法调用时才创建（初始化），也叫做对象的延时加载；
	*/
	private Single(){};
	private static Single s=null;
	//使用synchronized（）可避免多线程进入，但降低了效率；可采用“方法二”。
	/*
	public static synchronized Single getInstance(){	
		if(s==null){
			s=new Single();
		}
		return s;
	}
	*/
	//方法二；
	public static synchronized Single getInstance(){
		if(s==null){
			//将synchronized(同步)放在此处，减少了判断次数；
			synchronized(Single.class){
				if(s==null){
					s=new Single();
				}
			}
		}
		return s;
	}
}
class SingleDemo{
	public static void main(String[] args){
		Single ss=Single.getInstance();			//通过公共接口获得私有化对象引用；静态方法通过类名直接引用；
		ss.setNum(3);
		Single ss2=Single.getInstance();			//通过公共接口获得私有化对象引用；
		ss2.setNum(2);						
		System.out.println("单例模式修改num："+ss.getNum());
	}
}