java基礎<基礎知識整理>

對象的初始化過程

一、對象進行new以後的內存發生了那些事情

對象調用成員過程

一、對象條用成員過程

單例設計模式

一、代碼

解決一個類在內存中只存在一個對象

1.禁止其他程序建立該類對象。

2.要在本類中自定義一個對象。

3.對外提供一些訪問方式

餓漢式（一般用這個，因爲比較安全）

class Single
{
	private Single(){}

	private static Single p=new Single();
	
	public static Single getInstance()
	{
			return p;
	}

}

懶漢式（線程不安全，可以加入synchronized關鍵字，但是效率過低）

class Single
{
	private Single(){}

	private static Single p=null;
	
	public static /*synchronized */Single getInstance()
	{
			if(p==null)
				p=new Single();
			return p;
	}

}

繼承（概述）

一、概述

繼承：
1.提高了代碼的複用性。
2.讓類與類之間產生了關係，有了這個關係，纔有了多態的特性
3.java語言中只支持單繼承(因爲多繼承容易帶來安全隱患。當多個類中定義了
相同功能，當功能內容不同時，子類對象不確定要運行哪一個.)
但是java保留了多繼承的機制，並用另一種體現形式來完成，即多實現。
4.查閱父類功能，創建子類對象使用功能。

注意：千萬不要爲了獲取其他類的功能，簡化代碼而繼承。
必須是類與類之間有所屬關係纔可以繼承。

二、代碼

將學生和工人的共性描述提取出來，單獨進行描述，
只要讓學生和工人與單獨描述的這個類有關係就可以了。

class Person 
{
	String name;
	int age

}

class Student extends Person
{
	//String name;
	//int age=;
	void study()
	{
		System.out.println("good study");	
	}
}

class Worker extends Person
{
	//String name;
	//int age=;
	void study()
	{
		System.out.println("good work");	
	}
}

子父類中的變量、方法和構造方法的關係

一、變量的特點

如果子類中出現非私有的同名成員變量時，
子類要訪問本類中的變量，用this
子類要訪問父類中的同名變量，用super
super的使用和this的使用幾乎一致。

二、方法的特點

