1.1抽象類

什么是抽象類？
使用abstract修飾的類稱為抽象類

public abstract class Person { }

抽象類的特征

抽象類可以創建對象嗎？不可以

public class TestPerson {public static void main(String[] args) {//Person p = new Person(); //報錯} }

抽象類可不可以有構造方法？可以

public abstract class Person {public Person() {System.out.println("Person類中的無參構造方法");} }

抽象類中構造方法的作用，是提供給子類調用

public class Student extends Person{public Student() {super();//調用直接父類的無參構造方法System.out.println("Student類的無參構造方法");} }

抽象類中可以包含哪些成員
成員變量，成員方法，靜態方法，構造方法，final修飾的方法，抽象方法

public abstract class Person {//(1)成員變量/實例變量/屬性private String name;//姓名//(2)成員方法public void info() {System.out.println("大家好，我叫" + name);}//(3)靜態方法public static void show() {}//(4)構造方法public Person() {System.out.println("Person類中的無參構造方法");}//(5)final修飾的方法，只能被子類調用，不允許被子類重寫public final void fun() {} }

1.2抽象方法

什么是抽象方法
使用abstract修飾的方法稱為抽象方法

public abstract void print();

抽象方法的特征

抽象方法不允許有方法體，只能以“;”結尾

抽象方法只能聲明在抽象類中（含有抽象方法的類必須是抽象類）

抽象類中可以包含0個或多個抽象方法

抽象方法必須被子類實現

如果子類不能實現父類中的抽象方法，那么子類也必須是抽象類
總結:abstract可以修飾類和方法

1.3什么情況下使用抽象方法和抽象類

通過抽象類，可以避免子類設計的隨意性。通過抽象類，我們就可以做到嚴格限制子類的設計，使子類之間更加通用。（程序的可拓展和可維護性）
**什么情況下使用抽象類？**父類的名稱比較抽象，創建對象無意義。
Animal動物類–》》abstract,–>abstract shout()
每一種動物，分別實現發聲的方法

public abstract class Animal {public abstract void shout(); }class Dog extends Animal{@Overridepublic void shout() {System.out.println("小狗，汪汪叫。。。");}}class Cat extends Animal {@Overridepublic void shout() {System.out.println("小貓，喵喵叫。。。。");}} public class TestAnimal {public static void main(String[] args) {//父類引用指向子類對象Animal dog = new Dog();Animal cat = new Cat();//調用相同的方法dog.shout();cat.shout();//運行的結果，各不相同（各個子類實現之后的結果）} }

2.1初識接口

如果一個類中所有的方法均為abstract方法，那么這個類就可以聲明為接口

public abstract class MyClass {public abstract void show();public abstract String fun();public abstract int [] method(); }

可以改為如下代碼

public interface MyInterface {void show();String fun();int [] method(); }

2.2接口的定義

使用interface修飾，是一種數據類型，引用數據類型
接口的定義:

public interface MyInterface {void show(); }

接口中可以包含什么？

抽象方法
public abstract(可以省略)方法：

void show();String fun();int [] method();

非抽象方法

/**JDK1.8新特性，必須使用default關鍵字*/public default void method2() {}

屬性（public static final）常量，public static finial可以省略不寫

String name = "張三";public static final String name2 = "張三";

接口中可不可以包含構造方法？不允許，因為接口不是類
接口和類的關系

類去實現接口中的抽象方法，實現關系，implements

public class InterfaceImpl implements MyInterface{@Overridepublic void show() {}@Overridepublic String fun() {return null;}@Overridepublic int[] method() {return null;}}

一個類存在繼承關系，又存在實現關系？extends在前？implements在前？
繼承 父子關系 親爹
實現 實現關系 干爹
extends在前 implements在后

public class Student extends Person implements play{}

如果父類與接口中有完全相同的方法（一模一樣），子類/實現類所實現的方法是父類的？還是接口的？
父類優先于接口，子類實現的是父類中的方法

如果父類中于接口中有同名方法，對子類/實現類有什么要求呢？
父類與接口中的方法，在子類/實現類中構成方法的重載

3.1接口的特征

接口的傳遞性

public interface InterfaceA {public void show(); } interface InterfaceB extends InterfaceA{} interface InterfaceC extends InterfaceB{} class Impl implements InterfaceC{@Overridepublic void show() {}}

接口的繼承性（多繼承）

public interface InterfaceA {public void show(); } interface InterfaceB{} interface InterfaceC extends InterfaceB,InterfaceA{} class Impl implements InterfaceC{@Overridepublic void show() {}}

3.2使用接口的意義

可以實現設計和實現的分離，抽象出N多不同類的共同點。
舉例：飛機，鳥，球，導彈，宇宙飛船……

繼承is-a關系三角形 is a 幾何圖形

