java基礎的詳細瞭解第九天

Posted on 2021-08-10 by WalkonNet

1、匿名內部類

內部類：在一個類的內部定義瞭另外的類，稱為內部類，匿名內部類指的是沒有名字的內部類。為瞭清楚內部類的主要作用，下面首先觀察一個代碼。

interface IMessage{
	public void print();
}
class MessageImpl implements IMessage{//定義接口實現類
	public void print(){
		System.out.println("Hello World");
	}
}
class Demo{
	public static void get(IMessage msg){//接受接口對象
		msg.print();
	}
}
public class TestDemo1{
	public static void main(String args[]){
		IMessage msg = new MessageImpl();//子類為接口實例化
		Demo.get(msg);//傳遞msg對象
	}
}

如果說現在MessageImpl這個子類隻使用一次，有必要按照以上的方式進行定義嗎？

這個時候MessageImpl就沒有什麼意義瞭，但是可以利用匿名內部類的概念來解決此問題。匿名內部類是在抽象累和接口的基礎之上發展起來的。

interface IMessage{
	public void print();
}
class Demo{
	public static void get(IMessage msg){//接受接口對象
		msg.print();
	}
}
public class TestDemo1{
	public static void main(String args[]){
		IMessage msg = new IMessage(){//匿名內部類
			public void print(){
				System.out.println("hello,world!");
			}
		};
		Demo.get(msg);//傳遞msg對象
	}
}

結論：基本上搞匿名內部類都應該在接口或抽象類形式上完成。

在抽象類中使用匿名內部類

abstract class Message{
	public void print(){
		System.out.print(this.getInfo());
	}
	public abstract String getInfo();
}
class Demo{
	public static void get(Message msg){//接受接口對象
		msg.print();
	}
}
public class TestDemo1{
	public static void main(String args[]){
		Demo.get(new Message(){
			public String getInfo(){
				return "www.baidu.com";
			}
		});//傳遞msg對象
	}
}

強調：一個普通類進行不要再去有子類進行繼承，能夠繼承的隻是抽象類和接口，所以在普通類上繼續使用

匿名內部類的形式來定義子類，但是在正常的開發邏輯上是錯誤的。

2、Object類簡介

在Java的定義之中，除瞭Object類之外，所有的類實際上都存在繼承關系，即：如果現在定義瞭一個類，沒有默認繼承任何一個父類的話，則默認講繼承Object類，以下兩種類最終定義效果是完全一樣的。

Object類的無參構造是專門子類提供服務的。

方法名稱	類型	描述
public String toString()	普通	取得對象信息
public boolean equals(Object obj)	普通	對象的比較
public int hashCode()	普通	返回對象的哈希碼值

2.1 取得對象信息toString()

toString()的核心目的在於取得對象信息。相當於替換瞭getInfo()方法的功能。

class Person{
	private String name;
	private int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return "name = " + this.name + ",age = " + this.age ;
	}
}
public class TestDemo2{
	public static void main(String args[]){
		Person p = new Person("zsr",18);
		System.out.print(p.toString());
	}
}

2.2 對象的比較equals()

實際上對於equals()方法應該並不陌生，這個方法在String類中見過，String是Object類的子類，所以String類的equals()方法就是覆寫瞭Object類中的equals()方法，在Object類之中，默認的equals()方法實現比較的是兩個對象的內存地址數值，但是並不符合與真正的對象比較需要。對象比較之前也寫過，但是之前那是自己定義的一個新的方法名稱，今天可以給出標準的方法名稱：equals()。

class Person{
	private String name;
	private int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object anObject){
		if(anObject == null){
			return false;
		}
		if(this == anObject){
			return true;
		}
		//判斷anObject的實例是不是Person
		if( !(anObject instanceof Person)){
			return false;
		}
		//必須將Object類型變為Person類型後才可以調用name和age屬性
		Person per = (Person) anObject;
		return this.name.equals(per.name) && this.age == per.age;
	}
	public String toString(){//覆寫Object類方法
		return "name = " + this.name + ",age = " + this.age ;
	}
}
public class TestDemo3{
	public static void main(String args[]){
		Person per1 = new Person("zsr",18);
		Person per2 = new Person("zsr",18);
		//true
		System.out.println(per1.equals(per2));
		//false
		System.out.println(per1.equals("Hello,world!"));
	}
}

