栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java 面向对象 (5)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java 面向对象 (5)

初始化块

第四种成员终于出现了

语法形式
[修饰符]
{
     //可执行性代码...
}
  • 修饰符
    • 省略
      • 普通初始化块
      • 负责对对象执行初始化(实例相关)
    • static
      • 静态初始化块
      • 类初始化块
      • 负责对类执行初始化(类相关)
普通初始化块 调用时机

普通初始化块只在创建实例对象时才隐式调用,且总在构造器之前执行

public class HelloWorld 
{
	{
		int a = 10;
		if(a >  5)
		{
			System.out.println(1);
		}
		System.out.println(2);
	}
	
	{
		System.out.println(3);
	}
	
	public HelloWorld()
	{
		System.out.println(4);
	}
	   
    public static void main(String[] args)
	{
		   new HelloWorld();
		   
	}
}


  • 先定义的普通初始化块先执行
  • 应该尽量把多个普通初始化块合并成一个,从而让程序更加简洁,可读性更强
实例变量初始化

当 Java 创建一个对象时,系统先为该对象的所有实例变量分配内存空间(前提是该类已经被加载过了),接着程序开始对这些实例变量执行初始化

public class HelloWorld 
{
	int a = 1;
	{
		 a = 2;         //省略 int ,表明 a 为实例变量
	}
	
	public static void main(String[] args)
	{
		   System.out.println(new HelloWorld().a);
		   
	 }
}



public class HelloWorld 
{
	int a = 1;
	{
		 int a = 2;     //声明 int ,表明 a 为局部变量
	}
	
	public static void main(String[] args)
	{
		   System.out.println(new HelloWorld().a);
		   
	 }
}
  • 实例变量初始化顺序:
    1. 声明指定(源代码顺序)
    2. 初始化块(源代码顺序)
    3. 最后才执行构造器中指定的初始化处理
实质

使用 javac 编译 Java 类后,初始化块中的代码会被“还原”到每个构造器中,且位于构造器中所有的代码之前

public class HelloWorld 
{
	{
		 a = 2;          //提取出来的初始化块会被声明指定影响
	}
	int a = 1;
	
	public static void main(String[] args)
	{
		   System.out.println(new HelloWorld().a);
		   
	 }
} 



public class HelloWorld 
{
	public HelloWorld()
	{
		a = 2;           //显式还原到构造器中的初始化块不会被声明指定影响
	}
	
	int a = 1;
	
	public static void main(String[] args)
	{
		   System.out.println(new HelloWorld().a);
		   
	 }
}



  • 如果有一段初始化处理对同一类的所有对象完全相同
  • 且无须接受任何参数
  • 就可以把这段初始化处理提取成一个普通初始化块
  • 以提高初始化处理的复用以及整个应用的可维护性
静态初始化块 调用时机

系统将在类初始化阶段执行静态初始化块,而不是在创建实例对象时才执行

class A
{
	static
	{
		System.out.println(111);
	}
	{
		System.out.print(1);
	}
	public A()
	{
		System.out.print(2);
	}
}

class B extends A
{
	static
	{
		System.out.println(222);
	}
	{
		System.out.print(3);
	}
	public B()
	{
		System.out.print(4);
	}
}

public class HelloWorld extends B
{
	static
	{
		System.out.println(333);
	}
	{
		System.out.print(5);
	}
	public HelloWorld()
	{
		System.out.println(6);
	}
	
	public static void main(String[] args)
	{
		   new HelloWorld();
		   new HelloWorld();
		   
	 }
}



  • 静态初始化块总是比普通初始化块先执行
  • 应该尽量把多个静态初始化块合并成一个,从而让程序更加简洁,可读性更强
类变量初始化

