java基礎(chǔ)的詳細(xì)了解第九天
1、匿名內(nèi)部類
內(nèi)部類：在一個類的內(nèi)部定義了另外的類，稱為內(nèi)部類，匿名內(nèi)部類指的是沒有名字的內(nèi)部類。為了清楚內(nèi)部類的主要作用，下面首先觀察一個代碼。
interface IMessage{
public void print();
}
class MessageImpl implements IMessage{//定義接口實現(xiàn)類
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對象
}
}
如果說現(xiàn)在MessageImpl這個子類只使用一次，有必要按照以上的方式進(jìn)行定義嗎？
這個時候MessageImpl就沒有什么意義了，但是可以利用匿名內(nèi)部類的概念來解決此問題。匿名內(nèi)部類是在抽象累和接口的基礎(chǔ)之上發(fā)展起來的。
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(){//匿名內(nèi)部類
public void print(){
System.out.println("hello,world!");
}
};
Demo.get(msg);//傳遞msg對象
}
}
結(jié)論：基本上搞匿名內(nèi)部類都應(yīng)該在接口或抽象類形式上完成。
在抽象類中使用匿名內(nèi)部類
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對象
}
}
強(qiáng)調(diào)：一個普通類進(jìn)行不要再去有子類進(jìn)行繼承，能夠繼承的只是抽象類和接口，所以在普通類上繼續(xù)使用
匿名內(nèi)部類的形式來定義子類，但是在正常的開發(fā)邏輯上是錯誤的。
2、Object類簡介
在Java的定義之中，除了Object類之外，所有的類實際上都存在繼承關(guān)系，即：如果現(xiàn)在定義了一個類，沒有默認(rèn)繼承任何一個父類的話，則默認(rèn)講繼承Object類，以下兩種類最終定義效果是完全一樣的。
Object類的無參構(gòu)造是專門子類提供服務(wù)的。
| 方法名稱 | 類型 | 描述 |
|---|---|---|
| public String toString() | 普通 | 取得對象信息 |
| public boolean equals(Object obj) | 普通 | 對象的比較 |
| public int hashCode() | 普通 | 返回對象的哈希碼值 |
2.1 取得對象信息toString()
toString()的核心目的在于取得對象信息。相當(dāng)于替換了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()方法應(yīng)該并不陌生，這個方法在String類中見過，String是Object類的子類，所以String類的equals()方法就是覆寫了Object類中的equals()方法，在Object類之中，默認(rèn)的equals()方法實現(xiàn)比較的是兩個對象的內(nèi)存地址數(shù)值，但是并不符合與真正的對象比較需要。對象比較之前也寫過，但是之前那是自己定義的一個新的方法名稱，今天可以給出標(biāo)準(zhǔn)的方法名稱：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類型變?yōu)镻erson類型后才可以調(diào)用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，所以以上的方法嚴(yán)格來講已經(jīng)不叫覆寫，叫重載。
2.3 Object接口引用數(shù)據(jù)類型
在之前的分析來講Object可以接收任意的對象，從結(jié)構(gòu)上來講Object是所有類的父類，但是Object概念并不僅僅局限于此，他已接收所有的引用數(shù)據(jù)類型，包括：接口、數(shù)組。
使用Object類接收數(shù)組，數(shù)組和Object沒有任何明確的關(guān)系。
public class TestDemo4{
public static void main(String args[]){
Object obj = new int []{1,3,4};
int data [] = (int [])obj;//向下轉(zhuǎn)型
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();//向上轉(zhuǎn)型
Object obj = msg;//向上轉(zhuǎn)型
Message temp = (Message) obj;//向下轉(zhuǎn)型
System.out.println(temp);//toString()
}
}
從代碼上講，以上只能算是一個固定的操作概念，不過從實際來講，因為有了Obejct類的出現(xiàn)，所有的操作就可以達(dá)到統(tǒng)一，那么之前的鏈表程序，就應(yīng)該變得很方便了。所有的數(shù)據(jù)都使用Object接收，所有的對象比較（刪除、查找）都可以使用equals()。
3、包裝類
在Java的設(shè)計之中，一直倡導(dǎo)一個原則：一切皆對象，這個原則本省有一個漏洞，基本數(shù)據(jù)類型不是對象，所以這個原則就出現(xiàn)了問題，那么如果說現(xiàn)在這個問題由我們來解決，該如何解決呢？
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);//子類自動變?yōu)镺bject父類對象
MyInt temp = (MyInt) obj;//向下轉(zhuǎn)型
int result = temp.intValue();
System.out.println(result*result);
}
}
以上的操作是將基本類型變?yōu)榱艘粋€對象的形式進(jìn)行操作了，但是這里面有一個問題：基本數(shù)值型數(shù)據(jù)是可以進(jìn)行數(shù)學(xué)運算的，可是以上變?yōu)榱祟惖男问?，那么肯定無法直接計算了。以上的問題既然我們都想到方法解決，那么Java也一定早已解決，為此它專門提供了八種包裝類：
byte(Byte),short(Short),int(Integer),long(Long),float(Float),double(Double),boolean(Boolean),char(Character);
而這八種包裝類有分為兩大陣營：
數(shù)值型（Number子類）：Byte,Short,Integer(int),Float,Double,Long;
對象型（Object子類）：Boolean,Character(char)。
可是對于Number的子類，就必須觀察出Number類之中定義的方法：byteVlue()、intVlue()、doubleVlue()、shortVlue()、longVlue()、floatVlue()，就是從包裝的類之中取得所包裝的數(shù)值。
3.1 裝箱與拆箱
在基本數(shù)據(jù)類型和包裝類之間的轉(zhuǎn)化之中分為兩個重要概念：
裝箱操作：將基本數(shù)據(jù)類型變?yōu)榘b類，稱為裝箱，包裝類的構(gòu)造方法。
拆箱操作：將包裝類變?yōu)榛緮?shù)據(jù)類型，稱為拆箱，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之前所進(jìn)行的必須的操作，但是到了JDK1.5之后，Java提供了自動裝箱和自動拆箱的機(jī)制，并且包裝類的對象可以自動的進(jìn)行數(shù)學(xué)計算了。
自動裝箱與拆箱
public class TestDemo{
public static void main(String args[]){
Integer var = 10;//自動裝箱
int result = var;//自動拆箱
//可以直接利用包裝類進(jìn)行對象操作
System.out.println(++var*result);//自動進(jìn)行數(shù)學(xué)運算
}
}
但是到此為止還有一個小問題，實際上這一問題之前已經(jīng)見過。
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()和==的區(qū)別。
使用int還是Integer?
- 在接收數(shù)據(jù)的時候，使用的一定都是int，而保存數(shù)據(jù)的時候一般使用Integer
- 以后編寫的簡單java類統(tǒng)一不要再去使用基本數(shù)據(jù)類型，全部換位包裝類
3.2 字符串與基本數(shù)據(jù)類型的轉(zhuǎn)換
包裝類之中所提供的最大優(yōu)點在于可以講字符串變?yōu)橹贫ǖ幕緮?shù)據(jù)類型，下面列出幾個操作：
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()方法，可以取得制定索引的字符，而且一個字符的長度就是一位。
將字符串變?yōu)閕nt
public class TestDemo{
public static void main(String args[]){
String str = "16";
int result = Integer.parseInt(str);//String ——>int
System.out.println(result*result);
}
}
但是需要提醒的是，在執(zhí)行這種轉(zhuǎn)化的操作過程之中，字符串字符串中的全部內(nèi)容必須由數(shù)字所組成，如果有一位內(nèi)容不是數(shù)字，則在轉(zhuǎn)化的過程之中講出現(xiàn)如下的錯誤提示：NumbnerFormatException。
將字符串變?yōu)閐ouble
public class TestDemo{
public static void main(String args[]){
String str = "16.";
double result = Double.parsedouble(str);//String ——>int
System.out.println(result*result);
}
}
將字符串變?yōu)閎oolean型數(shù)據(jù)
public class TestDemo{
public static void main(String args[]){
String str = "true";
boolean result = Boolean.parseboolean(str);//String ——>int
System.out.println(result);
}
}
提示：在使用Boolean型包裝類的時候，如果字符串之中的內(nèi)容不是true或者是false，統(tǒng)一都按照false處理。
以上的操作是通過字符串變?yōu)橐恍┗绢愋偷臄?shù)據(jù)，但是反過來講，基本數(shù)據(jù)類型如何變?yōu)樽址兀?/p>
方式一：任何基本數(shù)據(jù)類型遇到了String之后都會變?yōu)镾tring型數(shù)據(jù)；
public class TestDemo{
public static void main(String args[]){
int num = 100;
String str = num+"";//int——>String //會產(chǎn)生垃圾
System.out.println(str.length());
}
}
//會有垃圾產(chǎn)生
方式二：利用String方法，public static String valueOf(數(shù)據(jù)類型 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程序之中的包，主要的目的是可以將不同功能的文件進(jìn)行分割，在之前的代碼開發(fā)之中，所有的程序都保存在了同一個目錄之中，這樣一來所帶來的問題：如果出現(xiàn)了同名的文件，那么會發(fā)生覆蓋問題，因為在同一個目錄之中不允許有重名的文件，而在不同的目錄下可以有重名文件，所謂的包實際上指的就是文件夾。
package cn.mldn.demo;//定義包
public class Hello{
public static void main(String args[]){
System.out.println("Hello World");
}
}
一旦定義完成之后，那么這個類的名字就成了“cn.mldn.demo.Hello”，即這既是完整的類名稱，而在進(jìn)行程序編譯的時候也需要將*.class文件保存在包之中，于是為了方便開發(fā)，那么也就提供了一個打包的編譯操作。
打包編譯：javac -d . 類.java
-d:表示生成目錄，根據(jù)package定義生成
-“.”:再當(dāng)前目錄下生成*.class
類.java:編譯源程序代碼
這個時候類的名字必須帶上包的名稱，所以執(zhí)行類的時候：java cn.mldn.demo.Hello，也就是說完整類的名稱就是“包.類”，而在所有的開發(fā)之中，沒有包的類是絕對不存在的，只要是程序一定要有包。
3.4 包的導(dǎo)入
既然使用包可以將一個大型的程序拆分成不同的功能目錄保存，那么這些不同的包之間也一定會存在包的導(dǎo)入問題，而導(dǎo)入包在程序之中使用import完成，下面通過一個程序進(jìn)行演示。
//定義一個Message
package cn.mldn.util;//打包
class Massage{
public String print(){
return "Hello World";
}
}
//定義另外一個類使用Message類
package cn.mldn.text;//打包
import cn.mldn.util.Message;//導(dǎo)入包
public class Text{
public static void main(String args[]){
Massage msg = new cn.mldn.util.Massage();
System.out.println(msg.print());
}
}
這個時候上面的兩個類應(yīng)該是按照順序編譯：
應(yīng)該首先編譯Message.java程序：javac –d . Message.java;
再次編譯Test.java程序：javac –d . Test.java，但是這個時候出現(xiàn)了一下的錯誤提示：
Text.java:5: 錯誤: Massage在cn.mldn.util中不是公共的; 無法從外部程序包中對其進(jìn)行
訪問
Massage msg = new cn.mldn.util.Massage();
^
提示：關(guān)于public class 和class定義類的區(qū)別
Public class：文件名和類名稱保持一致，在一個*.java文件之中只能存在一個public class定義，如果一個類要想被外部包所訪問必須定義為public；
Class：文件名稱可以和類名稱不一致，在一個*.java之中可以同事存在多個class定義，并且編譯完成之后會形成多個*.class文件，使用class定義的類只能夠在一個包中訪問，不同包之間無法訪問。
package cn.mldn.util;//打包
public class Massage{
public String print(){
return "Hello World";
}
}
但是同時也發(fā)現(xiàn)了一個問題，現(xiàn)在這些類在編譯的時候要有順序，實在很麻煩，為此在java之中專門提供了一個可以進(jìn)行自動連編的操作，編譯的時候使用*.java：javac –d . .java，將一個目錄之中所有的.java文件進(jìn)行編譯。
但是以上的代碼還有一個小問題：程序在進(jìn)行導(dǎo)入的時候使用了“包.類”的完整名稱完成的，但是如果在一個程序之中要同時導(dǎo)入一個包的多個類的時候，那么分開去編寫實在很麻煩，為此可以使用通配符“*”完成導(dǎo)入。
package cn.mldn.text;//打包
import cn.mldn.util.*;//導(dǎo)入包
public class Text{
public static void main(String args[]){
Massage msg = new cn.mldn.util.Massage();
System.out.println(msg.print());
}
}
但是需要注意的是，在java之中使用“”或者是的單獨導(dǎo)入，其從實際的操作性能上是沒有任何區(qū)別的，因為即使使用了也表示導(dǎo)入所需要的類，不需要的不導(dǎo)入。
可是在導(dǎo)入包的時候也會遇到一種比較麻煩的問題：會導(dǎo)入不同包的同名類，例如：對于Message類，現(xiàn)在在兩個包中都有：cn.mldn.util cn.mldn.info
package cn.mldn.text;//打包
import cn.mldn.util.*;//導(dǎo)入包
import cn.mldn.info.*;//導(dǎo)入包
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();
^
*/
由于某種需要，同時導(dǎo)入兩個包，這個時候要使用Message類的時候必須加上類的全名。
package cn.mldn.text;//打包
import cn.mldn.util.*;//導(dǎo)入包
import cn.mldn.info.*;//導(dǎo)入包
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、訪問控制權(quán)限
之前學(xué)習(xí)到的private就屬于一種訪問控制權(quán)限，而這種訪問控制權(quán)限只是封裝的一部分，再java里面提供有四種訪問控制權(quán)限：private、default、protected、public，而這四種訪問控制權(quán)限定義如下：
| 范圍 | private | default | protected | public |
|---|---|---|---|---|
| 同一包中的同一類 | √ | √ | √ | √ |
| 同一包中不同類 | √ | √ | √ | |
| 不同包中的子類 | √ | √ | ||
| 不同包中的非子類 | √ |
實際上public永遠(yuǎn)都可以訪問，但是對于封裝而言主要使用三個權(quán)限：private、default、protected。
觀察protected訪問權(quán)限
Info.java
package cn.sxau.demo.a;
public class Info {
//protected權(quán)限
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();
}
}
可以發(fā)現(xiàn)SubInfo繼承的子類Info不在同一個包內(nèi)，但是在同一個子類中，并且可以調(diào)用其子類。
錯誤代碼
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權(quán)限，所以在不同類非子類的類中是無法訪問。
對于權(quán)限的選擇
- 對于封裝的描述大部分情況下都使用的是private,很少的情況下使用protected，這兩個都叫封裝
- 屬性都是以private，方法都使用public。
封裝性就是指private、protected、default三個權(quán)限的使用。
5、jar命令
Jar是一種java給出的壓縮格式文件，即：可以將*.class文件以*.jar壓縮包的方式給用戶，這樣方便程序的維護(hù)，如果要使用jar的話，可以直接利用JDK給出的jar命令完成。
c：創(chuàng)建一個新的歸檔文件
f：指定jar的文件名稱，由用戶制定一個*.jar的文件名。
v：生成標(biāo)準(zhǔn)的壓縮信息
Message.java
package cn.sxau.util;//打包
public class Message{
public String print(){
return "hello world";
}
}
將Message.java程序進(jìn)行編譯：javac –d . Message.java，生成包.類；將“包.類”壓縮成my.jar文件：jar –cvf my.jar cn，出現(xiàn)了一個my.jar包；
此時my.jar就包含了所需要的程序使用類
現(xiàn)在my.jar和MyTest.java處于同一目錄之中。但是發(fā)現(xiàn)找不到my.jar之中定義的內(nèi)容，這是因為在java之中每一個*.jar文件都屬于一個獨立的CLASSPATH路徑，如果要想使用，必須配置CLASSPATH。
在測試之前需要在cmd配置SET CLASSPATH=.;F:\java\javabase\day09\my.jar
//定義一個測試類 調(diào)用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());
}
}
/*
執(zhí)行
F:\java\javabase\day09>java cn.sxau.test.MyTest
hello world
*/
總結(jié)
本篇文章就到這里了，希望能給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！
相關(guān)文章
這篇文章主要介紹了SpringBoot快速配置數(shù)據(jù)源的方法，幫助大家更好的理解和使用springboot框架，感興趣的朋友可以了解下2020-10-10
這篇文章主要介紹了Java定時器通信協(xié)議管理模塊Timer，?Timer一般指定時器（通信協(xié)議管理模塊）人類最早使用的定時工具是沙漏或水漏，但在鐘表誕生發(fā)展成熟之后，人們開始嘗試使用這種全新的計時工具來改進(jìn)定時器，達(dá)到準(zhǔn)確控制時間的目的2022-08-08
SpringBoot 統(tǒng)一公共返回類的實現(xiàn)
本文主要介紹了SpringBoot 統(tǒng)一公共返回類的實現(xiàn)，配置后臺的統(tǒng)一公共返回類，這樣做目的是為了統(tǒng)一返回信息，文中示例代碼介紹的很詳細(xì)，感興趣的可以了解一下2022-01-01
這篇文章主要介紹了Java消息隊列RabbitMQ之消息回調(diào)詳解,消息回調(diào)，其實就是消息確認(rèn)(生產(chǎn)者推送消息成功，消費者接收消息成功) , 對于程序來說，發(fā)送者沒法確認(rèn)是否發(fā)送成功,需要的朋友可以參考下2023-07-07
這篇文章主要為大家詳細(xì)介紹了如何使用鏈?zhǔn)酱鎯Y(jié)構(gòu)來實現(xiàn)棧，也就是鏈棧的實現(xiàn)，文中的示例代碼講解詳細(xì)，感興趣的小伙伴可以了解一下2022-11-11
本篇文章給大家整理了Java平閏年判斷的兩種方法，大家在寫程序的時候如果用的到參考下吧。2018-02-02
這篇文章主要介紹了簡單講解java中throws與throw的區(qū)別，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-07-07
SpringBoot集成MyBatisPlus+MySQL的實現(xiàn)
MybatisPlus是國產(chǎn)的第三方插件, 它封裝了許多常用的CURDapi,免去了我們寫mapper.xml的重復(fù)勞動,本文主要介紹了SpringBoot集成MyBatisPlus+MySQL的實現(xiàn),感興趣的可以了解一下2023-10-10
這篇文章主要介紹了詳解SpringBoot讀取配置文件的N種方法，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-02-02
Spring中@Value設(shè)置默認(rèn)值問題解決
本文主要介紹了Spring中@Value設(shè)置默認(rèn)值問題解決，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2023-07-07