回顧方法的定義與調(diào)用

方法的定義

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{
        
    }

}

方法的調(diào)用

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(); //這里會(huì)報(bào)錯(cuò)，不能調(diào)用!!!!!!!

    }

    //類實(shí)例化之后才存在
    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;
    }

}

//引用傳遞: 傳遞的對(duì)象，本質(zhì)還是值傳遞
//對(duì)象要理解透徹、內(nèi)存要理解透徹！?。。。。。?！
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 是一個(gè)對(duì)象：指向的--》Person person = new Person(); 這是一個(gè)具體的人可以改變屬性
        person.name ="wda";
    }

}


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

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

public class Student {

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

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



}

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

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

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

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

    }
 */

構(gòu)造器詳解

package com.oop.demo02;

//java-->會(huì)生成一個(gè)class文件
public class Person {

    //一個(gè)類即使什么都不寫，也會(huì)存在一個(gè)方法
    //顯式的定義構(gòu)造器
    String name;
    int age;

    //構(gòu)造器的功能
    //實(shí)例化初始值
    //1.使用new關(guān)鍵字，本質(zhì)是在調(diào)用構(gòu)造器
    //2.用來初始化值
    public Person(){
        this.name="safa";

    }

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

    //alt+ insert 快捷定義構(gòu)造器


}

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

        //new 實(shí)例化了一個(gè)對(duì)象
        Person person = new Person("aaa");
        System.out.println(person.name); //aaa

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

創(chuàng)建對(duì)象內(nèi)存分析

package com.oop.demo03;

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

    //無參構(gòu)造

    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ù)時(shí)候是對(duì)屬性來說的，方法里面用的比較少
    /*
        1.提高程序的安全性
        2.隱藏代碼的實(shí)現(xiàn)細(xì)節(jié)
        3.統(tǒng)一接口
        4.系統(tǒng)可維護(hù)性增加了
    */

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

    //學(xué)號(hào)
    private int id;

    //性別
    private char sex;

    //年齡
    private int age;

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

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

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

    //set 給這個(gè)數(shù)據(jù)設(shè)置值
    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;
        }

    }

    //學(xué)習(xí)（）
    //睡覺（）


}

/*
public static void main(String[] args) {
        Student s1 =new Student();
        // s1.name  會(huì)報(bào)錯(cuò)

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

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

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

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

    }
 */

繼承

基礎(chǔ)

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);
        //報(bào)錯(cuò)，說明父類私有的屬性不能繼承
    }
}

package com.oop.demo05;

//在Java中，所有的類，都默認(rèn)直接或間接繼承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;

//學(xué)生 is 人  派生類
//子類繼承了父類，就會(huì)擁有父類的全部方法?。?！
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無參構(gòu)造執(zhí)行了
        //Student 無參執(zhí)行了



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

package com.oop.demo05;

//在Java中，所有的類，都默認(rèn)直接或間接繼承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則出錯(cuò)，私有的東西無法繼承
    public void print(){
        System.out.println("person");
    }

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

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

package com.oop.demo05;

//學(xué)生 is 人  派生類
//子類繼承了父類，就會(huì)擁有父類的全部方法?。?！
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() {
        //隱藏代碼，默認(rèn)調(diào)用了父類的無參構(gòu)造?。。。。。。。。?！
        super();//調(diào)用父類的構(gòu)造器，必須要在子類構(gòu)造器第一行
        System.out.println("Student 無參執(zhí)行了");
    }
}

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

vs this:
    代表的對(duì)象不同：
        this：本身調(diào)用者這個(gè)對(duì)象
        super：代表父類對(duì)象的應(yīng)用
    前提：
       this：沒有繼承也可以使用
       super：只能在繼承條件才可以使用
    構(gòu)造方法
    this();本類的構(gòu)造
    super();父類的構(gòu)造

方法重寫

package com.oop.demo05;

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

package com.oop.demo05;

//重寫都是方法的重寫，和屬性無關(guān)
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)方法：方法的調(diào)用只和左邊，定義的數(shù)據(jù)類型有關(guān)
        //只有非靜態(tài)才叫做重寫 ，private也不可以，只有public才可以

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

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

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


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


    }
}