当 JVM 第一次主动使用某个类时,系统会在类的准备阶段为该类的所有类变量分配内存空间,在类的初始化阶段则负责对这些类变量执行初始化

  • 一个类需要在加载并初始化之后才能使用
  • 一旦类初始化阶段完成,该类将在虚拟机中一直存在
  • 即一旦类初始化阶段完成,静态初始化块将永远不会再获得执行的机会
  • 类变量初始化顺序:
    1. 声明指定(源代码顺序)
    2. 初始化块(源代码顺序)
缺陷
public class HelloWorld
{
	static int a = 1;
	
	{
		a = 18;          //省略 int ,表明 a 为类变量
	}
	
	public static void main(String[] args)
	{
		   System.out.println(HelloWorld.a);
		   System.out.println(new HelloWorld().a);
           System.out.println(HelloWorld.a);		   
		   
	 }
}
  • 静态初始化块不能对实例变量进行初始化处理
  • 普通初始化块却可以对类变量进行初始化处理
    • 但最好不要这样做
    • 否则需要等到第一次创建实例对象时
    • 类变量的初始化才真正完成
包装类

当某个方法签名中为 Object 类型的形参,但实际需要却是2、3等数值时…

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
charCharacter
floatFloat
doubleDouble
booleanBoolean
自动装箱和自动拆箱
public class HelloWorld
{
    public static void main(String[] args)
	{
		   Integer a = 18;
           Object  b = 18;
           int     c = a;
		   System.out.println(a.getClass());
		   System.out.println(b.getClass());
           System.out.println(c);
		   
	 }
}
  • Autoboxing:
    • 可以把一个基本数据类型的值直接赋给对应的包装类变量
      • Autoboxing —> Integer
    • 可以把一个基本数据类型的值直接赋给 Object 类型的变量
      • Autoboxing —> Integer —> upcasting
  • AutoUnboxing:
    • 可以把一个包装类对象直接赋值给一个对应的基本数据类型变量
      • AutoUnboxing —> int
包装类的几个静态方法

调用时需要使用类名作为前缀

public static Integer valueOf(String s)



public static Integer valueOf(int i)



public static int parseInt(String s)



public static String valueOf(...)



基本数据类型 + ""

$
包装类实例与数值的比较
public class HelloWorld
{
    public static void main(String[] args)
	{
		   Integer a = Integer.valueOf(1);
		   int     b = 2;
		   System.out.println(a > b);
		   
		   
		   System.out.println( new Integer(2) == new Integer(2));
		   System.out.println( new Integer("2") == new Integer("2"));
		   
		   
		   
		   Integer c = 2;
		   Integer d = 2;
		   System.out.println(c == d);
		   Integer e = 200;
		   Integer f = 200;
		   System.out.println(e == f);
		   System.out.println(Integer.valueOf(-129) == Integer.valueOf(-129));
		   System.out.println(Integer.valueOf(-128) == Integer.valueOf(-128));
		   System.out.println(Integer.valueOf(127)  == Integer.valueOf(127));
		   System.out.println(Integer.valueOf(128)  == Integer.valueOf(128));
		   
        
           System.out.println((Integer.valueOf(18)).equals(18));
		   System.out.println((Integer.valueOf(18)).equals(18.0f));
		   
	 }
}




//java.lang.Integer 类的一段源码
static final Integer[] cache = new Integer[-(-128) + 127 + 1]
static 
{
    for(int i = 0 ; i < cache.length ; i++)
    {
        cache[i] = new Integer(i - 128)
    }
}

	 }
}
  • public String toString() 方法是 Object 类中定义的实例方法

    • 因此所有的 Java 对象都具有该方法

    • 且所有的 Java 对象都可以和字符串进行连接运算

    • 此时系统将自动调用该对象的 toString() 方法返回值

  • Object 类提供的 toString() 方法返回值

    • 类名 + @ + hashCode
  • String 类已经重写了 Object 的 toString() 方法

    • 输出该字符串对象的字符序列
==

数值型相等,即返回 true

引用变量指向同一个对象,即返回 true

