Java面向對象（下）

包

定義：爲了便於管理大型軟件系統中數目衆多的類，解決類的命名衝突問題，Java引入包（package）機制，提供類的多重命名空間。

package語句作爲java源文件的第一條語句，指明該文件的中定義的類所在的包，若缺省該語句，則指定爲無名包。
java編譯器把包對應於文件系統的目錄管理，package語句中，用“.”來指明包目錄的層次。
如：package com.sxt;則該文件中所有的類位於.\com\sxt目錄下
如果想將一個類放入包中，在這個源文件第一句話寫package
必須保證該類的class文件位於正確的目錄下
必須將class文件的最上層包的父目錄位於classpath下
執行一個類的時候也要寫全包名

實例

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

package lee;
import lee.sub.Apple;
public class HelloTest{
	public static void main(String [] args){
		Hello hello =new Hello();
		Apple a = new Apple();
	}
}

package lee.sub;
public class Apple{}

編譯語句：javac -d . 類名.java

這樣的好處是這個類裏引入的包，直接就可以將先關的.class 文件生成到相應的文件夾下。

Java常用包

Java.lang:這個包下包含了java語言的核心類，如string、Math、System和Thread類，使用這個包下面的類無需使用import語句導入，系統會自動導入這個包下的所有類。

訪問控制

java權限修飾符public、protected、private置於類的成員定義前，用來限制其他對象對該類對象成員的訪問權限

對於class的權限修飾只可以用public（類可以在任意地方被訪問）和default（類只可以被同一個包內部的類訪問）

類的繼承與權限訪問

java中使用extends關鍵字實現類的繼承機制
通過繼承，子類自動擁有了基類superclass的所有成員（成員變量和方法）
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 name;
	}
	
	public int getAge(){
		return age;
	}
}

class Student extends Person{
	private String school;
	public String getSchool(){
		return school;
	}
	
	public void setSchool(String school){
		this.school = school;
	}
}

public class TestPerson{
	public static void main(String args[]){
		Student student = new Student();
		student.setName("Jason");
		student.setAge(28);
		student.setSchool("清華大學");
		System.out.println(student.getName());
		System.out.println(student.getAge());
		System.out.println(student.getSchool());
	}
}

輸出結果：

繼承中的構造方法

子類的構造過程中必須調用其基類的構造方法；
子類可以在自己的構造方法中使用super調用基類的構造方法；
如果調用super必須寫在子類構造方法的第一行；
如果子類的構造方法中沒有顯示的調用基類的構造方法，則系統默認調用基類無參數的構造方法；
如果子類構造方法中既沒有顯示的調用基類的構造方法，而基類中又沒有無參數的構造方法，則編譯出錯。

實例代碼：

class SuperClass{
	private int n;
	SuperClass(){
		System.out.println("SuperClass()");
	}
	
	SuperClass(int n){
		System.out.println("SuperClass(" + n +")");
		this.n = n;
	}
}

class SubClass extends SuperClass{
	private int n;
	SubClass(int n){
		System.out.println("SubClass(" + n +")");
		this.n = n;
	}
	
	SubClass(){
		super(300);
		System.out.println("SubClass()");
	}
}

public class TestSuperSub{
	public static void main(String arg[]){
		SubClass sc1 = new SubClass();
		SubClass sc2 = new SubClass(400);
	}
}

輸出結果：

方法的重寫

在子類中可以根據需要對從基類中繼承來的方法進行重寫；
重寫方法必須和被重寫方法具有相同的方法名稱、參數列表和返回類型；
重寫方法不能使用比被重寫方法更加嚴格的訪問權限。

實例代碼：

class Person{
	public String name;
	public int age;
	public void setName(String name){
		this.name = name;
	}
	
	public void setAge(int age ){
		this.age = age;
	}
	
	public String getName(){
		return name;
	}
	
	public int getAge(){
		return age;
	}
	
	public String getInfo(){
		return "My Name: " + name + "\n" + "Age: " + age;
	}
}

class Student extends Person{
	private String school;
	public String getSchool(){
		return school;
	}
	
	public void setSchool(String school){
		this.school = school;
	}
	
	public String getInfo(){
		return "My name: " + name + "\n" + "Age: " + age + "\n" + "My school: " + school;
	}
}

public class TestPerson{
	public static void main(String args[]){
		Student student = new Student();
		Person person = new Person ();
		person.setName("小明");
		person.setAge(29);
		student.setName("Jason");
		student.setAge(28);
		student.setSchool("清華大學");
		System.out.println(person.getInfo());
		System.out.println(student.getInfo());
	}
}

輸出結果：

Object類

Object類是所有java類的根基類；
如果在類的聲明中未使用extends關鍵字指明其基類，則默認基類爲Object類

toString方法

Object類中定義有public String toString（）方法，其返回值是String類型，描述當前對象的有關信息；
在進行String與其他類型數據的連接操作時，如：System.out.println();將自動調用該對象的toString（）方法；
可以根據需要在用戶自定義類型中重寫toString（）方法。

實例代碼：

