Java基础学习第六章之面向对象下

基本数据类型和包装类：

Java 语言是一种面向对象的编程语言，为了以更加面向对角的思维去考虑问题，所以Java 为8 种基本类型，提供了对应的包装类，基本类型是没有属性方法来供调用和使用的，包装类，可以理解成一个对应基本类型的类，可以调用属性和方法。

基本类型         包装类
byte            Byte
short           Short
int             Integer
long            Long
char            Character
float           Float
double          Double
boolean         Boolean

除去了int 和 char 都是首字母大字，（符合类的定义），基本类型和包装类 互转 ，以及把一个字符串转成包装类。
  int variable=123;           // 基本数据类型
  Integer wapI = new Integer(variable); // 转换成包装类
  variable = wapI.intValue(); // 把包装类型转成 基本数据类型
		
  boolean bVar=true;            // 基本数据类型
   Boolean wapB  = new Boolean(bVar); // 转换成包装类
   bVar = wapB.booleanValue(); // 把包装类型转成 基本数据类型
 
   Float fVar = new Float("12.34"); // 把字符串转成 Float 的包装类
   System.out.println(fVar);
   // 把一个 字符串 abc 转成 long 类，很明显不是一个类 所以会报异常
   Long lVar = new Long("abc");//java.lang.NumberFormatException: For input string: "abc"
   System.out.println(lVar);

 
 总结 ：基本类型 通过 new WrapperClass(primitive) 转成包装类，包装类 通过 WrapperStance.xxxValue() 转成 基本数据类型。
 如果 不是包装类的数据类型 转换会报 异常： NumberFormatException.

JDK 1.5 以后 为提供了自动拆装箱，基本数据和包装类可以直接赋值，子类可以直接赋值给父类。

     int result= 5;
	Integer iResult =result; // 基本类型  直接 赋值为 包装类型 
	result =iResult;//包装类型    直接 赋值为 基本类型 
		
	Bird bird = new Ostrich();  // 子类 赋值给 父类

把字符串转成基本类型 

	String intStr="234";
	int iStr = Integer.valueOf(intStr);
	 System.out.println(iStr);
	float fStr = Float.valueOf(iStr);
	 System.out.println(fStr);
	double dStr = Double.valueOf(iStr);
	 System.out.println(dStr);
     String str =123+"";// 任何基本类型 与 字符串 关联 都是 字符串
	 System.out.println(str);

对象的外理
  Object 类是所有的类的支接父类或是间接父类，在Object 中一个 toString() 方法，是返回对象的字符串表示，如果没有重写，就会返回该对象在内存中的16进制地址。

Ostrich os1 = new Ostrich("black");
	  System.out.println(os1);
    地址：com.soliucheng.domain.Ostrich@c17164
	
 重写toString,把我们感兴趣的内容表示出来。
     @Override
	public String toString() {
		return "Ostrich [colour=" + colour + "]";
	}
	Ostrich os1 = new Ostrich("black");
	 System.out.println(os1);	//默认调用 Object.toString();

   结果： Ostrich [colour=black]

equals 和 == 的用法


  Java 语言中对比较两个对象是否相等，提从了两种方式，一种是== 运算符，另一种是 equals() .
  当使用== 表较两个对象是否相等时，如果两个对象的都是数值型时，只要值相等，就会返回true,否则返回false.
  如果是引用数据类型时，两个变量引用的是同一个对象时，才会返回true. == 不能判断两个没有父子关系的对象。


  equals 是比较两个变量是否包含相同的字符串。Object 中 equals()  在比较两个引用变量时，需要进行重写，按需求进行比较。

 int a =65;
	 float b=65.0f;
	 char c ='A';
	 System.out.println("结果："+(a==b));
	 System.out.println("结果："+(b==c));
	 System.out.println("结果："+(c==a));
	 

	 System.out.println("--------引用类型比较-------------------");
	 String aString = new String("abc"); // 通过 new 创建对象，会生成两个对象，一 存放在栈中的是aString 引用，二是存放在堆中的abc 数据
	 String bString = new String("abc");
	 String cString="abc";//会生成两个对象，一 存放在栈中的是aString 引用，二是存放在堆中的abc 数据
	 System.out.println(aString == bString);  //false
	 System.out.println(aString.equals(bString));//true
	 System.out.println(aString == cString); //false
	 System.out.println(aString.equals(cString));//true

