java基礎(chǔ)的詳細了解第七天
1、static關(guān)鍵字
1.1 使用static關(guān)鍵字定義屬性
在講解static定義屬性操作之前，首先編寫如下一道程序。
現(xiàn)在定義一個表示中國人的操作類，所有人所在的國家為中國。
class Person{
private String name;
private int age;
String country = "中國";
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getInfo(){
return "姓名："+this.name+" "+"年齡："+this.age+" "+"國家："+country;
}
}
public class TestDemo1{
public static void main(String args[]){
Person per1 = new Person("張三",30);
Person per2 = new Person("李四",40);
Person per3 = new Person("王五",50);
System.out.println(per1.getInfo());
System.out.println(per2.getInfo());
System.out.println(per2.getInfo());
}
}
很明顯，現(xiàn)在不管有多少個Person對象他的屬性country的內(nèi)容都是相同的，如果這時中國改名了，那么所有Person類的country屬性都好更改，這樣的話太過繁瑣。
現(xiàn)在可以發(fā)現(xiàn)這樣的問題：
1、country屬性應(yīng)該是一個公共的內(nèi)容，但上面的代碼是將其分配給每一個對象；
2、對country屬性維護的時候要考慮的對象太多了，不便于維護。
所以如果想將country與普通屬性相區(qū)分，并表示公共的概念，則應(yīng)該使用static關(guān)鍵字完成。
class Person{
private String name;
private int age;
static String country = "中國";
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String getInfo(){
return "姓名："+this.name+" "+"年齡："+this.age+" "+"國家："+country;
}
}
public class TestDemo1{
public static void main(String args[]){
Person per1 = new Person("張三",30);
Person per2 = new Person("李四",40);
Person per3 = new Person("王五",50);
per1.country = "美國";
System.out.println(per1.getInfo());
System.out.println(per2.getInfo());
System.out.println(per2.getInfo());
}
}
那么現(xiàn)在對一個對象的屬性country進行修改就一定會影響到其他對象的country屬性，但是這里有個問題既然使用了static定義的屬性表示一個公共屬性，那么如果現(xiàn)在又一個對象進行修改是不合適的，應(yīng)該有所有對象的集合的最大代表，就是類。即：static屬性最好的調(diào)用，是通過“類名稱.static屬性”的方式來完成。
Person.country = “美國”; //類名稱.static屬性
通過本程序，就因該清楚一下幾點：
1.使用static定義的屬性不在堆內(nèi)存之中保存，保存在全局數(shù)據(jù)區(qū)；
2.使用static定義的屬性表示類屬性，類屬性可以由類型名稱直接進行調(diào)用；
3.static屬性雖然定義在類之中，但是其可以在沒有實例化對象的時候進行調(diào)用（普通屬性保存在堆內(nèi)存之中，static屬性保存在全局數(shù)據(jù)區(qū)）
在以后的開發(fā)之中，首先想到的不是static屬性，而是普通屬性。
1.2 使用static定義方法
class Person{
private String name;
private int age;
//static String country = "中國";
private static String country = "中國";
public Person(String name,int age){
this.name = name;
this.age = age;
}
//無法從靜態(tài)上下文中引用非靜態(tài) 變量 this
//靜態(tài)方法中沒有辦法使用this變量
public static void setCountry(String c){
country = c;
}
public static String getCountry(){
return country;
}
public String getInfo(){
return "姓名："+this.name+" "+"年齡："+this.age+" "+"城市："+country;
}
}
public class TestDemo1{
public static void main(String args[]){
/*Person per1 = new Person("張三",30);
Person per2 = new Person("李四",40);
Person per3 = new Person("王五",50);
per1.country = "美國";
System.out.println(per1.getInfo());
System.out.println(per2.getInfo());
System.out.println(per2.getInfo());*/
//調(diào)用的方法必須為靜態(tài)方法
//姓名：張三 年齡：30 城市：中國人民共和國
Person.setCountry("中國人民共和國");//沒有實例化對象產(chǎn)生
Person p1 = new Person("張三",30);
System.out.println(p1.getInfo());
}
}
以上的代碼如果單獨觀察都不難理解，主要都是由于static定義的特殊性所決定的，但是現(xiàn)在的類之中就比較熱鬧了，分成了兩類：static和非static，而對于方法的操作有如下兩定義：
1、static定義的方法不能調(diào)用非static的方法或是屬性；
2、非static定義的方法卻可以調(diào)用static方法和static屬性；
討論：為什么要有這樣的限制？
使用static定義的屬性和方法，可以在沒有實例化對象的時候調(diào)用，而非static方法必須在實例化對象之后才能調(diào)用。
1.3 分析主方法
在講解主方法之前，思考一下小小的區(qū)別：在之前講解Java方法定義格式的時候給過以下格式：如果一個方法在主類之中定義，并且有主方法直接調(diào)用的時候，前面必須有public static。
public class TestDemo{
public static void main(String args[]){
print(); //主方法直接調(diào)用
}
public static void print(){
System.out.println("Hello World");
}
}
按照之前所學習的概念來講，此時，表示的是一個static方法調(diào)用其他的static方法，但是如果這個時候的print方法上沒有static呢？所有非static方法幾乎都有一個特點：非方法要由實例化對象調(diào)用。
public class TestDemo{
public static void main(String args[]){
//Hello,World!
new TestDemo().print(); //實例化對象調(diào)用非static方法
}
public void print(){
System.out.println("Hello,World!");
}
}
主方法的組成：
- Public:表示一個訪問權(quán)限，表示公共
- static：此方法由類名稱直接調(diào)用，執(zhí)行類：Java 類名稱
- void：主方法是一切的開始
- main：系統(tǒng)規(guī)定的一個方法名稱，執(zhí)行類的時候默認找到此名稱
- String args[]：表示的是一些運行時參數(shù)，通過字符串接收
public class TestDemo2{
public static void main(String args[]){
for(int x = 0;x<args.length;x++){
System.out.println(args[x]);
}
}
}
1.4 關(guān)鍵字的使用
在實際的工作之中，使用static的原因有兩個：
- 希望可以在沒有實例化對象的時候可以輕松的執(zhí)行類的某些操作
- 現(xiàn)在希望表示出數(shù)據(jù)共享的概念
統(tǒng)計一個類的實例化對象的個數(shù)
class Person{
private String name;
static int num = 0;
public Person(){
num++;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
}
public class TestDemo3{
public static void main(String args[]){
Person per1 =new Person();
Person per2 =new Person();
Person per3 =new Person();
Person per4 =new Person();
System.out.println(Person.num);
}
}
2、代碼塊
2.1 普通代碼塊
public class PuTongDaiMaKuai{
public static void main(String args[]){
{ //普通代碼塊
int x = 10; //局部變量
System.out.println("x ="+x);
}
int x = 100; //全局變量
System.out.println("x ="+x);
}
}
//x =10
//x =100
2.2 構(gòu)造塊
class Person{
public Person(){
System.out.println("構(gòu)造方法1")
}
{
System.out.println("構(gòu)造塊2");
}
}
public class PuTongDaiMaKuai{
public static void main(String args[]){
new Person();
new Person();
new Person();
}
}
/*
構(gòu)造塊2
構(gòu)造方法1
構(gòu)造塊2
構(gòu)造方法1
構(gòu)造塊2
構(gòu)造方法1
*/
可以發(fā)現(xiàn)，構(gòu)造塊優(yōu)先于構(gòu)造方法先執(zhí)行，而且每當有一個新的實例化對象產(chǎn)生的時候，就會出現(xiàn)構(gòu)造塊的執(zhí)行。
2.3 靜態(tài)塊
靜態(tài)塊也是定義在類之中的，如果一個構(gòu)造塊上使用了static關(guān)鍵字進行定義的話，那么就表示靜態(tài)塊，但是靜態(tài)塊要考慮兩種情況。
情況一：在非主類之中定義的靜態(tài)塊
class Person{
public Person(){
System.out.println("構(gòu)造方法1");
}
{//構(gòu)造塊
System.out.println("構(gòu)造塊2");
}
static{//靜態(tài)塊
System.out.println("靜態(tài)塊3");
}
}
public class JingTaiKuai{
public static void main(String args[]){
new Person();
new Person();
new Person();
}
}/*構(gòu)造塊3構(gòu)造塊2構(gòu)造方法1構(gòu)造塊2構(gòu)造方法1構(gòu)造塊2構(gòu)造方法1*/
可以發(fā)現(xiàn)，靜態(tài)塊優(yōu)先于構(gòu)造塊，而且不管產(chǎn)生多少實例化對象，靜態(tài)塊只調(diào)用一次。
情況二：在主類中定義的靜態(tài)塊
public class TestDemo4{
static{
System.out.println("靜態(tài)塊");
}
public static void main(String args[]){
System.out.println("主方法");
}
}
/*
靜態(tài)塊
主方法
*/
在主類之中的靜態(tài)塊優(yōu)先于主方法執(zhí)行，那么既然靜態(tài)塊有這個特點，我們可以加以利用。
3、繼承性
Person java:
class Person{
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
Student java:
class Student{
private String name;
private int age;
private String school;
public void setName(String name){
this.name=name;
}
public void setAge(String age){
this.age=age;
}
public void setSchool(String school){
this.school=school;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public String getSchool(){
return school;
}
}
可以發(fā)現(xiàn)里面有一大部分的內(nèi)容已經(jīng)重復了，但是現(xiàn)在拋開程序不談，學生和人的關(guān)系是：學生就是一個人，但是學生類比人類的定義更加嚴格，此時按照之前的概念肯定無法解決問題。
3.1 繼承的實現(xiàn)
在Java中，如果想要明確的實現(xiàn)繼承的關(guān)系，則可以使用extends關(guān)鍵字完成，格式如下：
//但是在這里需要注意的是：子類又被稱為派生類；
//父類也被稱為超類（super class）
class 子類 extends 父類{}
class Person{
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
class Student extends Person
{
}
public class TestDemo5{
public static void main(String args[]){
Student stu = new Student();
stu.setName("張三");
System.out.println(stu.getName());
}
}
通過程序的運行我可以發(fā)現(xiàn)，現(xiàn)在在子類之中，沒有定義任何方法，而是可以直接將父類中定義的操作繼續(xù)使用，所以在子類之中可以對父類進行重用，當然，子類也可以定義屬于自己的操作。
class Person{
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
class Student extends Person{
private String school;
public void setSchool(String school){
this.school = school;
}
public String getSchool(){
return this.school;
}
}
public class TestDemo5{
public static void main(String args[]){
Student stu = new Student();
stu.setName("張三");
stu.setSchool("賓夕法尼亞大學");
//name = 張三,school = 賓夕法尼亞大學
System.out.println("name = " + stu.getName()+ ",school = " +stu.getSchool());
}
}
通過以上程序了一發(fā)現(xiàn)，在開發(fā)語言之中，子類最基本的功能就是維持父類的原本操作，所以在程序語言之中并不會存在所謂的現(xiàn)實生活中的“敗家子”的概念。所以通過程序可以發(fā)現(xiàn)，繼承的功能就是對已有類功能的一種擴充。
3.2 繼承的限制
1.在使用繼承關(guān)系后，子類對象在實例化對象前一定首先實例化父類構(gòu)造方法，再調(diào)用子類的構(gòu)造方法后子類再進行實例化操作?！F(xiàn)實生活之中，沒有老子，也絕對沒有后代，肯定是老子先出來，之后在輪到小的再出來，所以這樣的實例化方式非常吻合現(xiàn)實生活，如果在調(diào)用子類構(gòu)造之前先去調(diào)用父類構(gòu)造就可以證明是先實例化父類對象，而后再實例化子類對象。
2.Java中只允許單繼承，不允許多繼承。
3.在進行繼承的時候，子類會繼承父類所有的結(jié)構(gòu)。所有的非私有操作采用顯式繼承的方式，所有的私有操作采用隱式繼承的方式。——按之前的開發(fā)所講，一個類中的全部內(nèi)容肯定都被子類繼承，對于之前學生和人之間的操作，學生類也繼承了Person類中的name和age兩個屬性，這兩個屬性是間接繼承（隱式繼承），只能通過方法訪問
class Person{
public Person(){
System.out.println("父類構(gòu)造");
}
}
class Student extends Person{
public Student(){
//既然是進行構(gòu)造方法的調(diào)用，必須寫再首行位置
super();//此語句再無參時寫與不寫一樣
System.out.println("子類構(gòu)造");
}
}
public class JiChengXing{
public static void main(String args[]){
new Student();
}
}
而如果說現(xiàn)在父類中沒有明確的無參構(gòu)造方法，這個時候就可以利用super()來指定要調(diào)用的父類構(gòu)造參數(shù)。
class Person{
public Person(String name,int age){
System.out.println("父類構(gòu)造");
}
}
class Student extends Person{
public Student(String name,int age,String school){
super(name,age);
System.out.println("子類構(gòu)造");
}
}
public class JiChengXing{
public static void main(String args[]){
new Student("Jokser",22,"北京大學");
}
}
4、覆寫
既然現(xiàn)在出現(xiàn)類繼承的關(guān)系，就出現(xiàn)類子類和父類之間的聯(lián)系，而在子類之中有可能定義了和父類完全相同的方法或?qū)傩缘拿Q，這個時候就成為覆寫。
4.1 方法的覆寫
當子類定義了和父類在方法名稱、返回值類型、參數(shù)類型以及個數(shù)完全相同的方法的時候，成為方法的覆寫。
class A{
public void print(){
System.out.println("我是A的輸出方法");
}
}
class B extends A{
public void print(){
System.out.println("我是B的輸出方法");
}
}
public class TestDemo6{
public static void main(String args[]){
B b=new B();
//我是B的輸出方法
b.print();
}
}
當我們一個類之中的方法被覆寫之后，如果實例化的是這個子類對象，則被調(diào)用的方法就是被覆寫過的方法。
但是在進行方法覆寫的時候有一個點需要注意：被子類所覆寫的方法不能擁有比父類更嚴格的訪問控制權(quán)限，對于訪問控制權(quán)限現(xiàn)在已經(jīng)接觸過三種：private<default(不寫)<public。
如果此時父類的訪問權(quán)限是default權(quán)限，那么子類覆寫的時候只能是default或public權(quán)限，而如果父類的方法是public，那么子類之中的覆寫方法訪問權(quán)限只能是public。
提示：別沒事找事干！以后只要是方法都是public類型。屬性就寫private類型
當一個子類覆寫了一個父類方法的時候，那么在這種情況下，如果子類想要調(diào)用父類的被覆寫過的方法，則在方法前加上“super”。
class A{
public void print(){
System.out.println("我是A的輸出方法");
}
}
class B extends A{
public void print(){
//如果想在子類中調(diào)用父類的方法就在子類首行加super.方法名
super.print();
System.out.println("我是B的輸出方法");
}
}
public class TestDemo6{
public static void main(String args[]){
B b=new B();
//我是B的輸出方法
b.print();
}
}
🌝面試題:重載和覆寫的區(qū)別？在進行重載的時候返回值是否可以不同？
| 區(qū)別 | 重載 | 覆寫 |
|---|---|---|
| 英文單詞 | OverLoding | Overrider |
| 概念 | 方法名稱相同，參數(shù)類型以及個數(shù)不同 | 方法名稱、參數(shù)類型、參數(shù)個數(shù)必須全部相同 |
| 范圍 | 發(fā)生在一個類里面 | 發(fā)生在多個類里面 |
| 限制 | 沒有要求 | 被覆寫的方法不能有比父類更高的訪問控制權(quán)限 |
方法重載的時候返回類型是可以不同的，但是良好的設(shè)計要求是類型一致。
4.2 屬性覆蓋
當一個子類定義了和父類重名的屬性名稱的時候，就表示屬性的覆蓋了。
class A{
String str = "Hello World";
}
class B extends A{
int str = 100;
public void print(){
System.out.println(this.str);
System.out.println(super.str);
}
}
public class FuXie{
public static void main(String args[]){
B b=new B();
//100
//Hello World
b.print();
}
}
這種操作幾乎沒有意義，因為從開發(fā)來講，屬性一定進行封裝，封裝之后就沒有覆蓋了。
4.3 super關(guān)鍵字
🌝面試題:this和super的區(qū)別？
| 區(qū)別 | this | super |
|---|---|---|
| 定義 | 表示本類對象 | 表示父類對象 |
| 使用 | 本類操作：this()、this.屬性、this.方法 | super()、super.屬性、super.方法 |
| 調(diào)用構(gòu)造方法 | 調(diào)用本類構(gòu)造方法放在首行 | 子類調(diào)用父類構(gòu)造放在首行 |
| 查找范圍 | 先從本類中，查找不到父類 | 直接由子類查找父類 |
| 特殊 | 表示當前對象 | 無 |
5、數(shù)組操作（定義Array父類）
**要求：**現(xiàn)在要求定義一個整型數(shù)組的操作類，數(shù)組的大小由外部決定，用戶可以向數(shù)組之中增加數(shù)據(jù)，以及取得數(shù)組中的全部數(shù)據(jù)，也可以根據(jù)外部提供的數(shù)組的增長大小，在原本的數(shù)組之上擴充指定的容量，另外，在此類上派生兩個子類：
排序類（sortArray）：取得數(shù)組內(nèi)容是經(jīng)過排序出來的結(jié)果；
反轉(zhuǎn)類（Fanzhuan）：取得數(shù)組的內(nèi)容是反轉(zhuǎn)出來的結(jié)果；
首先要完成的是定義父類，根本就不需要考慮子類。
class Array{
private int data[];//定義一個數(shù)組，數(shù)組大小由外部決定
private int foot = 0;//數(shù)組角標
//創(chuàng)建數(shù)組
public Array(int len){
if(len > 0){
this.data = new int [len];//開辟空間
}else{
this.data = new int [1];
}
}
//增加數(shù)組
public boolean add(int num){
if(this.foot >= data.length){
return false;
}else{
this.data[this.foot ++] = num;
return true;
}
}
//輸出數(shù)組
public int[] getData(){
return this.data;
}
//動態(tài)擴充數(shù)組
public void inc(int num){
int [] newData = new int [this.data.length + num];
/*
public static void arraycopy(Object src, src - 源數(shù)組。
int srcPos, srcPos - 源數(shù)組中的起始位置。
Object dest, dest - 目標數(shù)組。
int destPos, destPos - 目的地數(shù)據(jù)中的起始位置。
int length) length - 要復制的數(shù)組元素的數(shù)量。
*/
System.arraycopy(this.data,0,newData,0,this.data.length);
this.data = newData;
}
}
//對數(shù)組進行排序操作
class sortArray extends Array{
public sortArray(int num){
super(num);
}
public int[] getData(){
java.util.Arrays.sort(super.getData());
return super.getData();
}
}
//數(shù)組內(nèi)容翻轉(zhuǎn)
class Fanzhuan extends Array{
public Fanzhuan(int num){
super(num);
}
public int[] getData(){
int head = 0;
int tail = super.getData().length - 1;
int center = super.getData().length / 2;
for(int i = 0 ; i < center ; i++,head++,tail--){
int temp = super.getData()[head];
super.getData()[head] = super.getData()[tail];
super.getData()[tail] = temp;
}
return super.getData();
}
}
public class Exam1{
public static void main(String args[]){
//Array arr = new Array(5);
//sortArray arr = new sortArray(5);
Fanzhuan arr = new Fanzhuan(5);
System.out.println(arr.add(3));
System.out.println(arr.add(1));
System.out.println(arr.add(3));
System.out.println(arr.add(8));
System.out.println(arr.add(0));
arr.inc(3);
System.out.println(arr.add(7));
System.out.println(arr.add(20));
System.out.println(arr.add(10));
int result[] = arr.getData();
for(int i = 0; i < result.length ; i++){
System.out.print(result[i]+"、");
}
}
}
在整個程序開發(fā)之中，可以明顯的感覺到，所有的操作都是圍繞著父類功能的擴充進行的，但是方法并沒有改變，所以在開發(fā)之中，父類的設(shè)計是最重要的，子類最好繼承或者說是覆寫覆寫操作，都是應(yīng)該以父類的方法為主。
6、final關(guān)鍵字
在Java中，final關(guān)鍵字表示的是一個終結(jié)器的概念，使用final可以定義類、方法、變量。
使用final定義的類不能有子類
final class A{
}
class B extends A{
}
使用final定義的方法不能被子類所覆寫
final class A{
public final void print(){}
}
class B extends A{
public void print(){}
}
使用final定義的變量，就表示常量，常量在定義的時候必須設(shè)置默認值，并且無法修改
final class A{
final String str = "hello world";//常量
public final void print(){
str = "你好"; //無法修改
}
}
public class Final{
public static void main(String args[]){
}
}
而如果說現(xiàn)在使用了public static定義的常量，那么這個常量就成為全局常量。
public static final String STR = "hello,world";//全局常量
而對于以上final關(guān)鍵字的三個操作，只有全局常量的概念是被開發(fā)之中所使用的，像類或方法定義上使用的情況，幾乎不會再我們編程中出現(xiàn)。
總結(jié)
本篇文章就到這里了，希望能給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！
相關(guān)文章
最新IDEA?2022基于JVM極致優(yōu)化?IDEA啟動速度的方法
這篇文章主要介紹了IDEA?2022最新版?基于?JVM極致優(yōu)化?IDEA?啟動速度,需要的朋友可以參考下2022-08-08
mybatis-plus返回map自動轉(zhuǎn)駝峰配置操作
這篇文章主要介紹了mybatis-plus返回map自動轉(zhuǎn)駝峰配置操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-11-11
MyBatis 處理枚舉類型的機制相對直接,它提供了一種靈活的方式來處理Java枚舉（enum）類型和數(shù)據(jù)庫之間的映射,本文給大家介紹了MyBatis處理枚舉類型的兩種方法,需要的朋友可以參考下2024-07-07
Java內(nèi)部類應(yīng)用之靜態(tài)內(nèi)部類應(yīng)用示例
這篇文章主要介紹了Java內(nèi)部類應(yīng)用之靜態(tài)內(nèi)部類應(yīng)用,結(jié)合實例形式分析了Java靜態(tài)內(nèi)部類的原理、功能、用法及相關(guān)操作注意事項,需要的朋友可以參考下2019-09-09
Java基于elasticsearch實現(xiàn)集群管理
這篇文章主要介紹了java基于elasticsearch實現(xiàn)集群管理,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-02-02
SpringBoot+Redis實現(xiàn)數(shù)據(jù)字典的方法
這篇文章主要介紹了SpringBoot+Redis實現(xiàn)數(shù)據(jù)字典的方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-10-10
spring基礎(chǔ)系列之JavaConfig配置詳解
本篇文章主要介紹了spring基礎(chǔ)系列之JavaConfig配置詳解，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-07-07
Windows7下的Java運行環(huán)境搭建過程圖解
這篇文章主要介紹了Windows7下的Java運行環(huán)境搭建過程圖解,需要的朋友可以參考下2014-04-04
本篇文章主要介紹了spring之Bean的生命周期詳解，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-05-05
Spring?Cloud?oauth2?認證服務(wù)搭建過程示例
這篇文章主要為大家介紹了Spring?Cloud?oauth2?認證服務(wù)搭建過程示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06