黑马程序员--java基础--面向对象思想和单例模式

本文详细解析Java的面向对象思想,包括类与对象的概念、成员变量与局部变量的区别、对象封装、构造函数、this关键字、静态概念及应用、静态代码块等核心知识点。同时介绍了静态变量和静态函数的使用场景,并通过一个数组工具类的实例展示了Java中的工具类设计,以及单例设计模式的两种实现方式:饿汉式和懒汉式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

                                                      ------- android培训java培训、期待与您交流! ----------

                                            面向对象

面向对象:是一种思想,想学好Java必须掌握面向对象。


        c语言是一门面向过程的语言,c语言强调的是功能行为。

        Java面向对象的思想就是强调具有功能的对象。面向对象是把行动者变成了指挥者。



面向对象的特点
        1. 是一种符合人们思考习惯的思想
        2. 可以将复杂的事情简单化
        3.将程序员从执行者转换成了指挥者

        Java的开发过程,其实就是不断的创建对象,使用对象,指挥对象做事情。

        设计的过程,其实就是在管理和维护对象之间的关系。


 
类与对象

如图我们可以理解为:类是事物的描述,对象是实体(也可以理解为:类就是图纸,汽车就是对象。)



       使用计算机语言就是不断的描述现实生活中的事物,而java中描述事物通过类的形式体现。

       Java是用类class来描述对象的属性和行为,通过new创建对象,即是该类事物实实在在存在的个体。


如何用代码形式创建对象

描述小汽车

分析:
1,属性。
	轮胎数。
	颜色。 
2,行为。
	运行。

*/
class Car
{
	int num;
	String color;
	
	void run()
	{
		//int num = 10;
		System.out.println(num+"..."+color);
	}

}

class  CarDemo
{
	public static void main(String[] args) 
	{
		//在计算机中创建一个car的实例。通过new关键字。 
		Car c = new Car();// c就是一个类类型的引用变量,指向了该类的对象。
		c.num = 4;
		c.color = "red";

		c.run();//要使用对象中的内容可以通过  对象.成员 的形式来完成调用。
	}
		
}


成员变量和局部变量
       之前我们用到的基本都是局部变量,现在我们将会使用成员变量。其实它两都是变量,规范写法上也没啥区别,都是标识符,但是在作用范围和内存中分配不同。


     

匿名对象
        匿名对象是对象的简化形式,匿名对象两种使用情况。
                1、当对对象方法仅进行一次调用的时。

                2、匿名对象可以作为实际参数进行传递。

匿名对象。没有名字的对象 。
		new Car();//匿名对象。其实就是定义对象的简写格式。
		Car c = new Car();
		c.run();
		new Car().run();
		
		1,当对象对方法仅进行一次调用的时候,就可以简化成匿名对象。
		
		new Car().num = 5;
		new Car().color = "green";
		new Car().run();

//基本数据类型参数传递
class Demo 
{
	public static void main(String[] args) 
	{

		int x = 3;
		show(x);
		System.out.println("x="+x);
	}
	public static void show(int x)
	{
		x = 4;
	}
}

//引用数据类型参数传递
class Demo
{
	int x = 3;
	public static void main(String[] args)
	{
		Demo d = new Demo();
		d.x = 9;
		show(d);
		System.out.println(d.x);
	}
	public static void show(Demo d)
	{
		d.x = 4;
	}
}


对象的封装



封装的表现形式

        (私有)private关键字:权限修饰符,用于修饰类中的成员(成员变量,成员函数)。

           私有只在本类中有效。

           将成员变量私有化,对外提供对应的set,get方法对其进行访问。
        

                                构造函数



 构造函数小特点

        当一个类中没有定义构造函数时,那么系统就会默认给该类加入一个空参数的构造函数。

        当在类中自定义了构造函数后,默认的构造函数就没有了。

构造函数和一般函数区别

  构造函数是在对象一建立就运行,给对象初始化。

        一个对象建立,构造函数只运行一次。

   一般方法是对象调用才执行,给是对象添加对象具备的功能。

        一般方法可以被该对象调用多次。

什么时候定义构造函数
        当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。

构造代码块和构造函数的区别:

        构造代码块给对象进行初始化。对象一建立就运行。

       构造代码块是给所以对象进行初始化。
       而构造函数是给对应的对象初始化。
       构造代码块中定义的是对象共性的初始化内容。
 
                               this关键字

/*
当成员变量和局部变量重名,可以用关键字this来区分。

this : 代表对象。代表哪个对象呢?当前对象。
	   this就是所在函数所属对象的引用。
	   简单说:哪个对象调用了this所在的函数,this就代表哪个对象。

this也可以用于在构造函数中调用其他构造函数。
注意:只能定义在构造函数的第一行。因为初始化动作要先执行。
*/

class Person
{
	private String name;
	private int age;	
	Person()
	{		
		name = "baby";
		age = 1;
		System.out.println("person run");
	}	
	Person(String name)	
	{
		this();
		this.name = name;
	}
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;		
	}
	public void speak()
	{
		System.out.println(this.name+":"+this.age);
	
	}

}


this的应用
       当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。
       但凡本类功能内部使用到了本类对象,都用this表示。

this的两种用法

1、用于区分同名变量的情况,说的成员和局部同名的时候;

2、用于构造函数间调用。


                                               static(静态)关键字

 

