java 面向對象編程

丹楓無跡 2021-04-25

展開全文

什么是面向對象

回顧方法的定義與調用

方法的定義

import java.io.IOException;

//Demo01 類
public class Demo01 {

    //main方法
    public static void main(String[] args) {

    }

    public String sayHello(){
        return "helloWorld";
    }
    
    public void readFile(String file) throws IOException{
        
    }

}

方法的調用

public class Demo02 {

    public static void main(String[] args) {

        //非靜態(tài)方法這樣
        new Student().say();

        //或者
        Student student=new Student();
        student.say();


    }

    //static 的方法是和類一起加載的，存在較早
    public static void a(){

        // b(); //這里會報錯，不能調用!!!!!!!

    }

    //類實例化之后才存在
    public void b(){

    }
}

//值傳遞
public class Demo03 {
    public static void main(String[] args) {

        int a=1;
        System.out.println(a);//1
        change(a);
        System.out.println(a);//1

    }

    //返回值為空
    public static void change(int a){
        a=10;
    }

}

//引用傳遞: 傳遞的對象，本質還是值傳遞
//對象要理解透徹、內存要理解透徹！！?。。。。?！
public class Demo04 {

    public static void main(String[] args) {

        Person person = new Person();
        System.out.println(person.name);//null
        change(person);
        System.out.println(person.name);//wda

    }

    public static void change(Person person){
        //person 是一個對象：指向的--》Person person = new Person(); 這是一個具體的人可以改變屬性
        person.name ="wda";
    }

}


//定義了一個Person類，有一個屬性
class Person{
    String name;//null
}

類與對象的創(chuàng)建

public class Student {

    //屬性；字段
    String name;//null
    int age;//0

    //方法
    public void study(){
        System.out.println(this.name+"在學習");
    }



}

/*
public static void main(String[] args) {

        //類：抽象的，需要實例化
        //類實例化后會返回一個自己的對象！
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.age=3;
        xiaoming.name="ming";

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

    }
 */

構造器詳解

package com.oop.demo02;

//java-->會生成一個class文件
public class Person {

    //一個類即使什么都不寫，也會存在一個方法
    //顯式的定義構造器
    String name;
    int age;

    //構造器的功能
    //實例化初始值
    //1.使用new關鍵字，本質是在調用構造器
    //2.用來初始化值
    public Person(){
        this.name="safa";

    }

    //有參構造器:一旦定義了有參構造，無參就必須顯式定義
    public Person(String name){
        this.name=name;
    }

    //alt+ insert 快捷定義構造器


}

/*
public static void main(String[] args) {

        //new 實例化了一個對象
        Person person = new Person("aaa");
        System.out.println(person.name); //aaa

    }
    構造器：
    1.和類名相同
    2.沒有返回值
    作用：
    1.使用new關鍵字，本質是在調用構造器
    2.用來初始化值
    注意點：
    1.一旦定義了有參構造，如果想使用無參構造，無參就必須顯式定義
    alt+ insert 快捷定義構造器
    this.=
 */

創(chuàng)建對象內存分析

package com.oop.demo03;

public class Pet {
    public String  name;
    public int age;

    //無參構造

    public void shout(){
        System.out.println("叫了一聲");;
    }
}

/*
public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name="wangcai";
        dog.age=3;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);

        Pet cat = new Pet();

    }
 */

封裝詳解

package com.oop.demo04;

//private 私有
public class Student {

    //封裝大多數(shù)時候是對屬性來說的，方法里面用的比較少
    /*
        1.提高程序的安全性
        2.隱藏代碼的實現(xiàn)細節(jié)
        3.統(tǒng)一接口
        4.系統(tǒng)可維護性增加了
    */

    // 名字
    //屬性私有
    private String name;

    //學號
    private int id;

    //性別
    private char sex;

    //年齡
    private int age;

    //提供一些可以操作這個屬性的方法
    //提供一些pubLicde的get、set方法

    //get 獲得這個數(shù)據(jù)

    public String getName(){
        return this.name;
    }