重寫：需要有繼承關(guān)系，子類重寫父類的方法！
    1.方法名必須相同
    2.參數(shù)列表必須相同
    3.修飾符：范圍可以擴(kuò)大：public>protected>default>private
    4.拋出的異常：范圍，可以被縮小，但不能擴(kuò)大；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) {

        //一個(gè)對(duì)象的實(shí)際類型是確定的
        //new Student();
        //new Person();

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

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

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

        //對(duì)象能執(zhí)行哪些方法，主要看對(duì)象左邊的類型，和右邊關(guān)系不大
        // s2.eat(); 報(bào)錯(cuò)
        ((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)注意事項(xiàng)：?。。。。。。。。。。。?！
1.多態(tài)是方法的多態(tài)，屬性沒有多態(tài)
2.父類和子類，有聯(lián)系  否則有類型轉(zhuǎn)換異常 ClassCastException
3.存在條件：繼承關(guān)系，方法需要重寫，父類引用指向子類對(duì)象 Father f1= new Son();

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

package com.oop.demo06;

public class Person {

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

}

instanceof 和類型轉(zhuǎn)換

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) {
        //類型之間的轉(zhuǎn)換：父   子

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

        //student 將這個(gè)對(duì)象轉(zhuǎn)換為Student類型，就可以使用Student類型的方法了！

        ((Student) obj).go();

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


    }
}

/*
1.父類引用指向子類的對(duì)象
2.把子類轉(zhuǎn)換為父類，向上轉(zhuǎn)型：
3.把父類轉(zhuǎn)換為子類，向下轉(zhuǎn)型：強(qiáng)制轉(zhuǎn)換
4.方便方法的調(diào)用，減少重復(fù)的代碼！簡潔！

抽象：封裝、繼承、多態(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);//能不能編譯通過取決于是否有父子關(guān)系

        //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);//編譯報(bào)錯(cuò)

        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);//編譯報(bào)錯(cuò)
        //System.out.println(student instanceof String);//編譯報(bào)錯(cuò)
 */

package com.oop.demo06;

public class Teacher extends Person{
}

static關(guān)鍵字

package com.oop.demo07;

public class Student {

    private static int age;//靜態(tài)變量 多線程中會(huì)仔細(xì)說到
    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)的變量對(duì)于類而言在內(nèi)存中只有一個(gè)，可以被類中所有實(shí)例共享
//        System.out.println(Student.score);//報(bào)錯(cuò)
        System.out.println(s1.age);
        System.out.println(s1.score);

//        Student.run();//報(bào)錯(cuò)
        new Student().run();

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

    }


}

package com.oop.demo07;

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

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

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

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

    public static void main(String[] args) {

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

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

    }
}

package com.oop.demo07;
//靜態(tài)導(dǎo)入包
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: 單繼承~ （接口可以實(shí)現(xiàn)多繼承）例如插座~
public abstract class Action {

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

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

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


    public Action() {
    }
}

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

    @Override
    public void doSomeThing() {

    }
}

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

package com.oop.demo09;


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

    //屬性都是常量 默認(rèn) 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
//類可以實(shí)現(xiàn)接口
//實(shí)現(xiàn)了接口的類，就需要重寫接口中的方法

//多繼承，利用接口實(shí)現(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.定義一些方法，讓不同的人實(shí)現(xiàn)~  10----》1
    3.方法都是 public abstract
    4.屬性都是 public static final
    5.接口不可以實(shí)例化~，接口中沒有構(gòu)造方法
    6.implements可以實(shí)現(xiàn)多個(gè)接口
    7.必須重寫接口中的方法~

內(nèi)部類

package com.oop;

import com.oop.demo10.Outer;

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

        Outer outer = new Outer();

        //通過這個(gè)外部類來實(shí)例化內(nèi)部類
        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("這是外部類的方法");

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

            }
        }


    }

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

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

            System.out.println(id);

        }

    }

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

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

//            System.out.println(id);//報(bào)錯(cuò)

        }

    }


}

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

}

package com.oop.demo10;

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

        Apple apple = new Apple();

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

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

            }
        };
    }
}

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

interface UserService{

    void hello();

}