结果：
    结果：true
结果：true
结果：true
--------引用类型比较-------------------
false
true
false
true

提供equals() 方法重写是比较两个引用变量是否相等的标准。在极端的情况下 可以把一个 bird 类 和 dog 类相等。所以在业务中要根据业各的实际情况 重写 equals() 方法。

示例：
package com.soliucheng.domain;

public class Bird {
	 private int age;
	 private String name;
	public Bird(){
     System.out.println("父类构造方法");		
	}
	public Bird(int age,String name){
		this.age=age;
		this.name=name;
				
	}
	public String say(String str){
		System.out.println("父类");
	  return str;
	}
	public void fly(){
		System.out.println("父类飞");
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * 重写 equals() 条件：只要传入的是bird 类且 age 相等，name 相等。 两个对象就相等。
	 */
	@Override
	public boolean equals(Object obj) {
		if(null!=obj && this.getClass() == obj.getClass()){
			Bird bird = (Bird)obj;
			if(bird.getAge()==this.getAge() && bird.getName().equals(this.getName())){
				return true;
			}
			return false;
		}
		return false;
	}

}

测试类：
   package com.soliucheng.domain;

   public  class Ostrich  {
	public static void main(String[] args) {
		Bird birds = new Bird(1,"lili");
		System.out.println(birds.equals("abc"));
		System.out.println(birds.equals(new Ostrich()));
		System.out.println(birds.equals(null));
	}
   
    }

结果：
   false
   false
   false

单例模式（Singleton）： 模式是高于语言的一种经验总结，是技术经典的提升。
   转载地址：http://blog.csdn.net/qjyong/article/details/1721342
  
    1.介绍：也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。
    2.实现单例模式的思路是：一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法（必须是静态方法，通常使用getInstance这个名称）；当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用；同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。
    3.注意事项：单例模式在多线程的应用场合下必须小心使用。如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。 解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。


    4.实现方式：通常单例模式在Java语言中，有两种构建方式：
       饿汉方式:指全局的单例实例在类装载时构建。(一般认为这种方式要更加安全些)
       懒汉方式:指全局的单例实例在第一次被使用时构建。 
   
    5.示例：
    
//------------------------------------------------------------------------------------//
package org.qiujy.test;
//方式一：饿汉式单例模式
public class Singleton1 {
 
 //构造方式设为private,外部不能访问
 private Singleton1() {
 }
 // 在自己内部定义自己的一个private实例,只供内部调用
 private static final Singleton1 instance = new Singleton1();
 // 提供了一个供外部访问本class的静态方法,可以直接访问
 public static Singleton1 getInstance() {
  return instance;
 }
}
//------------------------------------------------------------------------------------//
package org.qiujy.test;
//方式二：懒汉式单例模式
public class Singleton2 {
 
 private static Singleton2 instance = null;
 
 //这个synchronized很重要
 public static synchronized Singleton2 getInstance() {
  // 第一次使用时生成实例
  if (instance == null){
   instance = new Singleton2();
  }
  
  return instance;
 }
}
//------------------------------------------------------------------------------------//
Google公司的工程师Bob Lee写的新的懒汉单例模式
public class Singleton {    
   
  static class SingletonHolder {    
    static Singleton instance = new Singleton();    
  }    
   
