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());
	}
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值