		鳥 is a 球？不成立
接口	has-a關系	手機 has a 拍照的功能
		飛機 has a 飛行的能力
		鳥 has a 飛行的能力

接口體現的是一種能力

public interface Fly {public void flying();//飛行的能力 } class AirPlane implements Fly{@Overridepublic void flying() {System.out.println("飛機在祖國的藍天上自由飛翔……");} } class Bird implements Fly{@Overridepublic void flying() {System.out.println("小鳥唱著動聽的歌，在天空中飛……");} } class FootBall implements Fly{@Overridepublic void flying() {// TODO Auto-generated method stubSystem.out.println("球被踢了一腳，劃了個美麗的弧線飛到了對方的球門里……");} } public class Test {public static void main(String[] args) {//接口類型（引用數據類型）指向實現類的對象Fly airPlane = new AirPlane();Fly bird = new Bird();Fly football = new FootBall();//調用相同的方法airPlane.flying();bird.flying();football.flying();//運行結果，不相同} }

總結：使用接口實現多態的步驟

編寫接口

實現類實現接口中的方法

接口（類型）new 實現類對象
面向接口的編程

4.1 什么是內部類？

將一個類定義在另一個類的內部，該類就稱為內部類
Outer$Inner.class

public class Outer {//外部類class Inner{//內部類} }

內部類的優缺點
優點：內部類可以直接訪問外部類的私有屬性
缺點：破壞了類的結構
內部類的分類
一、 成員內部類
內部類相當于外部類的成員

public class Face { //臉private String shape = "瓜子臉";//私有屬性public class Nose{private String shape = "高鼻梁";public void breath() {//當內部類與外部類有相同的屬性時，在訪問外部類的屬性時，需要加上外部類的類名.this.屬性名System.out.println("鼻子長在了"+Face.this.shape+"形狀的臉上");System.out.println(shape);System.out.println("在使用鼻子呼吸！");}} } public class TestFace {public static void main(String[] args) {//創建的是臉的對象Face f = new Face();//創建鼻子的對象Nose n = f.new Nose();//調用方法n.breath();} }

內部類作為外部類的成員，可以直接訪問外部類的成員（包括private成員）,反之則不行

內部類作為外部類成員，可聲明為private、默認、protected或public.

內部類成員只有在內部類的范圍之內是有效的。

用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問權限

二、靜態內部類

public class Outer {private static String name = "張三";//靜態內部類，不允許訪問外部類的非static屬性static class Inner{public void show() {System.out.println(name);}}//如果內部類中的方法為static方法，那么內部類也必須為靜態內部類static class Inner2{public static void show() {}} } public class TestStaticInner {public static void main(String[] args) {//創建內部類的對象 Outer.Inner i = new Outer.Inner();i.show();//訪問的是靜態內部類中的靜態方法Outer.Inner2.show();} }

三、方法中的內部類
只能在方法中使用，相當于方法中的局部變量

public class Outer {int a = 10;//方法中的局部變量//Outer的成員方法public void show() {//內部類相當于show方法中的局部變量，使用范圍只能在show方法中class Inner{public void fun() {System.out.println("a=" +a);}}//創建內部類的對象new Inner().fun();} }

JDK1.8新特性
JDK1.8之前方法中的內部類要訪問外部類的局部變量，必須加上final關鍵字（常量）
JDK1.8開始，在訪問外部類的局部變量時，則可以不加final關鍵字
四、匿名內部類（存在繼承或實現關系）

可以實現一個接口，或者繼承一個父類

只能實現一個接口

適合創建那些只需要一次使用的類，不能重復使用

public abstract class Father {public abstract void dream(); }class Son extends Father{@Overridepublic void dream() { }} class Test{public static void main(String[] args) {Father f = new Son();Father f2 = new Father(){@Overridepublic void dream() {System.out.println("實現父親的偉大夢想"); } };f2.dream();} }

5.String類常用方法

5.1String類的定義

String是不可變字符序列

5.2String類的常用方法

char charAt(int index)返回字符串中第 index 個字符。

boolean equalsIgnoreCase(String other) 如果字符串與other
相等（忽略大小寫），則返回 true

int indexOf(String str) lastIndexOf() 查找指定字符串
出現的位置

int length()返回字符串的長度。

String replace(char oldChar,char newChar)返回一個新串，
它是通過用 newChar 替換此字符串中出現的所有
oldChar 而生成的

boolean startsWith(String prefix)如果字符串以 prefix 開始，
則返回 true

boolean endsWith(String prefix) 如果字符串以 prefix 結
尾，則返回 true

String substring(int beginIndex), String substring(int beginIndex,int endIndex)返回一個新字符
串，該串包含從原始字符串 beginIndex 到串尾或 endIndex-1
的所有字符

String toLowerCase()返回一個新字符串，該串將原始字符
串中的所有大寫字母改成小寫字母

String toUpperCase()返回一個新字符串，該串將原始字
符串中的所有小寫字母改成大寫字母

String trim() 返回一個新字符串，該串刪除了原始字
符串頭部和尾部的空格

package com.java.string;public class TestString {public static void main(String[] args) {String str = "abc";//聲明了一個String類型的變量，其值為“abc”；System.out.println(str);/**String類相當于char類型的數組，數組的長度一旦創建不能更改，value的數組還使用了final進行修飾*//**String類的常用方法*/System.out.println(str.charAt(0));System.out.println(str.equalsIgnoreCase("ABc"));//忽略大小寫的比較System.out.println(str.indexOf("b")+"\t"+str.indexOf("k"));//找到返回索引，找不到返回-1System.out.println(str.indexOf(98)+"\t"+str.indexOf('b'));//自動類型轉換 char-->intString str2 = "helloworld";System.out.println(str2.indexOf("o")+"\t"+str2.lastIndexOf("o"));//lastIndexOf反向搜索System.out.println(str2.indexOf("o",5)+"\t"+str2.lastIndexOf("o",3)+"\t"+str2.lastIndexOf("o",7));System.out.println("字符串字符的個數"+str2.length());System.out.println(str2.replace('o', 'P'));System.out.println(str2);System.out.println(str2.startsWith("hell"));//以XXX開頭System.out.println("Io.java".endsWith(".java"));//以XXX結尾System.out.println(str2.substring(3));//一直截取到字符串的結尾System.out.println(str2.substring(3, 7));//含頭不含尾System.out.println(str2);System.out.println("JAVA".toLowerCase()+"\t"+"java".toUpperCase());String str3 = " hello world ";System.out.println(str3.length()+"\t"+str3.trim().length());System.out.println(str3);str3 = str3.trim();System.out.println(str3);} }

String類和常量池

package com.java.string;public class TestString {public static void main(String[] args) {String str = "apple";String str2 = "banana";String str3 = "cat";String str4 = "dog";String str5 = "app";/**求兩個字符串的長度的最小值，使用循環，比較對應位置上的字母，如果不相同，則兩個對應位置上字母的ASCII嗎值相減*/System.out.println(str.compareTo(str2));//a-b -1System.out.println(str.compareTo(str3));//a-c -2System.out.println(str.compareTo(str4));//a-d -3//兩個字符串的長度相差System.out.println(str.compareTo(str5));//5-3 /**String類的構造方法*/String s1 = new String();//創建了一個長度為0的字符串String s2 = null;//沒有創建對象，只是聲明了String類型的對象s2String s3 = new String("hello");//通過char類型的數組構造String對象char [] c = {'a','b','c'};String s4 = new String(c);byte [] b = {97,98,99};String s5 = new String(b);String s6 = new String(c, 0, 2);System.out.println("s6:"+s6);String s7 = new String(b, 1, 2);System.out.println("s7:" +s7);}} public class TestString2 {public static void main(String[] args) {String str1 = "abc";String str2 = "a" + "b" + "c";String str3 = new String("abc");String str4 = str3+"";String str5 = new String("abc");System.out.println("str1==str2:"+(str1==str2));//tureSystem.out.println("str1==str3:"+(str1==str3));//falseSystem.out.println("str1==str4:"+(str1==str4));//falseSystem.out.println("str3==str5:"+(str3==str5));//false} }

什么情況會在堆里開空間？
等號右側：

有變量參與運行

使用了關鍵字new

字符串相等的判斷

== ：比較兩個字符串內存地址是否相等
equals(Object obj):用于比較兩個字符串對象的內容是否相等

public class TestString {public static void main(String[] args) {String str = "abc";String str2 = new String("abc");System.out.println("兩個對象的內存地址是否相等" + (str==str2));/**比較對應位置上的字符是否相等，如果都相等，返回true，否則，返回false*/System.out.println("兩個對象的內容是否相等："+(str.equals(str2)));/**因為person對象instanceof String的結果為false,所以直接返回false*/System.out.println("String對象與Person對象的內容是否相等："+(str.equals(new Person())));} } class Person{}

String類型重寫equals方法

public boolean equals(Object anObject) { //Object作方法的形式參數，多態的一種表示形式（str2,new Person()）if (this == anObject) { //地址相同，內容一定相同return true;}if (anObject instanceof String) {//引用數據類型的一個判斷 String anotherString = (String)anObject; //向下類型轉換，轉換成真實的String類型int n = value.length; //獲取的是str字符串中字符的個數if (n == anotherString.value.length) { //如果兩個字符串中字符的個數相等char v1[] = value; //str {'a','b','c'} str2 {'a','b','c'}char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i]) return false;i++;}return true;}}return false;}

總結

以上是生活随笔為你收集整理的面向对象深化的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。