方法的重寫

重寫：需要有繼承關係，子類重寫父類的方法！

1. 方法名必須相同
2. 引數列表必須相同
3. 修飾符：範圍可以擴大但不能縮小：public>Protected>Default>private
4. 丟擲的異常：範圍，可以被縮小，但不能擴大；ClassNotFoundException-->Exception(大)

重寫，子類的方法和父類必須要一致；方法體不同！

為什麼需要重寫：

1. 父類的功能，子類不一定需要，或者不一定滿足！

   Alt+Insert : overridde;

父類

package com.oop.Demo04;
​
public class A {
  //重寫都是方法的重寫，與屬性無關
  public void test(){
    System.out.println("A");
   }
}
 

子類

package com.oop.Demo04;
​
//繼承
public class B extends A{
​
  //Override  重寫
  @Override//註解：有功能的註釋
  public void test() {
    System.out.println("B");
   }
}

總控制

package com.oop;
​
import com.oop.Demo04.A;
import com.oop.Demo04.B;
​
//一個專案應該只有一個Main方法
public class Application {
​
  //靜態的方法和非靜態的方法區別很大
    //靜態方法：方法的呼叫只和左邊定義的資料型別有關
​
    //非靜態：重寫
  public static void main(String[] args) {
    //父類的引用指向了子類
    A a = new B();//子類重寫了父類的方法
    a.test();//B
​
    B b = new B();
    b.test();//A
   }
}
 

多型

多型存在的條件：

1. 有繼承關係
2. 子類重寫父類方法
3. 父類引用指向子類物件

多型注意事項：

1. 多型是方法的多型，屬性沒有多型
2. 父類和子類，有聯絡   型別轉換異常！  ClassCastException!

不能用多型：

1. static 方法，屬於類，它不屬於例項

2. final 常量；

3. private方法；

父類

package com.oop.Demo05;
​
public class Person {
  public void run(){
    System.out.println("run");
   }
}

子類

package com.oop.Demo05;
​
public class Student extends Person {
​
  @Override
  public void run(){
    System.out.println("son");
   }
​
  public void sun(){
    System.out.println("sun");
   }
}
 

總控制

package com.oop;

import com.oop.Demo05.Person;
import com.oop.Demo05.Student;

//一個專案應該只有一個Main方法
public class Application {
    public static void main(String[] args) {

        //一個物件的實際型別是確定的
        //new Student()
        //new Person()

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

        //Student呼叫的方法都是自己的或者繼承父類的！
        Student student = new Student();
        //Person 父型別，可以指向子類，但不能呼叫子類的方法
        Person person = new Student();

        //物件能執行那些方法，主要看物件的左邊型別，和右邊關係不大！
        student.run();
        person.run();//子類重寫了父類的方法，執行子類的方法
        student.sun();

        Person person1 = new Person();
        person1.run();
    }

}

型別轉換

1. 父類引用指向子類的物件

2. 把子類轉換為父類，向上轉型；

3. 把父類轉換為子類，向下轉型；強制轉換

4. 方便方法的呼叫，減少重複的程式碼！簡介

package com.oop;

import com.oop.Demo05.Person;
import com.oop.Demo05.Student;

//一個專案應該只有一個Main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.run();
        //型別之間的轉換：父子

        //高                 低
        Person person = new Student();
        //將person強制轉換為Student型別，就可以使用student型別的方法了
        ((Student)person).sun();
    }

}

static關鍵字

變數和方法：

package com.oop.Demo06;

//靜態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);//建議靜態的變數使用
        System.out.println(s1.age);
        System.out.println(s1.score);

        Student.run();//可以直接呼叫該類中的靜態方法
        new Student().go();//非靜態方法：必須要先new類才能呼叫
    }

    public static void run(){

    }
    public void go(){

    }
}

程式碼塊：

package com.oop.Demo06;

public class Preson {
    //2.賦初始值
    {
        //程式碼塊（匿名程式碼塊）
        System.out.println("匿名程式碼塊");
    }
    //1.只執行一次
    static {
        //靜態程式碼塊
        System.out.println("靜態程式碼塊");
    }
    //3.
    public Preson(){
        System.out.println("構造方法");
    }

    public static void main(String[] args) {
        Preson preson = new Preson();
        System.out.println("================");
        Preson preson1 = new Preson();
    }
}

靜態匯入包：

package com.oop.Demo06;

//靜態匯入包
import static java.lang.Math.PI;
import static java.lang.Math.random;

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

final

被final定義後不能用繼承了，相當於斷子絕孫

抽象類

abstract來修飾

1. 不能new這個類，只能靠子類 去實現它：約束！

2. 抽象類中可以寫普通方法

3. 抽象方法必須在抽象類中

抽象的抽象：約束

4. 存在的意義：抽象出來 提高開發效率

package com.oop.Demo07;

//abstract  抽象類    類extends     單繼承~    （介面可以多繼承）   
public abstract class Action {
    //約束~有人幫我們實現
    //abstract  抽象方法   只有方法的名字，沒有方法的實現
    public abstract void doSomeTging();
}	

package com.oop.Demo07;

//抽象類的所有方法，都必須要繼承它子類實現，除非子類也是抽象類，就由子子類實現
public class A extends Action{
    @Override
    public void doSomeTging() {

    }
}

介面

作用：

1. 約束
2. 定義一些方法，讓不同的人實現~ 	10---->1
3. public abstract
4. public static final
5. 介面不能被例項化~，介面中沒有構造方法~
6. implements可以實現多個介面
7. 必須要重新介面中的方法~

UserService：

package com.oop.Demo08;

//抽象的思維

//interface 定義的關鍵字  ,介面都需要有實現類
public interface UserService {
    //常量~public static final
     int age = 99;

    //介面中所有定義的方法其實都是抽象的  public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

TimeService：

package com.oop.Demo08;

public interface TimeService {
    void timer();
}

UserServiceImpl：

package com.oop.Demo08;

//抽象類：  extends~
//類 可以實現 介面 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() {

    }
}

內部類

內部類就是在一個類的內部定義一個類

1. 成員內部類

package com.oop.Demo09;

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("這是一個外部類");
    }
    public class Inner{
        public void in(){
            System.out.println("這是一個內部類");
        }

        //獲得外部類的私有屬性
        public void getId(){
            System.out.println(id);
        }
    }
}

public static void main(String[] args) {
  Outer outer = new Outer();
  outer.out();
  //通過這個外部類來例項化內部類
  Outer.Inner inner = outer.new Inner();
  inner.getId();
  inner.in();
}

2. 靜態內部類

給類加上static不能呼叫不含static的其他類

3. 區域性內部類

//一個java類中只能有一個 public class   但可以有多個class類
class A{
  public static void main(String[] args) {
    
   }
}

//區域性內部類
public void method(){
​
  class Inner{
    public void In(){
      
     }
   }
}

4. 匿名內部類

package com.oop.Demo09;
​
public class Test {
  public static void main(String[] args) {
    //沒有名字初始化類， 不用將例項儲存到變數中
    new Apple().eat();
    new UserService(){
      @Override
      public void hello() {
        
       }
     };
   }
}
class Apple{
  public void eat(){
    System.out.println("1");
   }
}
interface UserService{
  void hello();
}