但是需要有一個註意，很多人在寫對象的比較會使用如下的形式：

public boolean equals(Person anObject)

因為父類中的equals()方法用的是Object，所以以上的方法嚴格來講已經不叫覆寫，叫重載。

2.3 Object接口引用數據類型

在之前的分析來講Object可以接收任意的對象，從結構上來講Object是所有類的父類，但是Object概念並不僅僅局限於此，他已接收所有的引用數據類型，包括：接口、數組。

使用Object類接收數組，數組和Object沒有任何明確的關系。

public class TestDemo4{
	public static void main(String args[]){
		Object obj = new int []{1,3,4};
		int data [] = (int [])obj;//向下轉型
		for(int i = 0 ;i < data.length ; i++){
			System.out.println(data[i]);
		}
	}
}

接收接口對象，從接口的定義而言，它是不能去繼承一個父類的，但是由於接口依然屬於引用類型，所以即使沒有繼承類，也可以使用Object接收。

interface Message{}
class MessageImpl implements Message{//定義接口子類
	public String toString(){
		return "Hello World";
	}
}
public class TestDemo5{
	public static void main(String args[]){
		Message msg = new MessageImpl();//向上轉型
		Object obj = msg;//向上轉型
		Message temp = (Message) obj;//向下轉型
		System.out.println(temp);//toString()
	}
}

從代碼上講，以上隻能算是一個固定的操作概念，不過從實際來講，因為有瞭Obejct類的出現，所有的操作就可以達到統一，那麼之前的鏈表程序，就應該變得很方便瞭。所有的數據都使用Object接收，所有的對象比較（刪除、查找）都可以使用equals()。

3、包裝類

在Java的設計之中，一直倡導一個原則：一切皆對象，這個原則本省有一個漏洞，基本數據類型不是對象，所以這個原則就出現瞭問題，那麼如果說現在這個問題由我們來解決，該如何解決呢？

class MyInt{
	private int num;//基本類
	public MyInt(int num){
		this.num=num;
	}
	public int intValue(){
		return this.num;
	}
}
public class TestDemo6{
	public static void main(String args[]){
		Object obj = new MyInt(10);//子類自動變為Object父類對象
		MyInt temp = (MyInt) obj;//向下轉型
		int result = temp.intValue();
		System.out.println(result*result);
	}
}

以上的操作是將基本類型變為瞭一個對象的形式進行操作瞭，但是這裡面有一個問題：基本數值型數據是可以進行數學運算的，可是以上變為瞭類的形式，那麼肯定無法直接計算瞭。以上的問題既然我們都想到方法解決，那麼Java也一定早已解決，為此它專門提供瞭八種包裝類：

byte(Byte),short(Short),int(Integer),long(Long),float(Float),double(Double),boolean(Boolean),char(Character);

而這八種包裝類有分為兩大陣營：

數值型（Number子類）：Byte,Short,Integer(int),Float,Double,Long;

對象型（Object子類）：Boolean,Character(char)。

可是對於Number的子類，就必須觀察出Number類之中定義的方法：byteVlue()、intVlue()、doubleVlue()、shortVlue()、longVlue()、floatVlue()，就是從包裝的類之中取得所包裝的數值。

3.1 裝箱與拆箱

在基本數據類型和包裝類之間的轉化之中分為兩個重要概念：

裝箱操作：將基本數據類型變為包裝類，稱為裝箱，包裝類的構造方法。

拆箱操作：將包裝類變為基本數據類型，稱為拆箱，Number類中的xxValue()方法。

以int和Integer為例

public class TestDemo{
	public static void main(String args[]){
		Integer var = new Integer(10);//裝箱
		int result = var.intValue();//拆箱
		System.out.println(result*result);
	}
}

以double和Double為例

public class TestDemo{
	public static void main(String args[]){
		Double var = new Double(10.0);//裝箱
		double result = var.doubleValue();//拆箱
		System.out.println(result*result);
	}
}

以上的操作實在JDK1.5之前所進行的必須的操作，但是到瞭JDK1.5之後，Java提供瞭自動裝箱和自動拆箱的機制，並且包裝類的對象可以自動的進行數學計算瞭。

