一、面向對象（上延續版）

?1、匿名對象

概念：即沒有名字的對象

格式：new 類名（）;

匿名對象調用方法：new 類名().成員方法名();
好處：節省內存空間，在堆內產生，不需要從棧中開辟空間，使用完后立刻被jvm中的垃圾回收器回收

2、局部變量和成員變量的區別

1)代碼位置
成員變量：類中，方法外
局部變量：一般在方法之內
2）內存中的位置
成員變量：堆內存中，和new有關
局部變量：占內存中，和方法有關
3）生命周期不同
成員變量：隨從對象的創建而存在，對象創建完畢后會被jvm中的垃圾回收器回收
局部變量：隨著方法的調用而存在，當方法使用結束而消失
4）初始值
成員變量：系統會給成員變量進行默認的初始化，String的初始值為null，int的初始值為0
局部變量：必須進行初始化賦值

3、this的認識

this：用來提供本類中地址值的引用、

舉例：

public class Student {private String name ; //姓名public void setName(String name){this.name = name ; //等號右邊，指向該類（Student）的地址，等號左邊為set接收的數據}public String getName(){return name ;} }

?4、一個類的成員方法

類的成員變量：描述這個類有哪些屬性

類的成員方法：setXXX()/getXXX():賦值和獲取值的方法

類的構造方法?
1）這個方法名和類名相同
2）這個方法沒有void
3）構造方法可以重載：分為有參/無參構造方法

構造方法的目的：為了方便成員相關數據進行初始化

注意：當一個類中沒有構造方法的時候，系統會默認提供一個無參構造方法（不顯示在代碼中），但，如果系統中已經有了一個有參構造方法了，此時系統不會提供無參構造方法，需要自己手動輸入一個無參構造方法

一個標準類的寫法：

? ? ? ? 成員變量私有化

? ? ? ? 成員獲取值和輸出值的方法（setXXX()/getXXX()）
? ? ? ? 提供有參/無參構造方法?

public class Phone {private String brand ; //品牌private int price ; //價格private String color ; //顏色private String memoryCache ;//內存//無參構造方法public Phone() {}//有參構造方法public Phone(String brand, int price, String color, String memoryCache) {this.brand = brand;this.price = price;this.color = color;this.memoryCache = memoryCache;}//對外的公共訪問方法setXXX()/getXXX()public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public int getPrice() {return price;}public void setPrice(int price) {this.price = price;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public String getMemoryCache() {return memoryCache;}public void setMemoryCache(String memoryCache) {this.memoryCache = memoryCache;}//打電話public void callPhone(String toName){System.out.println(brand+"可以給"+toName+"打電話");}//發短信public void sendMsg(String toName){System.out.println("可以給"+toName+"發短信了...");} }

5、static關鍵字?

定義：是一種屬性的描述，可以是變量，可以是方法（靜態的，靜止的）

特點：
1）被靜態修飾的隨著類的加載而價值，優先于對象
2）不能和this一起使用
3）本身含義結束共享，公用；可以多個對象公用

靜態的使用范圍：靜態只能訪問靜態。

6、代碼塊

分類：靜態代碼塊，構造代碼塊，構造方法

優先級：靜態代碼塊>構造代碼塊>構造方法

舉例：

class Root {static {System.out.println("Root的靜態初始化塊");//1}{System.out.println("Root的普通初始化塊");//4}public Root() {System.out.println("Root的無參數的構造器");//5} } class Mid extends Root {static {System.out.println("Mid的靜態初始化塊");//2}{System.out.println("Mid的普通初始化塊");//6}public Mid() {System.out.println("Mid的無參數的構造器");//7}public Mid(String msg) {this();System.out.println("Mid的帶參數構造器，其參數值：" + msg);//8} }class Leaf extends Mid {static {System.out.println("Leaf的靜態初始化塊");//3}{System.out.println("Leaf的普通初始化塊");// 9}public Leaf() {super("hello");System.out.println("Leaf的構造器");//10} }public class LeafTest {public static void main(String[] args) {new Leaf();} }

二、面向對象（中）

1、繼承

定義：將多個類的共性內容抽取出來，房子一個獨立的類中，讓這個類和其他類產生一種關系就叫做繼承?

格式：

class 父類名{ 共性內容：姓名，年齡父類中的方法setXXX/getXXX等 } class 子類名 extends 父類名{}

?繼承的好處：
1）可以提高代碼的復用性
2）可以提高代碼的維護性
3）類與類的繼承關系，是后面“多態”的前提條件

特點：
1）繼承只能接受單繼承，不能多繼承
2）雖然不能多繼承，但是可以多層繼承

舉例：

class A{public void show1(){System.out.println("第一繼承");} } class B extends A{public void show2(){System.out.println("第二繼承");} } class C extends B{public void show3(){System.out.println("第三繼承");} } public class ExtendsDemo {public static void main(String[] args) {C c = new C() ;c.show3(); //c本身的方法c.show2(); //尋找B的方法c.show1(); //A的方法} }

?2、重寫

引入：子類在調用父類方法時有兩種情況
情況一：子類方法和父類方法名不相同，可以分別直接調用；
情況二：子類方法和父類方法名相同時：權限修飾符，返回值類型，參數列表都一樣時，如果主函數使用了該方法，則會發生子類方法將父類方法覆蓋的情況--->方法重寫
override

舉例：

class A {public void show(){System.out.println("我是A");} } class B extends A{public void show(){System.out.println("我是B");} } public class Demo{public static void main(String[] args) {B b =new B();b.show(); //此時父類和子類的方法名相同，則會出現子類方法將父類方法覆蓋，輸出應為：我是B} }

3、final關鍵字?

?本身含義：最終的，無法更改的

?特點：
1）final可以修飾類，該類不能被繼承
2）final可以修飾變量，此時這個變量是一個”常數“
3）final可以修飾成員方法，被修飾的方法不能被子類重寫

class A {final int a = 20;public void show(){int a =30;}} class B extends A {} public class FinalDemo {public static void main(String[] args) {B b =new B();b.show();System.out.println(b.a);} }

三、面向對象（下）

1、多態

1.什么是多態

宏觀角度：一個事務在不同時刻體現的狀態不同
微觀角度：具體對象在內存中的變化

2.多態的前提條件

1）必須有繼承關系，無繼承，不提多態
2）必須存在方法重寫
3）必須存在父類引用子類對象
格式：

父類名 對象名 = new 子類名() ; //向上轉型:使用的父親的東西

3.多態的成員訪問特點（很重要）?

1）成員變量：編譯看左，運行看左；
2）成員方法：編譯看左，運行看右；?
3）構造方法：多態的前提條件，有繼承關系，跟繼承一樣，分層初始化先執行父類的構造方法，然后進行子類的構造方法

4.多態的弊端

當多態的前提條件滿足后，出現了多態的弊端
無法調用子類的特有功能！

解決方法1，重新創建自己的子類對象
解決方法2，
向下轉型：
格式：

前提必須向上轉型Fu fu = new Zi() ; Zi z = (Zi)fu ; //強轉的語法

5.多態的好處

1）提高代碼的復用性，由繼承保證
2）提高代碼的延展性，由多態保證

實例：

class Animal{public void eat(){System.out.println("動物都需要吃飯");}public void sleep(){System.out.println("動物都需要休息");} } class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗吃骨頭");}@Overridepublic void sleep() {System.out.println("狗側著睡");}public void lookDoor() {System.out.println("狗看門");} } class Cat extends Animal{@Overridepublic void eat() {System.out.println("貓吃魚");}@Overridepublic void sleep() {System.out.println("貓躺著睡");}public void catch() {System.out.println("貓抓老鼠");} } public class DuoTaiDemo {public static void main(String[] args) {Animal a = new Cat() ;a.eat();a.sleep();Cat c =(Cat) a;c.catch();Animal a2 = new Dog() ;a2.eat();a2.sleep();Dog d =(Dog) a2;d.lookDoor();} }

2、抽象類

1.什么是抽象類？

定義：在一個類中，如果由抽象方法，這個類必須為抽象類

2.抽象的方法格式：

根據寫方法的格式一樣,加入一個關鍵字abstract,而且沒有方法體{} public abstract 返回值類型 方法名(空參/帶參) ;

3.抽象類的特點

1）不能實例化（不能創建對象）
2）必須強制子類進行抽象方法重寫

4.抽象類的成員特點：

1）成員變量：抽象類的成員變量可以是常量（被final自定義）/變量
2）成員方法：可以是抽象類方法也可以是非抽象類方法
3）構造方法：可以定義無參/有參

abstract class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public abstract void eat();public abstract void sleep(); } class Student extends Person{private String sno;public Student (){}public Student(String name, int age, String sno) {super(name, age);this.sno = sno;}public String getSno() {return sno;}public void setSno(String sno) {this.sno = sno;}@Overridepublic void eat() {System.out.println(getName()+"喜歡吃辣條");}@Overridepublic void sleep() {System.out.println(getName()+"在學校宿舍睡覺");}public void study(){System.out.println(getName()+"說，我愛學習");} } class Worker extends Person{private String wno;public Worker() {}public Worker(String name, int age, String wno) {super(name, age);this.wno = wno;}public String getWno() {return wno;}public void setWno(String wno) {this.wno = wno;}@Overridepublic void eat() {System.out.println(getName()+"喜歡吃肉");}@Overridepublic void sleep() {System.out.println(getName()+"在工地宿舍休息睡覺");}public void work(){System.out.println(getName()+"說，我愛工作");} } public class PersonTest {public static void main(String[] args) {Person p =new Student("張三",18,"學生001");Student s = (Student) p;System.out.println(p.getName()+"---"+p.getAge()+"---"+s.getSno());p.eat();p.sleep();s.study();System.out.println("--------------------------------------------");Person p2 =new Worker("李四",29,"工人001");Worker w = (Worker) p2;System.out.println(p2.getName()+"---"+p2.getAge()+"---"+w.getWno());p2.eat();p2.sleep();w.work();} }

3、接口

1.什么是接口？

接口體現的是事務的一種額外功能

2.格式

interface 接口名{ //命名規范和類名命名一樣,見名知意 "大駝峰命名法"只能為抽象方法 } 接口的子類----"子實現類" class 子類名 implements 接口名{//實現類必須實現接口的抽象方法,否則報錯} //接口比抽象類還抽象

2.特點

接口最大的特點：不能實例化

3.接口的成員特點

1）成員變量：只能是常量，存在默認修飾符：public static final
2）成員方法：之你呢個是抽象方法，存在默認修飾符：public abstract
3）構造方法：沒有構造方法

?實例：

interface Area {void calculateArea(); } class MyCircle implements Area{private double radius;public MyCircle() {}public MyCircle(double radius) {this.radius = radius;}public double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}@Overridepublic void calculateArea() {System.out.println("圓的面積為："+(3.14*getRadius()*getRadius()));} } class MyRectangle implements Area{private double length;private double width;public MyRectangle() {}public MyRectangle(double length, double width) {this.length = length;this.width = width;}public double getLength() {return length;}public void setLength(double length) {this.length = length;}public double getWidth() {return width;}public void setWidth(double width) {this.width = width;}@Overridepublic void calculateArea() {System.out.println("矩形的面積為"+(getLength()*getWidth()));} } import java.util.Scanner; public class Test {public static void main(String[] args) {Scanner sc =new Scanner(System.in);System.out.println("-----------圓形-------");System.out.print("請輸入圓的半徑：");double a = sc.nextDouble();Area a1 =new MyCircle(a);a1.calculateArea();System.out.println("-----------矩形-------");System.out.println("請輸入矩形的長和寬：");double b = sc.nextDouble();double c = sc.nextDouble();Area b2 =new MyRectangle(b,c);b2.calculateArea();} }

四、對面向對象中的幾個問題

1、關于Java中面向對象牽扯關系問題

Java中最基本的單位：類

類和類：繼承關系 extends,Java中只支持單繼承和多層繼承，不支持多繼承

類和接口：實現關系implement 一個類可以實現多個接口

接口與接口：繼承關系 extends

2、?在使用多態是出現ClassCastException，說明了什么？

ClassCastException屬于運行事情異常的一種：代表“類轉換異常”
使用多態操作向下轉型時使用不當，堆內存中信息和占內存信息沒有父子關系

3、abstract不能和那些關鍵字使用?

static：靜態方法算不上方法重寫
private：因為abstract需要被重寫，所以不能私有
final：被final修飾的成員方法不能被重寫，違背了抽象類的要求?

4、super關鍵字，和this的關系?

super:代表父類的空間標識(代表父類的地址值引用)

?區別：
1）
this.變量名???????????訪問本類的成員變量
super.變量名????????訪問父類的成員變量
2）
this.方法名()????????訪問本類的成員方法
super.方法名()??????訪問父類的成員方法
3）
this()??????????????????????訪問本類無參構造方法
super()??????????????????訪問父類的無參構造方法
4）
this(xxx)????????????????訪問本類的有參構造方法
super(xxx)?????????????訪問父類的有參構造方法?

5、接口和抽象類的區別

從定義來說：
this:用來提供本類中地址值的引用
super:用來提供空間上的地址值(即,父類的地址值的引用)

區別：

成員變量:?抽象類:可以是變量,也可以是自定義常量
?????????????????接口:?成員變量只能是常量.
成員方法?:抽象類:?抽象方法/非抽象方法
? ? ? ? ? ? ? ? ?接口:只能是抽象方法
構造方法:?抽象類?:無參構造,有參構造都可以存在?存在繼承關系,分層初始化
? ? ? ? ? ? ? ? ?接口:無構造方法.
抽象類用?entends??????

接口用implements?

6、什么是方法重寫 ，什么是方法重載

方法重寫:出現在繼承中,描述子類繼承父類時,當父類方法與子類方法名重名時,子類方法將覆蓋掉父類方法
方法重載:方法定義的時候,方法名相同,參數列表不同,與返回值無關,

7、方法的形式參數如果是引用類型和基本類型

為基本類型時:只需要在括號內輸入基本類型數值即可

為引用類型時:需要傳遞是當前類的具體類對象

總結

以上是生活随笔為你收集整理的JAVA学习_week3的全部內容，希望文章能夠幫你解決所遇到的問題。

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