static的特点:
1,static是一个修饰符,用于修饰成员。
2,static修饰的成员被所有的对象所共享。
3,static优先于对象存在,因为static的成员随着类的加载就已经存在了。 
4,static修饰的成员多了一种调用方式,就可以直接被类名所调用 。 类名.静态成员 。
5,static修饰的数据是共享数据,对象中的存储的是特有数据 

      当成员被静态修饰后,可以直接被类名调用。

       格式:类名.静态成员

成员变量和静态变量的区别
1,两个变量的生命周期不同。
成员变量随着对象的创建而存在,随着对象的被回收而释放。
静态变量随着类的加载而存在,随着类的消失而消失。


2,调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用,还可以被类名调用。


3,别名不同。
成员变量也称为实例变量。
静态变量称为类变量。 


4,数据存储位置不同。
成员变量数据存储在堆内存的对象中,所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据.






静态使用的注意事项:
1,静态方法只能访问静态成员。(非静态既可以访问静态,又可以访问非静态)
2,静态方法中不可以使用this或者super关键字。
3,主函数是静态的。



什么时候用静态
       
1,静态变量。
当分析对象中所具备的成员变量的值都是相同的 。
这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的,就是对象的特有数据,必须存储在对象中,是非静态的。
如果是相同的数据,对象不需要做修改,只需要使用即可,不需要存储在对象中,定义成静态的。


2,静态函数。
函数是否用静态修饰,就参考一点,就是该函数功能是否有访问到对象中的特有数据。
简单点说,从源代码看,该功能是否需要访问非静态的成员变量,如果需要,该功能就是非静态的。
如果不需要,就可以将该功能定义成静态的。当然,也可以定义成非静态,
但是非静态需要被对象调用,而仅创建对象调用非静态的

没有访问特有数据的方法,该对象的创建是没有意义。


静态代码块:
       格式:
              static
              {
                           静态代码块中的语句。
              }
特点:随着类的加载而执行,执行一次。并优先于主函数。用于给类进行初始化。
对象的初始化过程:

        1、把类名.class文件加载到内存中。
        2、执行该类中的static代码块,如果有得话,给该类进行初始化。
        3、在堆内存中开辟空间,分配内存地址。给对象
        4、在堆内存中建立对象的特有属性。并进行默认初始化。
        5、对属性进行显示初始化。
        6、对对象进行构造代码块初始化。
        7、对对象进行对应构造函数初始化。
        8、将内存地址赋给栈内存中的对象名变量。

主函数的构造说明



java中的工具类

        每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装。以便复用。
下面我们以一个数组工具类为例,作一个文档说明书。
/**
建立一个用于操作数组的工具类,其中包含着常见的对数组操作的函数如:最值,排序等 。
@author 郭
@version 
*/

public class ArrayTool
{
	private ArrayTool(){}//该类中的方法都是静态的,所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
						//可以将构造函数私有化。

	/**
	获取整型数组的最大值。
	@param arr 接收一个元素为int类型的数组。
	@return 该数组的最大的元素值
	*/
	public static int getMax(int[] arr)
	{
		int maxIndex = 0;
		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]>arr[maxIndex])
					maxIndex = x;//
		}

		return arr[maxIndex];
	}
	/**
	对数组进行选择排序。
	@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);
			}
		}
	}

	/*
	用于给数组进行元素的位置置换。
	@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;
	}
	
	/**
	获取指定的元素在指定数组中的索引.
	@param arr 接收一个元素为int类型的数组。
	@param key 要找的元素。
	@return 返回该元素第一次出现的位置,如果不存在返回-1.
	*/
	public static int getIndex(int[] arr,int key)
	{
		for(int x=0; x<arr.length; x++)
		{
			if(arr[x]==key)
				return x;
		}
		return -1;
	}

	/**
	将int数组转换成字符串。格式是:[e1,e2,...]
	@param arr 接收一个元素为int类型的数组。
	@return 返回该数组的字符串表现形式。 
	*/
	public static String arrayToString(int[] arr)
	{
		String str = "[";

		for(int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				str = str + arr[x]+", ";
			else
				str = str + arr[x]+"]";
		}
		return str;
	}
}

在dos命令行中输入命令:javadoc -d Myhelp -author-version ArrayTool.java


Java中的javadoc工具就会帮我们完成API的制作。




 
                                            单例设计模式
设计模式的概念:解决某一问题最行之有效的方法。

单例设计模式的作用:使一个类在内存中只存在一个对象。

步骤

        1、将构造函数初始化。

        2、在类中创建一个本类对象。

        3、提供一个访问方法可以获取到该对象。

单例设计模式有两种写法(背也要背下来

        1、饿汉式:也就是刚三部中的示例语句。它的特点是先初始化对象。

如:Single类一进内存,就已经创建好了对象。在实际开发中,出于安全考虑,建议使用饿汉式。

class Single  
{  
                   private static Single sin=new Single(); //直接创建对象,比较常用;
                   private Single(){}//构造函数私有化,使其他类中不能创建该类对象。
                   public static Single getInstance()//括号里面可以写入条件,从而实现可控性。
                   {  
                                   return sin;  
                    }  
}  

2、懒汉式:它的特点对象是方法被调用时,才初始化,这也叫对象的延时加载。

如:在以下完整代码中,Single类进内存,对象还没有存在,只有调用了getInstance()方法时,才创建对象。

class Single  
{  
               private static Single sin=null; //这里就是体现出懒汉,初始值定义为空,被调用时才创建对
               private Single(){}//构造函数私有化,使其他类中不能创建该类对象。
               public static Single getInstance() //括号里面可以写入条件,从而实现可控性。 
               {  
                            if(sin==null)   
                            sin=new Single();  
                            return sin;  
               }  
}  



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值