Oracle 字串和日期轉換
阿新 • • 發佈：2021-11-27
java的三大特徵
面嚮物件語言的三大特徵
封裝
包裝 把實現細節包裝起來,對外提供方法訪問
將類中的某些資訊或者成員方法隱藏起來,外部無法直接訪問,向外提供一些專門的方法操作;
隱藏(訪問許可權修飾符)
public class Person { /** 通過訪問修飾符來隱藏類中的資訊 */ private String name; private int age; /* public Person(String n , int a){k name = n; age = a; }*/ /** *為私有屬性提供專門的方法來進行訪問 * this 現實的表示當前正在訪問的物件 */ public void setName(String name) { if (name.length() < 5) { this.name = name;//物件p訪問時,this表示的是p物件 eat(); }else{ this.name="肖恩"; this.eat();//本類中訪問私有許可權的方法 } } public String getName(){ return name; } public void setAge(int age){ this.age=age; } public int getAge(){ return age; } /* 私有許可權的方法,可以在本類中訪問 */ private void eat() { System.out.print("乾飯王:"); } }
public class PersonTest { public static void main(String[] args) { /*Person p = new Person("jim",20);*/ /*Person p1 = new Person("jack",28);*/ Person p = new Person(); p.setName("崔"); p.setAge(21); System.out.println(p.getName()+p.getAge()); Person p1 = new Person(); p1.setName("瑞"); p1.setAge(22); System.out.println(p1.getName()+p1.getAge()); } }
this關鍵字
this關鍵字代表自身類的物件
注意：this關鍵字必須放在非靜態方法裡面
public class Demo{
private int a;
public Demo(int a){
this.a = a;
}
public int getA(){
return a;
}
public void setA(int a){
this.a = a;
}
}
繼承
- 父類被子類繼承
- 子類可以擁有父類的一些功能
- 繼承是面嚮物件語言的一種設計思想
- 可以提高程式碼的重用性以及程式碼的可擴充套件性
舉個例子
人類:共有姓名屬性
學生類:繼承人類 自有屬性:學號
小學生:繼承學生類
中學生:繼承學生類
大學生:繼承學生類
工人類:繼承人類 自有屬性:工號 工種
什麼樣的關係可以使用繼承?
同一類的東西( is a 關係)
A類 extends Object{}
B類 extends A類{}
C類 extends B類{}
建立父類（People）
package com.ff.javaopp.Day004;
/*
primarySchool類繼承People
PrimarySchool是People的子類(派生類)
父類(基類)
把人類相關的一些公有屬性,行為,定義在people類中
extends關鍵字
當一個類沒有顯示的繼承一類,那麼這個類預設繼承object
object是java所有類的基類 稱超類
*/
public class People {
private String name ;
private int age;
public People(){
System.out.println("人類中的無參的構造方法");
}
public People(String name){
this.name=name;
System.out.println("人類中的有參的構造方法");
}
public void setName(String name ){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public void eat(){
System.out.println(name+"乾飯人,乾飯魂,乾飯都是人上人");
}
}
建立子類（PrimarySchool）
public class PrimarySchool extends People {
private String clas;
public PrimarySchool(){
super("小紅");
System.out.println("小學生中的無參構造方法");
}
public void setClass(String clas){
this.clas=clas;
}
public String getClas(){
return clas;
}
public void play(){
System.out.println("過家家");
}
}
建立子類（MiddleSchool）
public class MiddleSchool extends People{
private String grade;
public void study(){
System.out.println("學習人,學習魂,學習都是人上人");
}
public void setGrade(String grade){
this.grade=grade;
}
public String getGrade(){
return grade;
}
}
建立測試類（PeopleTset）
package com.ff.javaopp.Day004;
public class PeopleTset {
public static void main(String[] args) {
PrimarySchool p = new PrimarySchool();
p.setName("瑞瑞");//父類
p.setAge(21);//父類
p.setClass("學前班");//小學生自己的屬性
System.out.println(p.getName()+p.getAge());//父類
System.out.println(p.getClas());//小學生自己的屬性
p.eat();//父類
p.play();//小學生自己的方法
MiddleSchool M = new MiddleSchool();
M.setName("榮榮");//父類
M.setAge(22);//父類
M.setGrade("高中生");//高中生自己的屬性
System.out.println(M.getName()+M.getAge());//父類
System.out.println(M.getGrade());//高中生自己的屬性
M.study();//高中生自己的屬性
M.eat();//父類
p.hashCode();//呼叫object類中的方法
/*
子類繼承了父類後,可以擁有父類中私有屬性,方法
*/
}
}
在建立子類物件時,會先呼叫父類構造方法,建立父類物件
public class Test {
/*
繼承中的構造方法
在建立一個子類物件時,同時也會建立父類物件
*/
public static void main(String[] args) {
XiaoMing xm= new XiaoMing();
xm.eat();
}
}
super表示父類
super關鍵字代表父類的引用，在程式中主要的用途
在子類構造方法中要呼叫父類的構造方法，需要注意：super語句只能出現在子類構造方法體的第一行。
用“super.成員變數名”來引用父類成員變數
用“super.方法名（引數列表）”的方式訪問父類的方法。
與this的區別，this通常指代當前物件，super通常指代父類。
建立小學生（PrimarySchool）的子類（XiaoMing）
public class XiaoMing extends PrimarySchool{
/*
在呼叫子類方法時,會先呼叫父類的構造方法
*/
public XiaoMing(){
//super(); 構造方法第一行預設使用super();呼叫父類預設無參的構造方法
super();//需要顯示呼叫,必須放在構造方法的第一行
System.out.println("小學生小明中無參的構造方法");
}
}
方法的重寫
為什麼使用方法的重寫？
父類的實現方式不能滿足子類的功能時可以進行重寫
public class XiaoMing extends PrimarySchool{
/*
方法的重寫:當子類中的實現步驟與父類中的實現方式不同時,
可以在子類中將父類中的方法重寫
必須與父類的方法結構相同(返回值,引數)
子類重寫後的方法的許可權範圍要大於等於父類方法的訪問許可權
super表示當前類的父類物件
在子類中可以通過super訪問父類中成員
@Override 註解 標籤
表明該方法是從父類中重寫過來了的
*/
@Override
public void eat(){
System.out.println("小明喜歡吃麵面");
super.eat();//呼叫父類成員
}
public void Question(){
System.out.println("小學生小明喜歡問問題");
}
}
瞭解關聯關係和依賴關係
建立一個Mobile類
public class Mobile {
private String num;
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
}
關聯關係:has-a關係 XXX有XXX
依賴關係:use-a關係 某個類中用到另一個類
public class Person {
private Mobile mobile;//單向關聯 一對一關聯
private Mobile[] mobiles;//單項關聯 一對多關聯
/*
依賴關係,Person中的某個方法中使用到另一個類
*/
public void callPeople(MiddleSchool middleSchool){
middleSchool.study();
middleSchool.setAge(25);//傳遞過來的是引用型別,會改變原來的值
}
}
抽象類abstract
- 如果一個類中沒有包含足夠的資訊來描述一個具體的物件,這樣的類就是抽象類
- 抽象類 也是一個類
- 抽象方法:被abstract關鍵字修飾,沒有方法體,只是作為功能的定義
抽象類的特點:
不能建立物件,因為其中包含了抽象的方法
包含構造方法,在建立子類物件時,可以簡介建立父類物件
建立Animal類
/*
被abstract修飾的類就是抽象類
抽象類中不一定有抽象方法
有抽象方法,那麼這個類必定是抽象類
*/
public abstract class Animal {
String name;
/*
在頂層類中,方法的實現與子類大多不相同,那麼在頂層類中可以將方發聲明為抽象方法
被abstract修飾,沒有方法體
只作為方法的定義
*/
public abstract void eat();
public abstract void sleep();
public void play(){
System.out.println("Animal Play");
}
}
建立子類Dog類
/*
抽象類就是作為定義,讓其他類繼承
一個類繼承抽象類:
要麼將子類宣告為抽象類
要麼重寫抽象類中所有的抽象方法
*/
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗子吃");
}
@Override
public void sleep() {
System.out.println("狗子睡");
}
}
建立子類Cat類
package com.ff.javaopp.Day004.abstractDemo;
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("貓吃魚");
}
@Override
public void sleep() {
System.out.println("貓睡覺");
}
}
建立測試類
package com.ff.javaopp.Day004.abstractDemo;
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
d.eat();
d.sleep();
d.play();
}
多型
同種事物,在不同時刻表現不同的狀態
多型的條件:
- 要有繼承
- 要有方法重寫
- 父類的引用指向子類物件
不使用多型
public class Test {
public static void main(String[] args) {
/* Dog d = new Dog();
d.eat();
d.sleep();
d.play();*/
//Dog d = new Dog();不是多型
Dog dog = new Dog();
Cat cat = new Cat();
Test t = new Test();
t.feedCat(cat);
t.feedDog(dog);
}
public void feedDog(Dog dog) {
dog.eat();
dog.sleep();
}
public void feedCat(Cat cat) {
cat.eat();
cat.sleep();
}
}
程式碼過於冗餘
使用多型
public class Test1 {
public static void main(String[] args) {
Animal dog = new Dog();
//dog.eat();編譯期間看左邊,執行期間看右邊
Animal cat = new Cat();
Test1 t = new Test1();
t.feedAnimal(cat);
t.feedAnimal(dog);
}
public void feedAnimal(Animal animal) {
animal.eat();//
animal.sleep();
}
}
執行結果：
貓吃魚
貓睡覺
狗子吃
狗子睡