當子類出現和父類一模一樣的函數時，
當子類對象調用該函數，會運行子類函數的內容。
如同父類的函數被覆蓋一樣。(父類的函數依然存在於內存中，只不過沒有運行）
這種情況是函數的另一個特性：重寫（覆蓋）

覆蓋：
1.子類覆蓋父類，必須保證子類權限大於等於父類權限。
2. 靜態只能覆蓋靜態。

注意：重寫與重載不同。 

三、構造方法的特點

1.在對子類對象進行初始化時，父類的構造函數也會運行，
那是因爲子類的構造函數默認第一行有一條隱式的語句super()
super():會訪問父類中空參數的構造函數。而且子類中所有的構造函數第一行都是super()

2.爲什麼子類一定要訪問父類中的構造函數？
因爲父類中的數據子類可以直接獲取，所以子類對象在建立時，需要先查看父類是如何對這些數據進行初始化的。
所以子類在對象初始化時，要先訪問以下父類中的構造函數。
如果要訪問父類中指定的構造函數，可以通過手動定義super語句的方式來指定。

注意：super語句一定定義在子類構造函數的第一行。子類的構造函數的第一行也可以用子類的構造函數來代替
父類的構造函數，但是這並不影響對父類變量進行賦值，因爲子類的構造函數中總會有一個調用父類的構造函數

四、需要能夠理解的代碼

class Person
{
	private String name;
	Person(String name)
	{
		this.name=name;
	}
	void show(){}
}

class Student extends Person
{
	Student(String name)
	{
		//super.name=name;
		super(name);
	}
	void method()
	{
		super.show();
	}
}

用以幫助理解以上代碼的例子

class Person
{
	String name="zhangsan";
	Person(){};
	Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
}

class Student extends Person
{
	String name;
	Student(String name)
	{
		super(name);
	}
	/*public String getName()
	{
		return name;
	}
	*/

}

class  ExtendsDemo5
{
	public static void main(String[] args) 
	{
		Student s=new Student("wqz");
		String name=s.getName();
		String name2=s.name;
		System.out.println(name);//返回wqz
		System.out.println(name2);//返回null
	}
}

final關鍵字

一、概述

1.可以修飾類

被final修飾的類，不可以被繼承。（爲了避免被繼承，被子類複寫功能。）

2.可以修飾方法

被final修飾的方法，不可以被重寫

3.可以修飾變量

被final修飾的變量是一個常量，只能賦值一次。既可以修飾成員變量，又可以修飾局部變量。只要這個

模板方法模式

一、代碼

什麼是模板方法？

答：在定義功能時，功能的一部分是確定的，但是有一部分是不確定的，而確定的部分在使用不確定的部分，那麼這時就將不確定的部分暴露出去，由該類的子類去完成。

abstract class GetTime
{
	public final void getTime()
	{
		long start =System.currentTimeMillis();
		runCode();
		long end =System.currentTimeMillis();
		System.out.println("毫秒："+(end-start));
	}


	public abstract void runCode();

}

class SubTime extends GetTime
{
	public void runcode()
	{		
		for(int x=0;x<100;x++)
		{
			System.out.print("x");
		}	
	}
}


class  TemplateDemo
{
	public static void main(String[] args) 
	{
		SubTime st=new SubTime();
		st.getTime();
	}
}

接口

一、格式

1. interface 接口名字

{

public static final int NUM=3;

public abstract void show();

}

2. 接口中常見定義：常量，抽象方法。

接口裏面的常量和抽象方法都有固定的修飾符

常量：public static final 

方法：public abstract

3. class Test    (extends Demo)   implements 接口名字1，接口名字2

{

}

4.接口與接口之間是繼承關係

interface A

{}

interface B extends A

{}

interface Inter
{
	public static final NUM=3;
	public abstract void show();
}

class Test implements Inter
{
	public void show(){}
}

class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t=new Test();
		System.out.println(t.NUM);
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);
	}
}

二、接口的特點

1.接口是對外暴露的規則。

2.接口是程序的功能擴展。

3.接口可以用來多實現

4.類與接口之間是實現關係，而且類可以繼承一個類的同時實現多個接口。

5.接口與接口之間可以有繼承關係

三、接口舉例體現

abstract class Student
{
	abstract void study();

	void sleep()
	{
		System.out.println("sleep");
	}
}

interface Smoking
{
	void smoke();
}

class ZhangSan extends Student implements Smoking
{
	void study(){};
	public void smoke(){};
}

class Lisi extends Student
{
	void study(){};
}


class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

Object類

一、概述

Object:是所有對象的直接後者的間接父類，傳說中的上帝。
該類中定義的成員，是所有對象都具備的。

二、代碼(equals()方法)

class Person
{
}

class Demo
{
}


class Demo1
{
	private int num;
	Demo1(int num)
	{
		this.num=num;
	}
	public boolean equals(Object obj)
	{
		if(obj instanceof Demo1)
		{
		Demo1 d=(Demo1)obj;
		return this.num==d.num;
		}
		else
			return false;
	}
}

class ObjectDemo
{
	public static void main(String[] args) 
	{
		Demo d1=new Demo();
		Demo d2=new Demo();
		Demo d3=d1;
		Demo1 d4=new Demo1(4);
		Demo1 d5=new Demo1(4);
		Demo1 d6=new Demo1(5);

		Person p=new Person();

		System.out.println(d1.equals(d2));//false
		System.out.println(d1.equals(d3));//true
		System.out.println(d1==d2);//false
		System.out.println(d1==d3);//true	
		System.out.println(d4.equals(d5));//返回true
		System.out.println(d4.equals(d6));//返回false
		System.out.println(d4.equals(p));//返回false


		//其實,equals()方法比較的就是————地址。
	}
}

三、代碼（toSting()方法）

public String toString()
{
	return getClass().getName() + '@' + Integer.toHexString(hashCode());
}

包與包之間訪問

一、會出現的問題

①PackageDemo.java:6: 錯誤: 找不到符號
                DemoA a=new DemoA();
                ^
  符號:   類 DemoA
  位置: 類 PackageDemo