    //set 給這個數(shù)據(jù)設置值
    public void setName(String name){
        this.name=name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){
            this.age = 3;
        }else {
            this.age=age;
        }

    }

    //學習（）
    //睡覺（）


}

/*
public static void main(String[] args) {
        Student s1 =new Student();
        // s1.name  會報錯

        s1.setName("sfa");
        s1.getName();

        //alt + insert 可以智能生成get set!!!!!!!!!!

        s1.setAge(999);//不合法的

        System.out.println(s1.getAge());

    }
 */

繼承

基礎

package com.oop;

import com.oop.demo05.Student;


public class Application {
    public static void main(String[] args) {
        Student student =new  Student();
        student.say();
        System.out.println(student.money);
        //System.out.println(student.money_private);
        //報錯，說明父類私有的屬性不能繼承
    }
}

package com.oop.demo05;

//在Java中，所有的類，都默認直接或間接繼承object類
//人 父類
public class Person /*extends Object*/{

    //public
    //protected
    //default
    //private
    public int money =10_0000_0000;

    private int money_private=10;

    public void say(){
        System.out.println("說了一句話");
    }

}

package com.oop.demo05;

//學生 is 人  派生類
//子類繼承了父類，就會擁有父類的全部方法！！！
public class Student extends Person{

    //ctrl+h  打開繼承樹?。。。。?！

}

package com.oop.demo05;

//Teacher is Person  派生類
public class Teacher extends Person{
}

super詳解

package com.oop;

import com.oop.demo05.Student;


public class Application {
    public static void main(String[] args) {
        Student student =new  Student();
        //Person無參構造執(zhí)行了
        //Student 無參執(zhí)行了



        //student.test("aa");
        student.test1();
    }
}

package com.oop.demo05;

//在Java中，所有的類，都默認直接或間接繼承object類
//人 父類
public class Person /*extends Object*/{

    //public
    //protected
    //default
    //private
    public int money =10_0000_0000;

    private int money_private=10;

    protected String name="ks";

    //public-->private則出錯，私有的東西無法繼承
    public void print(){
        System.out.println("person");
    }

    public void say(){
        System.out.println("說了一句話");
    }

    public Person() {
        System.out.println("Person無參構造執(zhí)行了");
    }
}

package com.oop.demo05;

//學生 is 人  派生類
//子類繼承了父類，就會擁有父類的全部方法?。?！
public class Student extends Person{

    //ctrl+h  打開繼承樹！?。。。?！
    private String name="qj";
    public void test(String name){
        System.out.println(name);//aa
        System.out.println(this.name);//qj
        System.out.println(super.name);//ks
    }

    public void print(){
        System.out.println("Student");
    }

    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//person
    }

    public Student() {
        //隱藏代碼，默認調用了父類的無參構造！?。。。。。。。?！
        super();//調用父類的構造器，必須要在子類構造器第一行
        System.out.println("Student 無參執(zhí)行了");
    }
}

super注意點：
    1.super調用父類的構造方法，必須在構造方法的第一行
    2.super必須只能出現(xiàn)在子類的方法或者構造方法中！
    3.super和this不能同時調用構造方法

vs this:
    代表的對象不同：
        this：本身調用者這個對象
        super：代表父類對象的應用
    前提：
       this：沒有繼承也可以使用
       super：只能在繼承條件才可以使用
    構造方法
    this();本類的構造
    super();父類的構造

方法重寫

package com.oop.demo05;

//繼承
public class A extends B{
    @Override //注解：有功能的注釋
    public void test() {
        System.out.println("A->test()");
    }
}

package com.oop.demo05;

//重寫都是方法的重寫，和屬性無關
public class B {

    public void test(){
        System.out.println("B->test()");
    }
}

package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {
    public static void main(String[] args) {

        //靜態(tài)的方法和非靜態(tài)的方法區(qū)別很大
        //靜態(tài)方法：方法的調用只和左邊，定義的數(shù)據(jù)類型有關
        //只有非靜態(tài)才叫做重寫 ，private也不可以，只有public才可以

        A a=new A();
        a.test();

        //父類的引用指向了子類
        B b=new A();//子類重寫了父類的方法
        b.test();

        //test()方法都有static時
        //A->test()
        //B->test()


        //靜態(tài)的方法和非靜態(tài)的方法區(qū)別很大
        //去掉static,即重寫之后
        //A->test()
        //A->test()


    }
}

