萬事萬物皆對象，對象是具有某些屬性和功能的統一體。面向對象開發即不斷地創建對象，使用對象，指揮對象，銷毀對象。
1. 類與對象
類：是一組相關的屬性和行為的集合
對象：是該類事物的具體體現
舉例：學生為一個類，某一具體的學生如班長就是一個對象
1.1 類的組成
**成員變量 + 構造函數 + 成員方法 **
class Person{
public String name;
public Integer age;
public Person(String name,Integer age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
1.2 對象內存圖
創建一個對象，要在棧區，堆區，方法區使用內存，具體見以下的Demo;
public class PersonDemo {
public static void main(String[] args) {
Person p1 = new Person("小紅",11);
Person p2 = new Person("小明",13);
}
}
在內存分配中如下圖：
2. 幾種變量
-
2.1 局部變量與成員變量
-
2.2 成員變量與靜態變量
3. 面向對象的特征
3.1 封裝
是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式.封裝提高了代碼的復用性和安全性。
3.2 繼承
多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那么多個類無需再定義這些屬性和行為，只要繼承那個類即可
3.2.1 格式
class 子類名 extends 父類名 {}
3.2.2 特點
(1)Java只支持單繼承，不支持多繼承。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error
(2) Java支持多層繼承(繼承體系)
class A{}
class B extends A{}
class C extends B{}
3.2.3 注意事項
(1) 子類只能繼承父類所有非私有的成員(成員方法和成員變量)
(2) 子類不能繼承父類的構造方法，但是可以通過super()關鍵字去訪問父類構造方法。
Demo:
class Father {
private int num = 10;
public int num2 = 20;
//私有方法，子類不能繼承
private void method() {
System.out.println(num);
System.out.println(num2);
}
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
class Son extends Father {
public void function() {
//num可以在Father中訪問private
//子類不能繼承父類的私有成員變量
//System.out.println(num);
System.out.println(num2);
}
}
class ExtendsDemo {
public static void main(String[] args) {
// 創建對象
Son s = new Son();
//子類不能繼承父類的私有成員方法
//s.method();
s.show();
s.function();
}
}
3.3 多態
某一個事物，在不同時刻表現出來的不同狀態.前提是要有繼承關系,有方法重寫
,有父類引用指向子類對象。
Demo：
public class PolymDemo {
public static void main(String[] args) {
Animal animal1 = new Dog();
animal1.eat(); // 狗吃肉
Animal animal2 = new Cat();
animal2.eat(); // 貓吃魚
}
}
class Animal {
public void eat() {
System.out.println("eat");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("貓吃魚");
}
}
4. 類的初始化過程
** Demo:**
public class ClassInitDemo {
public static void main(String[] args) {
Base tmp = new Derived();
/** 初始化過程
* Base:static init block invoked.. 1
* Derived:static init block invoked... 2
* Base:normal block invoked.. 3
* Base:constructor invoked.. 4
* Derived:normal block invoked.. 5
* Derived:constructor invoked.. 6
*/
}
}
class Base {
//1. 初始化父類中的靜態成員變量和靜態代碼塊
static int b;
static {
System.out.println("Base:static init block invoked..");
}
//3. 初始化父類的普通成員變量和代碼塊
int a;
{
System.out.println("Base:normal block invoked..");
}
//4. 執行父類的構造方法
public Base() {
System.out.println("Base:constructor invoked..");
}
}
class Derived extends Base {
//2. 初始化子類中的靜態成員變量和靜態代碼塊
static int e = 4;
static {
System.out.println("Derived:static init block invoked...");
}
//5. 初始化子類的普通成員變量和代碼塊
int d;
{
System.out.println("Derived:normal block invoked..");
}
//6. 執行子類的構造方法
public Derived() {
System.out.println("Derived:constructor invoked..");
}
}
5. 抽象類
在Java中，一個沒有方法體的方法應該定義為抽象方法，而類中如果有抽象方法，該類必須定義為抽象類。
-
格式
abstract class 類名 {
public abstract void 抽象方法名();
public void 非抽象方法名();
}
** 注意: **
(a)抽象類不一定有抽象方法，有抽象方法的類一定是抽象類
(b)抽象類有構造方法，但不能被初始化，構造方法用來給子類訪問其成員變量
(c)abstract不能與private,final,static關鍵字共存
6. 接口
為了體現事物功能的擴展性，Java中就提供了接口來定義這些額外功能，并不給出具體實現
6.1 格式
//接口類
interface 接口名 {
void 方法1();
String 方法2();
}
//實現類
class 類名 implements 接口名 {
void 方法1(){
do something;
}
String 方法2(){
do something;
}
}
注意：
(a)接口不能實例化
(b)接口的子類要么是抽象類,要么重寫接口中的所有抽象方法
6.2 接口成員的特點
-
成員變量
只能是常量
默認修飾符 public static final
-
構造方法
沒有，因為接口主要是擴展功能的，而沒有具體存在成員方法
-
只能是抽象方法
默認修飾符 public abstract
6.3 類與接口的關系
-
類與類：
繼承關系，只能單繼承，但是可以多層繼承
-
類與接口：
實現關系，可以單實現，也可以多實現。還可以在繼承一個類的同時實現多個接口
-
接口與接口：
繼承關系，可以單繼承，也可以多繼承
6.4 接口與抽象類對比
7. 內部類
把類定義在其他類的內部，這個類就被稱為內部類。
訪問特點： 內部類可以直接訪問外部類的成員，包括私有。外部類要訪問內部類的成員，必須創建對象。
Demo:
class Outer {
private int num = 10;
class Inner {
public void show() {
//可以直接訪問外部類的私有成員變量
System.out.println(num);
}
}
public void method() {
//找不到符號
//show();
Inner i = new Inner();
i.show();
}
}
-
7.1 成員內部類
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
-
7.2 局部內部類
class Outer {
public void method() {
final int n = 100;
class Inner {
public void show() {
System.out.println(n);
}
}
Inner i = new Inner();
i.show();
}
}
class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
-
7.3 匿名內部類
abstract class Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
class PersonTest {
public static void main(String[] args) {
//如何調用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
pd.method(new Person() {
public void show() {
System.out.println(“show”);
}
});
}
}