自動裝箱與拆箱

public class TestDemo{
	public static void main(String args[]){
		Integer var = 10;//自動裝箱
		int result = var;//自動拆箱
        //可以直接利用包裝類進行對象操作
		System.out.println(++var*result);//自動進行數學運算
	}
}

但是到此為止還有一個小問題，實際上這一問題之前已經見過。

public class TestDemo{
	public static void main(String args[]){
		Integer x = new Integer(10);//新空間
		Integer y = 10;//入池
		Integer z = 10;
		System.out.println(x==y);//false
		System.out.println(x==z);//false
		System.out.println(y==z);//ture
		System.out.println(x.equals(y));//ture
	}
}

使用包裝類的時候還需要考慮equals()和==的區別。

使用int還是Integer?

在接收數據的時候，使用的一定都是int，而保存數據的時候一般使用Integer
以後編寫的簡單java類統一不要再去使用基本數據類型，全部換位包裝類

3.2 字符串與基本數據類型的轉換

包裝類之中所提供的最大優點在於可以講字符串變為制定的基本數據類型，下面列出幾個操作：

Integer類：public static int parseInt(String s);

Double類：public static double parseDouble(String s);

Boolean類：public static boolean parseboolean(String s;

但是character這個包裝類之中，並沒有提供一個類似的parseCharacter()，因為字符串String類之中提供瞭一個charAt()方法，可以取得制定索引的字符，而且一個字符的長度就是一位。

將字符串變為int

public class TestDemo{
	public static void main(String args[]){
		String str = "16";
		int result = Integer.parseInt(str);//String ——>int
		System.out.println(result*result);
	}
}

但是需要提醒的是，在執行這種轉化的操作過程之中，字符串字符串中的全部內容必須由數字所組成，如果有一位內容不是數字，則在轉化的過程之中講出現如下的錯誤提示：NumbnerFormatException。

將字符串變為double

public class TestDemo{
	public static void main(String args[]){
		String str = "16.";
		double result = Double.parsedouble(str);//String ——>int
		System.out.println(result*result);
	}
}

將字符串變為boolean型數據

public class TestDemo{
	public static void main(String args[]){
		String str = "true";
		boolean result = Boolean.parseboolean(str);//String ——>int
		System.out.println(result);
	}
}

提示：在使用Boolean型包裝類的時候，如果字符串之中的內容不是true或者是false，統一都按照false處理。

以上的操作是通過字符串變為一些基本類型的數據，但是反過來講，基本數據類型如何變為字符串呢？

方式一：任何基本數據類型遇到瞭String之後都會變為String型數據；

public class TestDemo{
	public static void main(String args[]){
		int num = 100;
		String str = num+"";//int——>String //會產生垃圾
		System.out.println(str.length());
	}
}
//會有垃圾產生

方式二：利用String方法，public static String valueOf(數據類型 b)

public class BaoZhuangLei{
	public static void main(String args[]){
		int num = 100;
		String str =String.valueOf(num);//int——>String
		System.out.println(str.length());
	}
}

3.3 包的定義

在Java程序之中的包，主要的目的是可以將不同功能的文件進行分割，在之前的代碼開發之中，所有的程序都保存在瞭同一個目錄之中，這樣一來所帶來的問題：如果出現瞭同名的文件，那麼會發生覆蓋問題，因為在同一個目錄之中不允許有重名的文件，而在不同的目錄下可以有重名文件，所謂的包實際上指的就是文件夾。

package cn.mldn.demo;//定義包
public class Hello{
	public static void main(String args[]){
		System.out.println("Hello World");
	}
}

一旦定義完成之後，那麼這個類的名字就成瞭“cn.mldn.demo.Hello”，即這既是完整的類名稱，而在進行程序編譯的時候也需要將*.class文件保存在包之中，於是為瞭方便開發，那麼也就提供瞭一個打包的編譯操作。

打包編譯：javac -d . 類.java

-d:表示生成目錄，根據package定義生成

-“.”:再當前目錄下生成*.class

類.java:編譯源程序代碼

這個時候類的名字必須帶上包的名稱，所以執行類的時候：java cn.mldn.demo.Hello，也就是說完整類的名稱就是“包.類”，而在所有的開發之中，沒有包的類是絕對不存在的，隻要是程序一定要有包。

3.4 包的導入

既然使用包可以將一個大型的程序拆分成不同的功能目錄保存，那麼這些不同的包之間也一定會存在包的導入問題，而導入包在程序之中使用import完成，下面通過一個程序進行演示。

//定義一個Message
package cn.mldn.util;//打包
class Massage{
	public String print(){
		return "Hello World";
	}
}

//定義另外一個類使用Message類
package cn.mldn.text;//打包
import cn.mldn.util.Message;//導入包
public class Text{
	public static void main(String args[]){
		Massage msg = new cn.mldn.util.Massage();
		System.out.println(msg.print());
	}
}

這個時候上面的兩個類應該是按照順序編譯：

應該首先編譯Message.java程序：javac –d . Message.java;

再次編譯Test.java程序：javac –d . Test.java，但是這個時候出現瞭一下的錯誤提示：

Text.java:5: 錯誤: Massage在cn.mldn.util中不是公共的; 無法從外部程序包中對其進行
訪問
                Massage msg = new cn.mldn.util.Massage();
                ^

提示：關於public class 和class定義類的區別

 Public class：文件名和類名稱保持一致，在一個*.java文件之中隻能存在一個public class定義，如果一個類要想被外部包所訪問必須定義為public；

 Class：文件名稱可以和類名稱不一致，在一個*.java之中可以同事存在多個class定義，並且編譯完成之後會形成多個*.class文件，使用class定義的類隻能夠在一個包中訪問，不同包之間無法訪問。

package cn.mldn.util;//打包
public class Massage{
	public String print(){
		return "Hello World";
	}
}

但是同時也發現瞭一個問題，現在這些類在編譯的時候要有順序，實在很麻煩，為此在java之中專門提供瞭一個可以進行自動連編的操作，編譯的時候使用*.java：javac –d . .java，將一個目錄之中所有的.java文件進行編譯。

但是以上的代碼還有一個小問題：程序在進行導入的時候使用瞭“包.類”的完整名稱完成的，但是如果在一個程序之中要同時導入一個包的多個類的時候，那麼分開去編寫實在很麻煩，為此可以使用通配符“*”完成導入。

package cn.mldn.text;//打包
import cn.mldn.util.*;//導入包
public class Text{
	public static void main(String args[]){
		Massage msg = new cn.mldn.util.Massage();
		System.out.println(msg.print());
	}
}

但是需要註意的是，在java之中使用“”或者是的單獨導入，其從實際的操作性能上是沒有任何區別的，因為即使使用瞭也表示導入所需要的類，不需要的不導入。

可是在導入包的時候也會遇到一種比較麻煩的問題：會導入不同包的同名類，例如：對於Message類，現在在兩個包中都有：cn.mldn.util cn.mldn.info

package cn.mldn.text;//打包
import cn.mldn.util.*;//導入包
import cn.mldn.info.*;//導入包
public class Text{
	public static void main(String args[]){
		Message msg = new cn.mldn.util.Message();
		System.out.println(msg.print());
	}
}
/*
Text.java:6: 錯誤: 對Message的引用不明確, cn.mldn.info中的類 cn.mldn.info.Messag
e和cn.mldn.util中的類 cn.mldn.util.Message都匹配
                Message msg = new cn.mldn.util.Message();
                ^
*/

由於某種需要，同時導入兩個包，這個時候要使用Message類的時候必須加上類的全名。

package cn.mldn.text;//打包
import cn.mldn.util.*;//導入包
import cn.mldn.info.*;//導入包
public class Text{
	public static void main(String args[]){
		cn.mldn.util.Message msg = new cn.mldn.util.Message();
		System.out.println(msg.print());
	}
}

4、訪問控制權限

之前學習到的private就屬於一種訪問控制權限，而這種訪問控制權限隻是封裝的一部分，再java裡面提供有四種訪問控制權限：private、default、protected、public，而這四種訪問控制權限定義如下：

范圍	private	default	protected	public
同一包中的同一類	√	√	√	√
同一包中不同類		√	√	√
不同包中的子類			√	√
不同包中的非子類				√

實際上public永遠都可以訪問，但是對於封裝而言主要使用三個權限：private、default、protected。

觀察protected訪問權限

Info.java

package cn.sxau.demo.a;
public class Info {
//protected權限
	protected String str = "www.baidu.com";
}

SubInfo.java

package cn.sxau.demo.a;
import cn.sxau.demo.a.Info;
public class SubInfo extends Info{
	public void print(){
		System.out.println(super.str);
	}
}

TestInfo.java

package cn.sxau.testab;
import cn.sxau.demo.a.SubInfo;
public class TestInfo{
	public static void main(String args[]){
		new SubInfo().print();
	}
}

可以發現SubInfo繼承的子類Info不在同一個包內，但是在同一個子類中，並且可以調用其子類。

錯誤代碼

package cn.sxau.testab;
import cn.sxau.demo.a.Info;
public class TestInfo{
	public static void main(String args[]){
		System.out.println(new Info().str);
	}
}
/*
F:\java\javabase\day09>javac -d . TestInfo.java
TestInfo.java:5: 錯誤: str 在 Info 中是 protected 訪問控制
                System.out.println(new Info().str);
                                             ^
1 個錯誤
*/

原因是str是protected權限，所以在不同類非子類的類中是無法訪問。

對於權限的選擇

對於封裝的描述大部分情況下都使用的是private,很少的情況下使用protected，這兩個都叫封裝
屬性都是以private，方法都使用public。

封裝性就是指private、protected、default三個權限的使用。

5、jar命令

Jar是一種java給出的壓縮格式文件，即：可以將*.class文件以*.jar壓縮包的方式給用戶，這樣方便程序的維護，如果要使用jar的話，可以直接利用JDK給出的jar命令完成。

c：創建一個新的歸檔文件

f：指定jar的文件名稱，由用戶制定一個*.jar的文件名。

v：生成標準的壓縮信息

Message.java

package cn.sxau.util;//打包
public class Message{
	public String print(){
		return "hello world";
	}
}

將Message.java程序進行編譯：javac –d . Message.java，生成包.類；將“包.類”壓縮成my.jar文件：jar –cvf my.jar cn，出現瞭一個my.jar包；

此時my.jar就包含瞭所需要的程序使用類

現在my.jar和MyTest.java處於同一目錄之中。但是發現找不到my.jar之中定義的內容，這是因為在java之中每一個*.jar文件都屬於一個獨立的CLASSPATH路徑，如果要想使用，必須配置CLASSPATH。

在測試之前需要在cmd配置SET CLASSPATH=.;F:\java\javabase\day09\my.jar

//定義一個測試類 調用my.jar
package cn.sxau.test;
public class MyTest{
	public static void main(String args[]){
		cn.sxau.util.Message msg = new cn.sxau.util.Message();
		System.out.println(msg.print());
	}
}
/*
執行
F:\java\javabase\day09>java cn.sxau.test.MyTest
hello world
*/

總結

本篇文章就到這裡瞭，希望能給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

java基礎的詳細瞭解第九天

目錄

1、匿名內部類

2、Object類簡介

Object類的無參構造是專門子類提供服務的。

2.1 取得對象信息toString()

2.2 對象的比較equals()

2.3 Object接口引用數據類型

3、包裝類

3.1 裝箱與拆箱

3.2 字符串與基本數據類型的轉換

將字符串變為int

將字符串變為double

將字符串變為boolean型數據

3.3 包的定義

3.4 包的導入

4、訪問控制權限

觀察protected訪問權限

對於權限的選擇

5、jar命令

總結

推薦閱讀：

發佈留言取消回覆

近期文章

目錄

1、匿名內部類

2、Object類簡介

Object類的無參構造是專門子類提供服務的。

2.1 取得對象信息toString()

2.2 對象的比較equals()

2.3 Object接口引用數據類型

3、包裝類

3.1 裝箱與拆箱

3.2 字符串與基本數據類型的轉換

將字符串變為int

將字符串變為double

將字符串變為boolean型數據

3.3 包的定義

3.4 包的導入

4、訪問控制權限

觀察protected訪問權限

對於權限的選擇

5、jar命令

總結

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