public class TestToString{
	public static void main(String [] args){
		Dog d = new Dog();
		System.out.println("d:=" + d);
	}
}
class Dog{
	public String toString(){
		return "Iam a hot Dog!";
	}
}

輸出結果：

equals方法

Object類中定義有
Public boolean equals(Object obj)方法，提供定義對象是否“相等”的邏輯；
Object的equals方法定義爲：X.equals(y)當x和y是同一個對象的應用時返回true否則返回false；
jdk提供了一些類，如String、Date等，重寫了Object的equals方法，調用這些類的equals方法，X.equals(y),當x和y所引用的對象是同一類對象且屬性內容相等時，返回true否則返回false；
可以根據需要在用戶自定義類型中重寫equals方法。

實例代碼：

public class TestEquals{
	public static void main(String [] args){
		Cat c1 = new Cat(1,2,3);
		Cat c2 = new Cat(1,2,5);
		System.out.println(c1 == c2);
		System.out.println(c1.equals(c2));
		
		String s1 = new String("hello");
		String s2 = new String("hello");
		System.out.println(s1 == s2);
		System.out.println(c1.equals(c2));
	}
}

class Cat{
	int color;
	int height;
	int weight;
	
	public Cat(int color, int height, int weight){
	this.color = color;
	this.height = height;
	this.weight = weight;
	}
	public boolean equals(Object obj){
	if(obj == null)return false;
	else{
		if(obj instanceof Cat){
			Cat c = (Cat)obj;
			if(c.color == this.color && c.height == this.height && c.weight == this.weight){
				return true;
			}
		}
	}
	return false;
    }
}

輸出結果：

對象轉型（casting）

一個基類的引用類型變量可以“指定”其子類的對象；
一個基類的引用不可以訪問其子類對象新增加的成員（屬性和方法）；
可以使用引用變量instanceof類名來判斷該引用類型變量所“指向”的對象是否屬於該類或該類的子類；
子類的對象可以當做基類的對象來使用稱作向上轉型（upcasting），反之稱爲向下轉型（downcasting）。

動態綁定（多態）

動態綁定是指在執行期間而非編譯期間判斷所引用對象的實際類型，根據其實際的類型調用相應的方法

三個必要條件：

要有繼承；
要有重寫；
父類引用指向子類對象；

實例代碼：

class Animal{
	private String name;
	Animal(String name){
		this.name = name;
	}
	
	public void enjoy(){
		System.out.println("叫聲...");
	}
}

class Cat extends Animal{
	private String eyesColor;
	Cat(String n, String  c){
		super(n);
		eyesColor = c;
	}
	
	public void enjoy(){
		System.out.println("貓叫聲...");
	}
}

class Dog extends Animal{
	private String furColor;
	Dog(String n, String  c){
		super(n);
		furColor = c;
	}
	
	public void enjoy(){
		System.out.println("狗叫聲...");
	}
}

class Lady{
	private String name;
	private Animal pet;
	Lady(String name, Animal pet){
		this.name = name;
		this.pet = pet;
	}
	
	public void myPetEnjoy(){
		pet.enjoy();
	}
}

public class TestPlo{
	public static void main(String args[]){
		Cat c = new Cat("Catname","blue");
		Dog d = new Dog("Dogname","black");
		Lady l1 = new Lady("11",c);
		Lady l2 = new Lady("12",d);
		l1.myPetEnjoy();
		l2.myPetEnjoy();
	}
}

輸出結果：

抽象類

用abstract關鍵字來修飾一個類的時候，這個類叫做抽象類，用abstract來修飾一個方法的時候，這個方法叫做抽象方法；
含有抽象方法的類必須被聲明爲抽象類，抽象類必須被繼承，抽象方法必須被重寫；
抽象類不能被實例化；
抽象方法只需聲明，而不需實現。

接口

接口是抽象方法和常量值的定義的集合；
從本質上講，接口是一種特殊的抽象類；
多個無關類可以實現同一個接口；
一個類可以實現多個無關類的接口；
與繼承關係類似，接口與實現類之間存在多態性；
用interface修飾的原因是解決多重繼承（一個子類有多個父類）的問題，每個父類之間有多個並且重複的成員變量；
接口是由static修飾的變量就不屬於專門對象；
修飾符可以是public或省略，如果省略了public訪問控制符，則默認採用包權限訪問控制符，即只有在相同包結構下纔可以訪問該接口；
如果一個變量是靜態而且是final類型的就可以定義爲一個接口。

王華春一Jason

發佈了141 篇原創文章 · 獲贊 72 · 訪問量 11萬+

他的留言板關注

Java面向對象（下）

vue項目獲取富文本編輯器wangEditor內容導出爲word（html轉word格式並下載）

dotnet C# 創建 X11 應用時設置窗口背景顏色

Navicat安裝與激活教程

TDengine docker安裝方法

vue3組件通信與props

sapui5

Alpine Linux apk add DNS lookup error

部分JDK版本的發佈時間

工作中用到的腳本合集

合併代碼時Beyond Compare設置

【Java學習專題】深入理解this關鍵字

VUE前端項目部署、發佈

【Java學習專題】static關鍵字的祕密

CSS基礎（三）——盒子模型

Java入門概述

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結