public class HelloWorld
{
    public static void main(String[] args)
	{
		   System.out.println(18 == 18.0f);
		   System.out.println(97 == 'a');
		   System.out.println("Hi~" == "Hi~");
		   System.out.println(new String("Hi~") == new String("Hi~"));
		   
	 }
}
  • == 不可用于比较类型上没有继承关系的两个对象
equals

重写此方法以提供自定义的相等标准

public class HelloWorld
{
    public static void main(String[] args)
	{
		   System.out.println(Integer.valueOf(18) == 18);
		   System.out.println(Integer.valueOf(18) == 18.0);
		   
		   
		   System.out.println((Integer.valueOf(18)).equals(18));
		   System.out.println((Integer.valueOf(18)).equals(18.0));
		   System.out.println((Integer.valueOf(18)).equals(18.0f));
		   
	 }
}



public class HelloWorld
{
	private String id;
	private String name;
	public HelloWorld(String id , String name)
	{
		this.id = id;
		this.name = name;
	}
	
	public String getId()
	{
		return this.id;
	}
	
	public String toString()
	{
		return "HelloWorld[" + name + " = "+id+"]";
	}
	
	public boolean equals(Object obj)
	{
		if(this == obj)              //如果两个对象为同一个对象
		{
			return true;
		}
		
		if(obj != null && obj.getClass() == HelloWorld.class)
		{
			System.out.println(obj.getClass());
			System.out.println(HelloWorld.class);
			HelloWorld h = (HelloWorld)obj;               
			if(this.getId().equals(h.getId()))            //两个对象的 id 相等
			{
				return true;
			}	
		}
		
		return false;
	}
	
    public static void main(String[] args)
	{
		   HelloWorld h1 = new HelloWorld("123"  ,  "Hi" );
		   HelloWorld h2 = new HelloWorld("123"  ,  "Hi~" );
		   HelloWorld h3 = new HelloWorld("1234" ,  "Hi~" );
		   System.out.println(h1.equals(h2));
		   System.out.println(h1.equals(h3));
		   System.out.println(h2.equals(h3));
		   
	 }
}

  • public boolean equals(Object obj) 方法是 Object 类中定义的实例方法
    • 因此所有的 Java 对象都具有该方法
  • Object 类提供的 equals() 方法
    • 和 == 差不多
    • 比较的是实例对象的地址
  • String 类已经重写了 Object 的 equals() 方法
    • 判断标准为两个字符串所包含的字符序列相同
  • equals() 方法重写的几条规则:
    • 自反性
      • x.equals(x) == true
    • 对称性
      • x.equals(y) == y.equals(x)
    • 传递性
      • x.equals(y) == true && y.equals(z) == true —> x.equals(z) == true
    • 一致性
      • 如果实例对象 x 、y 用于等价比较的信息没有改变,则无论调用多少次,x.equals(y) 要么一直是 true ,要么一直是 false
    • x != null
      • x.equals(null) == false
单例类(Singleton)

始终只能创建一个实例对象

class A
{
	private static A instance;
	private A(){}
	public static A getInstance()
	{
		if(instance == null)
		{
			instance = new A();
		}
		return instance;
	}
}

public class HelloWorld
{
    public static void main(String[] args)
	{
		   A a1 = A.getInstance();
		   A a2 = A.getInstance();
		   System.out.println(a1 == a2);
		   System.out.println(a1.equals(a2));
		   
	 }
}
  • 频繁地创建对象带来的系统开销问题,可能会导致系统性能下降

  • 良好封装的原则:

    • 构造器使用 private 修饰

    • 然后再提供一个方法作为访问点

    • 设置为 public ,用于创建实例对象

    • 设置为 static ,该方法的主调只能是类本身,因为调用该方法时还不存在实例

    • 然后在提供一个成员变量来缓存创建的实例对象

    • 设置为 static ,因为该成员变量需要被上述的访问点方法访问

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/970401.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号