JavaSE基礎篇---oop:面對物件

阿新 • • 發佈：2020-09-06

//有些雜，，，，看不懂可以找我，我再重寫

類，方法的呼叫

package com.oop.demo01;
//類，方法的呼叫
public class Demo01 {
    public static void main(String[] args) {

        //靜態呼叫,在之前的隨筆裡有記載
        //Student.say();
        //動態態呼叫
        Student student = new Student();
        student.say();

    }

    //和類一起載入的
  public static void a(){

    }

     
//類例項化之後才存在的，所以靜態方法和動態方法不能混合呼叫
    public void b(){

    }
}

值傳遞

package com.oop.demo01;

import java.util.Date;

//值傳遞
public class Demo02 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1

        Demo02.change(a);
        //change（a）沒有把a處理後的值返回所以結果依舊是1
        System.out.println(a);;// 
1




    }

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

}

引用傳遞

package com.oop.demo01;

//引用傳遞：物件，本質還是值傳遞

//注意：物件，記憶體
public class Demo03 {
    public static void main(String[] args) {

        Person person = new Person();

        System.out.println(person.name);//null

        Demo03.change(person);
        System.out.println(person.name); 
//king
    }

    public  static void change(Person person){
        //person是一個物件：
        person.name="king";
    }
}

//定義一個Person類，有一個熟悉屬性：name
class Person{
    String name;
}

有參無參

package com.oop.demo02;
//java——》class
//out目錄就是輸出檔案，將java檔案變成class
public class Person {

    //一個類即時什麼都不寫，class裡也會有一個預設的方法（構造器）

    String name;
    int age;

    //例項化初始值
    //1.使用new關鍵字，本質是在呼叫構造器
    //無參構造
    public Person(){
        this.name="king";
    }

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

    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }


}

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

        Person person = new Person("king",23);

        System.out.println(person.name);

    }

    構造器:
        1.和類名相同
        2.沒有返回值
    作用：
        1.new本質在呼叫構造方法
        2.初始畫物件的值
    注意點：
        1.定義有參構造之後，如果想用無參構造，顯示的定義一個無參的構造
         ait+insert自動生成方法
* */

package com.oop.demo02;

public class Student {

    //屬性：欄位
    String name;
    int age;


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

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

        //類：抽象的，要例項化
        //類例項化後會返回自己的物件
        //student物件就是一個Student類的具體的一個例項

        Student gg=new Student();
        Student mm=new Student();

        gg.name="小g";
        gg.age=9;
        gg.study();//小g在學習
        System.out.println(gg.name);//小g
        System.out.println(gg.age);//9




        mm.name="小m";
        mm.age=3;
        System.out.println(mm.name);//小m
        System.out.println(mm.age);//3

    }
* */

建立物件

package com.oop.demo03;
//建立物件
public class Pet {
    public String name;
    public int age;

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

/*
      小結
      1.類與物件
            類是一個模板：抽象，物件是一個具體的例項
      2.方法
            定義，呼叫
      3.對應的引用
            引用型別：基本型別（8）
              物件是通引用來操作的：棧——》堆
      4.屬性：欄位Field 成員變數
        預設初始化：
            數字：0/0.0
            char：u0000
            boolean： false
            引用：null
      5.物件的建立和使用：
           你須使用new關鍵字，構造器 eg:Person king=new Peeson()
           物件的屬性：king.name
           物件方法：king.sleep()

      6.類：
           靜態的屬性  屬性
           動態的行為  方法

           封裝，繼承，多型

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

        Pet dog = new Pet();
        dog.name="cai";
        dog.age=3;
        dog.shout();

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


    }*/

封裝

package com.oop.demo04;
//封裝：
//意義：提高程式的安全性，保護資料
//      隱藏程式碼的實現細節
//      統一介面
//      提高系統可維護性


//封裝本質：
//類 private：私有 ，get，set
public class Student {

    private String name;  //名字
    private int id;//學號
    private char sex;//性別
    private int age;//年齡

    //提供可以操作private的方法
    //解決：get，set方法

    //get 獲得資料
    public String getName(){
        return this.name;
    }

    //set方法，給資料設定值
    public void setName(String name){
        this.name=name;
    }

    //alt+insert自動生成方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<120&&age>=0){
            this.age = age;
        }else{
            this.age=3;
        }
    }
}
/*    public static void main(String[] args) {
        Student s1=new Student();

        s1.setName("king");

        s1.setAge(70);
        System.out.println(s1.getAge());
    }
 */

繼承

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()");
    }
}

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

        //靜態方法和非靜態方法區別很大

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

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

小結：
重寫：需要有繼承關係，子類重寫父類方法
    1.方法名必須相同
    2.引數列表必須相同
    3.修飾符：範圍可以擴大但不能縮小：public>protected>Default>private
    4.丟擲異常：範圍，可以被縮小，但不能擴大：

為什麼重寫：
    1.父類功能：子類不一定需要，或不一定滿足
    Alt+Insert：override

    * */





//Person是父類 Student和Teacher是子類
package com.oop.demo05;



//在Java中，所有的類，都直接或間接預設繼承object
//extends:擴充套件
//父類

