黑马程序员 基础(三)

原创 2013年12月04日 22:24:24

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

1,Object对象基本操作

        Object类是所有类的基类,除了八个原始类型,以及一个void类型,Object类提供了基本的方法

public static void Object_description(){
		Object obj = new Object();
		//一般情况下,equals方法只是比较内存地址是否一致,继承类常常是重写object类的equals方法,
		//参数一定要是Object,否则编译错误
		System.out.println(obj.equals(null));
		//hashcode用于返回对象在内存中映射的hash码,是本地化方法(native)
		System.out.println(obj.hashCode());
		//生成对象的类名和hash码值的连接字符串
		System.out.println(obj.toString());
		//获取对象的类名
		System.out.println(obj.getClass());
	}

补充:Object的hashcode是本地化方法,主要是通过分配的内存地址计算来的,所以即使两个Object描述的内容一致,对应的hashcode码也不同

注意:不能这样写:null是原始类型

null.equals(null);

2,享元模式

          享元模式是设计模式的一种,定义如下:运用共享技术有效的支持大量细粒度的对象。

        典型应用:

        典型的享元模式的例子为文书处理器中以图形结构来表示字符。一个做法是,每个字型有其字型外观, 字模 metrics, 和其它格式资讯,但这会使每个字符就耗用上千字节。取而代之的是,每个字符参照到一个共享字形物件,此物件会被其它有共同特质的字符所分享;只有每个字符(文件中或页面中)的位置才需要另外储存。以下程式用来解释上述的文件例子。这个例子用来解释享元模式利用只载立执行立即小任务所必需的资料,因而减少内存使用量。
         integer在享元模式中的运用,不能用new Integer(23)的方法,这样就是引用堆内存了,不能混淆
代码如下:
public static void FlyweightPattern_mode(){
		//如果数值在-128~127之间,则会将第一次使用到的数值存放在缓冲池中
		//下次在使用相同值的时候,则就不需要分配堆内存了,直接引用就可以了
		Integer i1 =147;//自动装箱成整形对象
		Integer i2 =147;//自动装箱成整形对象
		System.out.println( i1==i2);//打印出false
		i1 =23;//存在缓冲池中
		i2 =23;//直接引用23
		System.out.println( i1==i2);//打印出true
	}

验证结果:


3,享元模式在字符串中的应用

          享元模式在数字中应用的方法是否同样对字符串有效呢?先看一段代码

	String str1 = “abc”
	String str2 = new String("abc");
	System.out.println(str1 == str2);

答案是false,因为是引用堆内存,那么有什么办法解决呢,有!

	String str3 = "abc";
	String str4 = new String("abc").intern();
	System.out.println(str3 == str4);

intern方法就是在常量池中查找是否有和自己内容一样的字符存在,如果有则指向常量池。
验证结果:


4,字符串引用的问题

          引用的问题在开发中也很重要,稍不注意就容易被修改,查找问题也不容易,例如:

	StringBuffer s1 = new StringBuffer("abc");
	StringBuffer s2 = new StringBuffer("abc");
	new problem_study().method(s1, s2);
	System.out.println(s1.toString()+":"+s2.toString());

处理函数如下:

public void  method(StringBuffer sbuf,StringBuffer sbuf1){
		sbuf1 = sbuf.replace(1, 2, "o");
		System.out.println(sbuf1 == sbuf);
	}

执行replace操作,那么谁的值会改变呢?打印结果是是两个都变,还是s1变,或者s2变,看下结果:

sbuf和sbuf1指向了同一个内存,结果是s1变了,s2没有变,按照常理来说应该s2也应该变,但是有个前提,sbuf是s1的副本,sbuf1是s2的副本,所以s2还是指向堆内存原来的地方,s1的值被改变了,说明sbuf引用的对象值改变了,所以Stringbuffer的replace操作是在引用对象上直接操作的。

用string测试:

	String str5 = new String("abc");
	String str6 = new String("abc");
	new problem_study().method(str5, str6);
	System.out.println(str5.toString()+":"+str6.toString());

处理函数如下:

public void method(String str,String str1){
		str = str1.replace("b", "o");
		System.out.println(str == str1);
	}

那么结果又是什么呢?还会是aoc:abc吗?先看结果


分析:str和str1指向不同内存,那么至少有一个变吧,但是结果都没有变,说明str指向的是一个新地址,说明str1的内容不能被改变,str5和str6没有受到一点影响

推论:sting类型的对象不能改变,即使是replace操作,那是假象,只是又生成一个新的字符串。

5,可变参数(jdk1.5新特性)

        说明:可变参数简化了开发人员的许多操作,

         1,简化了操作人员写重载 ,重载是比较头疼的事情,像String重载一大堆,

         2,简化了操作人员写数组 ,每次使用都要new一个数组对象,然后再调用,很麻烦

	public static void multi_args(){
		System.out.println(sum(2,3,4));
		System.out.println(sum(2,3));
	}
	public static int sum(int...arg){
		int sum =0;  
		for(int i = 0; i < arg.length; i++){
			sum += arg[i];  
		}
		return sum;
	}

验证结果:


6,类的静态导入

       当一个源文件中使用大量工具类时,如果每次写都要加上类名,会很麻烦,影响效率,代码也不清晰,解决的办法是用静态导入,例如求两个数最大值。

import static java.lang.Math.max;

就是在import的后面加上static标识符

public static void import_static(){
		int i = 2;
		int j = 3;
		//此时max前面就不需要加Math类了
		int max = max(i,j);
		System.out.println(max);
	}

验证结果:


7,类的成员初始化(带有继承的)

          大致过程是,先是父类静态部分,接着子类静态部分,接着父类构造部分,最后子类构造部分,
         详细过程如下:

 (1). 父类静态相关初始化(仅仅执行一次)
        父类的静态成员初始化(仅执行一次)
        父类static代码块(仅执行一次)--->

 (2).子类静态相关初始化(仅仅执行一次)
       子类的静态成员初始化(仅执行一次)--->
       子类static代码块(仅执行一次)--->

 (3). 父类非静态相关初始化
        父类成员变量初始化--
        父类构造代码块 --->           

        父类构造方法初始化 ---> //执行这步的原理同上
 (4). 子类非静态相关初始化
        子类成员变量初始化--->
        子类构造代码块--->
        子类构造方法初始化
 示例代码:

父类

class father{
	public static String name = "大明";
	public int age = 30;
	static {
		System.out.println("father static code......"+name);
	}
	{
		System.out.println("father construct code......."+age);
	}
	public father(){
		System.out.println("father construct function......"+name+" "+age);
	}
}

子类:

class child extends father{
	public static String name = "小明";
	public int age = 6;
	static{
		System.out.println("child static code......"+name);
	}
	{
		System.out.println("child construct code......"+age);
	}
	public child(){
		System.out.println("child construct function......"+name+" "+age);
	}	
}

调用函数:

father f = new child();

验证结果:



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

 

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

黑马程序员-java基础(三)-异常体系

------- android培训、java培训、期待与您交流! ---------- 异常体系 异常的体系 异常:是在运行时期发生的不正常情况,java通过面向对象的思想将问题封装成了对象,用异常...

黑马程序员--学习日记(三)面向对象基础

一,面向对象 1.      理解面向对象 面向对象是相对于面向过程而言的,面向对象和面向过程都是一种编程的思想。 1.1面向对象和面向过程的区别? 面向过程更加强调的是它的功能行为。面向对象...

黑马程序员--OC基础--面向对象三大特征

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-1、面向对象三大特征OC中面向对象的三大特征是:封装、继承和多态。2、封装封装就是把数据隐藏起来,只能用此类的方法...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)