  public static Singleton getInstance() {    
    return SingletonHolder.instance;    
  }    
   
} 
  
在加载singleton时并不加载它的内部类SingletonHolder，而在调用getInstance（）时调用SingletonHolder时才加载SingletonHolder，从而调用singleton的构造函数，实例化singleton，从而达到lazy loading的效果。

final 修饰变量的使用方法
  final 可以修饰全局变量和局部变量。全局变量 定义在类中，使用final 修饰。final 修饰的全局变量，系统不会默认赋初值，所以需要在使用这些类变量时，就应该赋初值。
 final 修饰基本类型：
  final 修饰全局变量：
      1. 可以在定义的时候直接赋初值。 2.声明后 使用 代码块赋初值。3.构造方法赋初值。4. 使用 static final 修饰，直接赋初值，或使用静态代码块赋初值
  final 修饰局部变量：
      1.可以在定义的时候直接赋初值。2.声明后，使用前再赋初值。
 final 修饰引用类型：
      final 修饰 引用类型，只保存引用类型引用的变量对象不变，而变量对象的值是可以改变的。

代码如下：
  package com.soliucheng.domain;

public  class Ostrich  {
	private int age;
	public static String RESULT_TRUE;
	final int a =5;
	final static byte ad='A';
	final String str;
	final int c;
	final static double d;
	final char ch;
	{
//		System.out.println(c); 编译错误，系统不会对final 修饰的变量默认初始化 赋初值，所以没赋值的变量，使用时，会报错
		str="abc";
		ch='a';
	}
	static{
		d = 1.23;
	}
	public Ostrich(){
//		str="bcd";  在代码块中 为final str变量赋值后，构造方法不能重新赋值
		c=6;
	}
	public Ostrich(int age){
		this.age=age;
		c=6;  // 每个构造方法 都需要 对未赋值的 变量 进行赋值
	}
	public static void main(String[] args) {
		Ostrich os = new Ostrich();
		System.out.println(os.a);
		System.out.println(Ostrich.ad);
		System.out.println(os.str);
		System.out.println(os.c);
		System.out.println(os.d);
		System.out.println(os.ch);
		
		final String str="abc";
//		str="bc";  final 修饰 局部变量 不能重新进行赋值
		final double d ;
		d=232.1D;  // 定义局部变量 并赋初值
		System.out.println(d);
		// 引用类型
		final Ostrich os2 = new Ostrich(10); // final 修饰 引用类型变量，只保存引用变量的引用的对象不改变，但是对象值是可以改变的
		os2.setAge(50);
		System.out.println(os2.getAge()); // 50
		
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
   
}
 结果：
  65
 abc
 6
 1.23
 a
 232.1
 50

final 修饰方法：
  final 修饰方法称为最终方法，不可被重写，为了在继承时，子类重写父类的方法时，可以把父类的方法定义成 final.方法一般是对外公开的所以定义成public .如果定义成 private final .这就成了类的私有方法，所以，不存在可重写的问题。

代码：
public  class Ostrich  {
	public final void test(){
		System.out.println("final 方法");
	}
	public final void test(String str){
		System.out.println(str);
	}

}

class subOstrich extends  Ostrich{
 	public  void test(){
 		System.out.println("final 方法");
 	}
}

子类 不能重写父类定义的final 方法。编译出错。 final 方法依然 可以重载。

缓存对象：当一个对象重复使用时，不断的创建新对象会相当的耗费资源，所以，有必要把这个对象缓存起来。类似于java.long.Integer.的做法。

代码如下：
package com.soliucheng.domain;
/**
 * 缓存对象
 * @author Administrator
 *
 */
public  class CacheObject  {
	private final String name;
	private static CacheObject [] cache = new CacheObject[5];// 缓存10 个对象 
	private static int pos=0;// 位置
	public CacheObject(String name){
      this.name=name;
	}
    public static CacheObject valueOf(String name){
    	for(int i=0;i<5;i++){
    		
    		if(cache[i]!=null && cache[i].getName().equals(name)){
    			return cache[i];
    		}
    	}
    	if(pos == 5){
    		cache[0]= new  CacheObject(name);
    		pos=1;
    		return cache[0];
    	}else{
    		cache[pos++] = new CacheObject(name);
    		return cache[pos-1];
    	}
    }
	
	public static void main(String[] args) {
		CacheObject obj1 =  CacheObject.valueOf("abc");
		CacheObject obj2 =  CacheObject.valueOf("abc");
		System.out.println( obj1 == obj2);
		// 在Integer 中做了缓存，缓存的大小是 -127到128
		Integer i =129;
		Integer j = 129;
		System.out.println(i == j);  // false
		Integer a=1;
		Integer b=1;
		Integer c=Integer.valueOf(8);
		Integer d=Integer.valueOf(8);
		System.out.println(a == b);// false
		System.out.println(c == d);// true
	}