重寫：需要有繼承關系，子類重寫父類的方法！
    1.方法名必須相同
    2.參數(shù)列表必須相同
    3.修飾符：范圍可以擴大：public>protected>default>private
    4.拋出的異常：范圍，可以被縮小，但不能擴大；classNotFoundException(xiao)-- Exception(da)是不可以的
重寫，子類的方法和父類必須要一致，方法體不同

為什么需要重寫：
    1.父類的功能，子類不一定需要，或者不一定滿足！
    快捷鍵： Alt+insert :override!!!!!!

多態(tài)

什么是多態(tài)

package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {

        //一個對象的實際類型是確定的
        //new Student();
        //new Person();

        //可以指向的引用類型就不確定了: 父類的引用指向子類

        //Student 能調用的方法都是自己的或者繼承父類的
        Student s1 = new Student();
        //Person 父類型。可以指向子類，但是不能調用子類獨有的方法
        Person s2 = new Student();
        Object s3 =new Student();

        s2.run();//son 子類重寫了父類的方法，執(zhí)行子類的方法
        s1.run();//son

        //對象能執(zhí)行哪些方法，主要看對象左邊的類型，和右邊關系不大
        // s2.eat(); 報錯
        ((Student)s2).eat();
        s1.eat();//eat


    }
}

package com.oop.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

/*
多態(tài)注意事項：?。。。。。。。。。。。?！
1.多態(tài)是方法的多態(tài)，屬性沒有多態(tài)
2.父類和子類，有聯(lián)系  否則有類型轉換異常 ClassCastException
3.存在條件：繼承關系，方法需要重寫，父類引用指向子類對象 Father f1= new Son();

    1.static 方法，屬于類，它不屬于實例
    2.final 常量，不可以改變
    3.private 方法，私有的不能重寫
 */

package com.oop.demo06;

public class Person {

    public void run(){
        System.out.println("run");
    }

}

instanceof 和類型轉換

package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        //類型之間的轉換：父   子

        //高                   低
        Person obj=new Student();

        //student 將這個對象轉換為Student類型，就可以使用Student類型的方法了！

        ((Student) obj).go();

        //子類轉換為父類，可能丟失自己的本來的一些方法！
        Student student = new Student();
        student.go();
        Person person=student;
        //person.go();//報錯


    }
}

/*
1.父類引用指向子類的對象
2.把子類轉換為父類，向上轉型：
3.把父類轉換為子類，向下轉型：強制轉換
4.方便方法的調用，減少重復的代碼！簡潔！

抽象：封裝、繼承、多態(tài)！ 抽象類，接口
 */

package com.oop.demo06;

public class Person {

    public void run(){
        System.out.println("run");
    }

}

package com.oop.demo06;

public class Student extends Person{

    public void go(){
        System.out.println("go");
    }

}

/*
//System.out.println(X instanceof  Y);//能不能編譯通過取決于是否有父子關系

        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student
        Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        System.out.println("=============================");

        Person person =new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//編譯報錯

        System.out.println("=============================");
        Student student =new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//編譯報錯
        //System.out.println(student instanceof String);//編譯報錯
 */

package com.oop.demo06;

public class Teacher extends Person{
}

static關鍵字

package com.oop.demo07;

public class Student {

    private static int age;//靜態(tài)變量 多線程中會仔細說到
    private double score;//非靜態(tài)變量

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);//建議通過這種類型來訪問靜態(tài)變量，靜態(tài)的變量對于類而言在內存中只有一個，可以被類中所有實例共享
//        System.out.println(Student.score);//報錯
        System.out.println(s1.age);
        System.out.println(s1.score);

//        Student.run();//報錯
        new Student().run();

        Student.go();
        go();//類中的的方法可以直接訪問類中的靜態(tài)方法

    }


}

package com.oop.demo07;

public final class Person {
    //被final修飾的類不能被繼承