PackageDemo.java:6: 錯誤: 找不到符號
                DemoA a=new DemoA();
                            ^
  符號:   類 DemoA
  位置: 類 PackageDemo


錯誤原因：類名寫錯。因爲類名的全名是：報名.類名

②PackageDemo.java:6: 錯誤: 程序包packa不存在
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 錯誤: 程序包packa不存在
                packa.DemoA a=new packa.DemoA();
 
錯誤原因：packa包不在當前目錄下，需要設置classpath,告訴jvm去哪裏找指定的packa包


③PackageDemo.java:6: 錯誤: DemoA在packa中不是公共的; 無法從外部程序包中對其進行訪
問
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 錯誤: DemoA在packa中不是公共的; 無法從外部程序包中對其進行訪
問
                packa.DemoA a=new packa.DemoA();
                                       

錯誤原因：有了包範圍變大，一個包中的類要被訪問，必須要有足夠大的權限，所以被訪問的類要被public修飾



④PackageDemo.java:6: 錯誤: DemoA在packa中不是公共的; 無法從外部程序包中對其進行訪
問
                packa.DemoA a=new packa.DemoA();
                     ^
PackageDemo.java:6: 錯誤: DemoA在packa中不是公共的; 無法從外部程序包中對其進行訪
問
                packa.DemoA a=new packa.DemoA();


錯誤原因：類共有後，被訪問的成員也要公有，纔可以被訪問。



總結：
①包與包之間進行訪問，被訪問的包中的類以及類中的成員，需要public修飾

②不同包中的子類，還可以直接訪問父類中被protected修飾的成員

二、訪問權限

包與包之間可以使用的權限只有兩種，public和protected

public      protected       defalut      private 
同一個類中 ok ok ok ok
同一個包中 ok ok ok
子類 ok ok
不同包中 ok

三、其他注意事項

一個java文件中，不可以出現兩個以上的公有類、或者接口，因爲一個類被public修飾後，該java文件的名字必須與該類的名字一致，如果出現兩個以上的public類，無法明確該文件的名字與哪個類的名字一致。

基本數據類型——對象包裝類

一、概述

基本數據類型對象包裝類

byte	Byte
*int	Integer
short	Short
long	Long
boolean Boolean
float	Float
double	Double
*char	Character

基本數據類型對象包裝類，
1.最常見的作用————用於基本數據類型和字符串類型之間做轉換

1.1基本數據類型轉成字符串
	基本數據類型+""
	基本數據類型包裝類.toString(基本數據類型值)
	如：Integer.toString(34);將34整數編程"34"

1.2字符串轉成基本數據類型
	xxx a=Xxx.parseXxx(String)
	如：int a=Integer.parseInt("123");
	如果int a=Integer.parseInt("a123");會報數字格式異常。

	Integer i=new Integer("123");
	int num=i.intValue();

2.十進制與其他進制進行轉換

2.1 十進制轉成其他進制
	二進制：toBinaryString();
	十六進制：toHexString();
	八進制:toOctalString();

2.2 其他進制轉成十進制
	parseInt(String,radix);
	例：Integer.parseIn("110",10)

基本數據類型——對象包裝類新特性

class  
{
	public static void main(String[] args) 
	{
		Integer x=4;//JDK1.5以後新特性————自動裝箱。即自動完成了new Integer(4);
		x=x+2;//自動拆箱，變成了int類型，所以能和2進行數學運算。再將所得和，進行裝箱賦給x.自動拆箱，實際上是進行了x.intValue()操作。

		

	}

	public static void method()
	{
		Integer x=new Integer("123");
		Integer y=new Integer(123);

		System.out.println(x==y);//false
		System.out.println(x.equals(y));//true
	}


	public static void method1()
	{
		Integer m=128;
		Integer n=128;
		System.out.println(m==n);//false
		Integer a=127;
		Integer b=127;
		System.out.println(a==b);//true
		//因爲數值在byte（-128,127）範圍內，對於新特性，如果該數已經存在，則不會開闢新空間。
	}
}