	public String getName() {
		return name;
	}
	@Override
    public boolean equals(Object obj){
    	if(null!=obj && obj.getClass()== this.getClass()){
    		CacheObject cache=	(CacheObject)obj;
    		if(cache.getName().equals(this.getName())){
    			return true;
    		}
    	}
    	return false;
    }
	@Override
	 public int hashCode(){
		 return this.name.hashCode();
	 }
	 
   
}
 
结果：
true
false
true
true

抽象类和抽象方法的使用： abstract 修饰的方法叫抽象方法，有抽象方法的类，一定要写成抽象类，抽象类中，可以有普通方法，抽象方法，只能有方法的定义，而不能有方法的实现，抽象类不能实例化，所以，抽象类要被继承，子类实现父类定义的所部抽象方法，如果子类不实现全部的抽象方法，那么子类需要定义成抽象类。

代码如下：
  package com.soliucheng.domain;

 // 定义一个抽象类
 abstract class Aminal {
	private String name; // 可以定义属性
    public Aminal(String name){ //可以定义构造方法，构造方法不能被继承，但可以子类调用
    	this.name=name;
    }
	public abstract String say();// 定义了抽象方法 所以类一定要定义成抽象类

	public void say(String str) { // 可以定义变通方法
		System.out.println(str);
		String result = say(); // 普通方法中 可以调用抽象方法
		System.out.println(result);
	}

	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}
 // 子类 实现抽象类
 public class Dog extends Aminal{
   private int age;
	public Dog(String name,int age) {
		super(name);
		this.age=age;
		 
	}

	@Override
	public String say() {
		 
		return "dog wang wang";
	}
	public static void main(String[] args) {
		Dog dog = new Dog("TOM",2);
		dog.say("abc");
	}
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}


结果:
   abc
   dog wang wang

接口的定义和使用：
   接口使用interface 定义 ，格式 访问修饰符 interface InterFaceName{} 。 接口用来定义对外提供的服务，只定义服务(模版)，而没有实现。
接口中只能声明方法，而没有实现体。
不能定义普通方法。
不能定义构造方法
可以定义全局变量，默认是 public static final 
接口可以继承多个接口，类可以实现多个接口,接口接用 , 分开。
类实现接口，使用关键字 implements .

代码如下：
package com.soliucheng.domain;


public interface Dog extends A, B { // 接口 继承接口
	// public Dog(){} 不能声明构造方法


	// 不能定义普通方法
	// public void run(String str){
	//
	// }
	// public static void eat();// 不能定义静态方法
	public static final String RESULT = "1";// 定义全局变量 String RESULT="1";


	void run();//


	public void say(String str);
}


interface A {
	public String say();
}


interface B {


}


// 子类实现接口
class BigDog implements Dog {


	@Override
	public String say() {
		return null;
	}


	@Override
	public void say(String str) {


	}


	@Override
	public void run() {
		// TODO Auto-generated method stub


	}


}

 public class A // 外部类


 public class B{} // 内部类
}


内部类进一步实现了封装，只需要很少使用时，可以定义成内部类。
非静态类 
  代码如下：
 package com.soliucheng.domain;


public class OutClass { 
   
private int weight=400;// 重量

public class InnerClass{
private int weight=200;
private int hight;
private String colour;
public InnerClass(){  }
public InnerClass(int hight,String colour){
this.hight= hight;
this.colour=colour;
}
  {
System.out.println("普通的初始化块");
}
  private void info(){
int weight=100;
   System.out.println("腿高度："+hight);
System.out.println("腿颜色："+colour);


System.out.println("外部类的属性："+OutClass.this.weight); 
System.out.println("内部类的属性："+this.weight);
System.out.println("局部变量:"+weight);
  }
}
public void test(){
InnerClass inner = new InnerClass(10,"bleak");
inner.info();
}
public static void main(String[] args) {
OutClass out = new OutClass();
out.test();

// InnerClass inner = new InnerClass(); 编译报错，静态方法不能访问非静态成员
}
}


静态类 
  代码如下：
   