    {
        //匿名代碼塊
        //程序執(zhí)行時不能主動調用這個代碼塊
        //創(chuàng)建對象時自動創(chuàng)建，而且在構造器之前
        //可以用來賦初值
        System.out.println("匿名代碼塊");
    }

    static{
        //靜態(tài)代碼塊
        //類一加載就直接執(zhí)行
        //永久執(zhí)行一次
        System.out.println("靜態(tài)代碼塊");
    }

    public Person() {
        System.out.println("構造方法");
    }

    public static void main(String[] args) {

        Person person1=new Person();
        System.out.println("==============");
        Person person2=new Person();

        /*
        靜態(tài)代碼塊
        匿名代碼塊
        構造方法
        ==============
        匿名代碼塊
        構造方法
         */

    }
}

package com.oop.demo07;
//靜態(tài)導入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象類

package com.oop.demo08;

//抽象類  extends: 單繼承~ （接口可以實現(xiàn)多繼承）例如插座~
public abstract class Action {

    //約束~有人幫我們實現(xiàn)
    //抽象方法，只有方法名字，沒有方法的實現(xiàn)
    public abstract void doSomeThing();

    //1.不能new這個抽象類，只能靠子類去實現(xiàn)它；約束！
    //2.抽象類中可以寫普通方法
    //3.抽象方法必須在抽象類中
    //抽象的抽象：約束

    //思考題 不能new，存在構造器嗎？  存在?。。?！↓↓↓↓↓↓↓↓
    //存在的意義是什么  抽象出來 提高開發(fā)效率


    public Action() {
    }
}

//抽象類的所有方法，繼承了它的子類，都必須實現(xiàn)這些方法~除非~它也是抽象類
public class A extends Action{

    @Override
    public void doSomeThing() {

    }
}

接口的定義與實現(xiàn)

package com.oop.demo09;


//抽象的思維~Java 架構師~
//interface 定義的關鍵字,接口都需要有實現(xiàn)類
public interface UserService {
    //接口中的所有定義的方法其實都是抽象的 默認為public abstract

    //屬性都是常量 默認 public static final
    int AGE=99;


    void add(String name);
    void delete(String name);
    void uodate(String name);
    void query(String name);

}

package com.oop.demo09;

public interface TimeService {
    void timer();
}

package com.oop.demo09;

//抽象類：extends
//類可以實現(xiàn)接口
//實現(xiàn)了接口的類，就需要重寫接口中的方法

//多繼承，利用接口實現(xiàn)多繼承
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void uodate(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

作用：
    1.約束
    2.定義一些方法，讓不同的人實現(xiàn)~  10----》1
    3.方法都是 public abstract
    4.屬性都是 public static final
    5.接口不可以實例化~，接口中沒有構造方法
    6.implements可以實現(xiàn)多個接口
    7.必須重寫接口中的方法~

內部類

package com.oop;

import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {

        Outer outer = new Outer();

        //通過這個外部類來實例化內部類
        Outer.Inner inner = outer.new Inner();
        inner.getID();//10


    }
}

package com.oop.demo10;

public class Outer {

    private int id=10;
    public void out(){
        System.out.println("這是外部類的方法");

        //局部內部類
        class Inner{
            public void in(){

            }
        }


    }

    public class Inner{
        public void in(){
            System.out.println("這是內部類的方法");
        }

        //獲得外部類的私有屬性~
        public void getID(){

            System.out.println(id);

        }

    }

    //靜態(tài)內部類
    public static class Inner2{
        public void in(){
            System.out.println("這是內部類的方法");
        }

        //不能獲得外部類的屬性
        public void getID(){

//            System.out.println(id);//報錯

        }

    }


}

//一個Java類中可以由多個class類，但是只能由public class
class A{

}

package com.oop.demo10;

public class Test {
    public static void main(String[] args) {

        Apple apple = new Apple();

        //沒有名字初始化類,不用將實例保存在變量中
        new Apple().eat();

        //沒有名字初始化接口
        new UserService(){
            @Override
            public void hello() {

            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{

    void hello();

}