public class Person /*extends Object*/ {
        public String name="kings";

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

/*    //public
    //proteced受保護的
    //default 預設的
    //private 私有的
    //優先順序高——>低

    private int money=10_0000_0000;
    public void say(){
        System.out.println("king");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
super注意點：
    1.super呼叫父類的構造方法，必須在構造方法發的第一個
    2.super必須只能在現在子類的方法或者構造方法中
    3.super和this不能同時呼叫構造方法
與this對比
    代表的物件不同
        this：本身呼叫者這個物件
        super：代表父類物件應用
    前提
        this：沒有繼承也可以使用
        suo：只能在繼承條件下才可以使用
    構造方法
        this();本類的構造
        super（）；父類構造

 */

package com.oop.demo05;
//Student類是Person類的派生類，子類
//子類繼承了父類，就會擁有父類的全部方法
public class Student extends Person {

    //Ctrl+H;


 public Student(){
     //隱藏程式碼：呼叫了父類的無參構造
     //super();呼叫父類構造器必須放到子類構造器的第一行
     System.out.println("Student 無參執行了");
 }

    private String name="king";


    public void test1(){
        System.out.println(name);//kingking
        System.out.println(this.name);//king,this輸出當前類的值
        System.out.println(super.name);//kings，super父類的值
    }

    public void test(String name){
        System.out.println(name);//kingking
        System.out.println(this.name);//king,this輸出當前類的值
        System.out.println(super.name);//kings，super父類的值
    }

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

        Student student = new Student();


        //student.test("kingking");
    }
* */

package com.oop.demo05;

public class Teacher extends Person {
}

多型

package com.oop.demo06;

public class Person {

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

/*
多型注意事項
1.多型是方法的多型，屬性沒有多型
2.父類和子類，有聯絡 型別轉換異常！ClassCastException！
3.存在條件：繼承關係，方法需要重寫，父類引用指向子類物件
        1.static 方法，屬於類，它不屬於例項
        2.final 常量：
        3.private 方法：
        以上3個都不能重寫
* */
/*
   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();
        s1.run();

    }

*/
package com.oop.demo06;

public class Student extends Person {

    @Override
    public void run() {//子類重寫父類方法
        System.out.println("son");
    }

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

instanceof，強制轉換

//person 父類    stud和teache子類
package com.oop.demo07;

//instanceof，強制轉換
public class Person {

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

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

        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student
        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能編譯通過

        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);//編譯報錯，person與String沒有關係


    }
    /*
1.父類引用指向子類物件
2.把子類轉換為父類，向上轉型：丟失精度，可能丟失一些方法
3.把父類轉換為子類，向下轉型：強制轉換eg:Person obj=new student;  ((student)obj).go();

*
*/

package com.oop.demo07;

public class Student extends Person {
}


package com.oop.demo07;

public class Teacher extends Person {
}

導包

package com.oop.Demo08;

//靜態匯入包
import  static java.lang.Math.random;
//static
public class Student {

    private static int age;//靜態的變數,多執行緒用到！
    private double score;//非靜態變數

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

        System.out.println(Student.age);//0
        System.out.println(s1.age);//0
        System.out.println(s1.score);//0.0
    }

}

抽象類，關鍵詞abstract

package com.oop.demo09;

//抽象類的所有方法，繼承了它的子類，都必須要實現他的方法，除非他也是抽象類
public abstract class A extends Action{

    public void doSomething() {

    }
}

package com.oop.demo09;

//abstract 抽象類；類 extends: 單繼承（類只有單繼承），介面可以多繼承
public abstract class Action {

    //約束~有人幫我們是實現
    //abstract,抽象方法，只有方法名字，沒有方法實現！
    public abstract void doSomething();
}

    //抽象類特點：不能new這個抽象類，只能靠子類去實現它：約束！
    //           抽象類中可以寫普通的方法
    //           抽象方法必須在抽象類中
    //           抽象的抽象：約束~

    //思考？
    //1.可以new物件嗎，存在構造器嗎？
    //2.存在意義 抽象出來~提高開發效率


//思考題解答
//1.抽象類是存在建構函式的，其建構函式是提供給子類建立物件的時候初始化父類的屬性的。
//2.更利於程式碼的維護和重用，對子類進行保護，當你修改子類資料時觸發到抽象類，會提醒開發者有些東西不可隨意改變

介面，關鍵此interface

package com.oop.Demo10;

public interface TimeService {
    void timer();
}

package com.oop.Demo10;

//抽象的思維~Java！！！

//介面:interface,關鍵字
//介面都需要有實現類
public interface UserService {
    //介面中的所有定義都是抽象的 public

    //常量,一般不會用
    public static final int AGE=99;

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

/*
介面作用：
        1.約束
        2.定義一些方法，讓不同的人實現
        3.方法：public abstract
        4.常量：public static final
        5.介面不能被例項化，介面中沒有構造方法
        6.implements可以實現多個介面；eg：public class UserServiceImpl implements UserService,TimeService{}
        7.實現介面，必須要實現重寫介面中的方法
**/

package com.oop.Demo10;

//類 可以實現介面 implements 介面
//實現介面的類，就需要重寫介面的方法
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}