 package com.soliucheng.domain;


public class OutClass { 
   
private int weight=400;// 重量
private static String name= "cow";
static public class InnerClass{
private int weight=200;
private int hight;
private String colour;
private static int age=1;
public InnerClass(){  }
public InnerClass(int hight,String colour){
this.hight= hight;
this.colour=colour;
}
  {
System.out.println("普通的初始化块");
}
  private void info(){
int weight=100;
   System.out.println("腿高度："+hight);
System.out.println("腿颜色："+colour);

//
System.out.println(OutClass.name); // 静态内部普通方法 可以访问外部类的静态方法，不能访问普通方法
// System.out.println("外部类的属性："+OutClass.this.weight); 
System.out.println("内部类的属性："+this.weight);
System.out.println("局部变量:"+weight);
  }
  private static void message(){
  System.out.println("牛的年龄："+age);
//   System.out.println("腿高度："+hight);//编译报错，内部类的静态方法 不能访问内部类的普通属性
  System.out.println(OutClass.name); //可以访问外部在的静态属性 不能访问外部类的普通属性
  }
}
public void test(){
InnerClass inner = new InnerClass(10,"bleak");
inner.info();
InnerClass.message();
}
public static void main(String[] args) {
OutClass out = new OutClass();
out.test();

// InnerClass inner = new InnerClass(); 编译报错，静态方法不能访问非静态成员
}
}


enum 枚举类型的使用


GC 垃圾回收机制


抽象类和接口的区别：


  共同点：只是声明方法，而没有实现。都外于继承的最顶端都需要子类去实现类父或接口的声明方法。都不能实例化。
  区别：   抽象类                         接口不可以


           可以定义普通方法               不可以定义普通方法
           可以定义构造方法，由子类调用   不可以定义构造方法
           可以定义代码块                 不可以定义代码块
           可以定义普通属性               不可以定义普通属性      
           一个类子能继承一个父           一个类可以实现多个接口




内部类：在一个类中，声明了另外的一个类，声明在类内部的类叫内部类，内部类外边的类是外部类。

 public class A // 外部类

 public class B{} // 内部类
}

内部类进一步实现了封装，只需要很少使用时，可以定义成内部类。
非静态类 
  代码如下：
 package com.soliucheng.domain;

public class OutClass { 
   
	private int weight=400;// 重量
	
	public class InnerClass{
		private int weight=200;
		private int hight;
		private String colour;
		public InnerClass(){  }
		public InnerClass(int hight,String colour){
			this.hight= hight;
			this.colour=colour;
		}
	   {
			System.out.println("普通的初始化块");
		}
	   private void info(){
			int weight=100;
		    System.out.println("腿高度："+hight);
			System.out.println("腿颜色："+colour);
			
			
			System.out.println("外部类的属性："+OutClass.this.weight); 
			System.out.println("内部类的属性："+this.weight);
			System.out.println("局部变量:"+weight);
	   }
	}
	public void test(){
		InnerClass inner = new InnerClass(10,"bleak");
		inner.info();
	}
	public static void main(String[] args) {
		OutClass out = new OutClass();
		out.test();
		
//		InnerClass inner = new InnerClass(); 编译报错，静态方法不能访问非静态成员
	}
}

静态类 
  代码如下：
   
 package com.soliucheng.domain;

public class OutClass { 
   
	private int weight=400;// 重量
	private static String name= "cow";
	static public class InnerClass{
		private int weight=200;
		private int hight;
		private String colour;
		private static int age=1;
		public InnerClass(){  }
		public InnerClass(int hight,String colour){
			this.hight= hight;
			this.colour=colour;
		}
	   {
			System.out.println("普通的初始化块");
		}
	   private void info(){
			int weight=100;
		    System.out.println("腿高度："+hight);
			System.out.println("腿颜色："+colour);
			
//			
			System.out.println(OutClass.name); // 静态内部普通方法 可以访问外部类的静态方法，不能访问普通方法
//			System.out.println("外部类的属性："+OutClass.this.weight); 
			System.out.println("内部类的属性："+this.weight);
			System.out.println("局部变量:"+weight);
	   }
	   private static void message(){
		   System.out.println("牛的年龄："+age);
//		   System.out.println("腿高度："+hight);//编译报错，内部类的静态方法 不能访问内部类的普通属性
		   System.out.println(OutClass.name); //可以访问外部在的静态属性 不能访问外部类的普通属性
	   }
	}
	public void test(){
		InnerClass inner = new InnerClass(10,"bleak");
		inner.info();
		InnerClass.message();
	}
	public static void main(String[] args) {
		OutClass out = new OutClass();
		out.test();
		
//		InnerClass inner = new InnerClass(); 编译报错，静态方法不能访问非静态成员
	}
}

enum 枚举类型的使用

GC 垃圾回收机制