Java-面相对象进阶(更新迭代中)

1.static(静态)-P121~123

static表示静态,是Java中的一个修饰符,可以修饰成员方法,成员变量.

(1)静态变量-P121

被static修饰的成员变量,叫做静态变量

特点: ●被该类所有对象共享.  ●不属于对象,属于类.  ● 随着类的加载而加载,优先于对象存在.

调用方式: 类名调用(推荐).                  对象名调用.

public class Student {
    //属性:
    private String name;//姓名
    private int age;//年龄
    private String gender;//性别

    public static  String teacherName;//定义静态变量


    public Student() {
    }

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


    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 String getGender() {
        return gender;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }

    //行为:
    public void study(){
        System.out.println(name + "正在学习");
    }

    public void show(){
        System.out.println(name + " " + age + " " + gender + " " + teacherName);
    }
}

public class Main {

    public static void main(String[] args) {

        Student s1 = new Student("彭于晏",18,"男");
        Student s2 = new Student("刘亦菲",18,"女");
        Student.teacherName = "李老师";//类名调用

        s1.show();//打印结果: 彭于晏 18 男 李老师
        s2.show();//打印结果: 刘亦菲 18 女 李老师
    }
}

静态变量的内存原理自己去看网课比较好(P121)

(2)静态方法-P122

被static修饰的成员方法,叫做静态方法

特点: ●多用在测试类和工具类中 ●Javabean类中很少会用 (工具类:帮助我们做一些事情的,但是不描述任何事物的类)

调用方式: 类名调用(推荐).                  对象名调用.

(3)工具类-P122

Javabean类	用来描述一类事物的类.eg:Student , Teacher , Dog , Cat等
测试类	用来检查其他类是否书写正确,带有main方法的类,是程序的入口
工具类	不是用来描述一类事物的,而是帮助我们做一些事情的类,就是一个工具

//工具类:

//1.类名见名知意
//2.私有化构造方法(目的:不让外界创建它的对象,因为工具类不描述一类事物,创建了其对象也没有意义)
//3.方法定义为静态(也就是我们刚学的静态方法,为了方便调用)

public class ArrayUtil {    //1.类名见名知意(数组工具)

    private ArrayUtil(){}   //2.私有化空参构造

    //3.静态方法定义
    //需求:
    //(1)提供一个工具类方法printArr,用于返回整数数组的内容.返回格式如[1,2,3,4](只考虑整形一维数组)
    //(2)提供一个工具类方法getAerage,用于返回平均分.(只考虑浮点型一维数组)
    public static String printArr(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        return  sb.toString();
    }

    public static double getAverage(double[] arr){
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum / arr.length;
    }

}

public class Main {

    public static void main(String[] args) {

        int[] arr1 = {10,20,30,40};
        double[] arr2 = {3.2,4.8,5.6,2.4};

        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);//打印结果: [10,20,30,40]

        double p = ArrayUtil.getAverage(arr2);
        System.out.println(p);//打印结果: 4.0
    }
}

练习-定义学生工具类(P122)

(4)static的注意事项-P123

注意事项	总结
静态方法只能访问静态变量和静态方法	静态方法中,只能访问静态
非静态方法可以访问静态变量或静态方法,也可以访问非静态的成员变量和非静态的成员方法	非静态方法中可以访问所有
静态方法中是没有this关键字的	静态方法中没有this关键字

代码方面和内存方面理解自己去看网课比较好(P123)

(5)重新认识main方法-P123

public class Main {

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

public	被JVM调用,访问权限足够大
static	被JVM调用,不用创建对象,直接类名访问,因为main方法是静态的,所以测试类中其他方法也需要是静态的.
void	被JVM调用,不需要给JVM返回值
main	一个通用的名称,虽然不是关键字,但是被JVM识别
String[]args	以前用于接收键盘录入数据的,现在没用了

-----------

2.继承-P124

(1)什么是继承

Java中提供一个关键字extends,用这个关键字,我们可以让一个类和另一个类建立起继承关系.

eg. public class Student extends Person {}

Student 称为子类(派生类) , Person 称为父类(基类或超类).

(2)使用继承的好处

可以把多个子类中重复的代码抽取到父类中了,提高代码的复用性.

子类可以在父类的基础上,增加其他的功能,使子类更加强大.

(3)什么时候使用继承

----------

3.包,final,权限修饰符,代码块

----------

4.抽象类

----------

5.接口

-----------

6.多态

-----------

7.内部类-P140~143

类的五大成员:

● 属性,方法,构造方法,代码块,内部类.

什么是内部类?

●在一个类的里面,再定义一个类.

为什么要学习内部类? 

●B类表示的事物是A类的一部分,且B单独存在没有意义,就可把B设计成内部类.(eg:人类的心脏)

//内部类表示的事物是外部类的一部分
//内部类单独出现没有任何意义

//代码举例:
public class Car {   // 外部类(车)
    String carName;
    int carAge;
    String carColor;
    
    class Engine {   // 内部类(发动机)
        String engineName;
        int engineAge;
    }
}

内部类的访问特点:

●内部类可以直接访问外部类的成员,包括私有.

●外部类想要访问内部类的成员,必须创建对象.

//内部类表示的事物是外部类的一部分
//内部类单独出现没有任何意义

//代码举例:
public class Car {   // 外部类(车)
    private String carName; // 私有化
    int carAge;
    String carColor;

    Engine e = new Engine(); // 
    // 创建一个内部类的对象
    public void show() {
        System.out.println(e.engineName); // 外部类想要访问内部类的成员,必须创建对象
    }

    class Engine {   // 内部类(发动机)
        String engineName;
        int engineAge;

        public void show() {
            System.out.println(carName); // 内部类可以直接访问外部类的成员,包括私有
        }
    }
}

内部类的分类:

●成员内部类:(了解)  写在成员位置的,属于外部类的成员.

//成员内部类的代码如何书写?
//●写在成员位置的,属于外部类的成员.
//●成员内部类可以被一些修饰符所修饰,如: private,默认,protected,public,static等
//●在成员内部类里面,JDK16之前不能定义静态变量,其之后才可以定义静态变量.

//如何创建成员内部类的对象?
//●方式一:在外部类中编写方法,对外提供内部类的对象.(private修饰内部类时使用)
//●方式二:直接创建格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;(一般用这个)

//成员内部类如何获取外部类的成员变量?
//●见代码

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

        Outer.Inner oi = new Outer().new Inner();// 方式二

        Outer o = new Outer(); //方式一
        System.out.println(o.getInstance());

        oi.show();
    }
}

class Outer {   // 外部类()
    private int a = 30;
    class Inner {   // 成员内部类()
        private int a = 20;
        public void show(){
            int a = 10;
            System.out.println(a);//10
            System.out.println(this.a);//20
            System.out.println(Outer.this.a);//30   Outer.this  获取了外部类对象的地址值
        }
    }

    public Inner getInstance(){ // 方式一
        return new Inner();
    }
}

●静态内部类:(了解)   成员内部类的一种特殊情况(用static修饰的成员内部类)  

//静态内部类中只能访问外部类中的静态变量和静态方法,如果想要访问非静态的需要创建对象
//创建静态内部类对象的格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名();
//调用非静态方法的格式: 先创建对象,用对象调用
//调用静态方法的格式: 外部类名.内部类名.方法名();

public class Test2 {
    public static void main(String[] args) {
        Outer2.Ineer.show2(); //调用静态方法
        Outer2.Ineer oi = new Outer2.Ineer(); //创建静态内部类的对象
        oi.show1(); //调用非静态方法
    }
}

class Outer2 {  //外部类
    int a = 10;
    static int b = 20;
    static class Ineer {  //静态内部类
        public void show1() {
            System.out.println("非静态方法被调用了");
            Outer2 o = new Outer2();
            System.out.println(o.a);
            System.out.println(b);
        }
        public static void show2() {
            System.out.println("静态方法被调用了");
            Outer2 o = new Outer2();
            System.out.println(o.a);
            System.out.println(b);
        }
    }
}

 ●局部内部类:(了解) 将内部类定义在方法里面就叫做局部内部类,类似于方法里面的局部变量

//外界是无法直接使用局部内部类,需要在方法内部创建对象并使用
//该类可以直接访问外部类的成员,也可以访问方法内的局部变量

public class Test3 {
    public static void main(String[] args) {
        Outer3 o = new Outer3();
        o.show();
    }
}

class Outer3{  //外部类
    int b = 20; //成员变量
    public void show(){  //外部类的一个方法

        int a = 10;  //局部变量
        class Inner{  //局部内部类
            String name;
            int age;
            private void method1(){
                System.out.println(a); //局部内部类中直接调用方法内的局部变量
                System.out.println(b); //局部内部类中直接调用外部类的成员
                System.out.println("局部内部类中的method1方法");
            }
            public static void method2(){
                System.out.println("局部内部类中的method2静态方法");
            }
        }

        Inner i = new Inner(); //创建局部内部类的对象
        i.method1(); //调用局部内部类中的方法
        Inner.method2(); //调用局部内不累中的静态方法
    }
}

●匿名内部类:(掌握)  本质上就是隐藏了名字的内部类,可以写在成员位置,也可以写在局部位置

//匿名内部类格式:
//    new 类名或者接口名() {         继承/实现
//         重写方法;                方法重写
//     };                          创建对象

public class Test4 {
    public static void main(String[] args) {
        //创建匿名内部类实现Swim这个接口,本质上其实是创建了这个匿名内部类的一个对象
        //为啥嘞? 因为现在运行你就会发现什么也没有打印出来
        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了swim方法");
            }
        };

        //创建匿名内部类继承Animal这个类,本质上其实是创建了这个匿名内部类的一个对象
        //为啥嘞? 因为现在运行你就会发现什么也没有打印出来
        new Animal(){
            @Override
            public void eat() {
                System.out.println("重写了eat方法");
            }
        };

        
        //匿名内部类使用场景:
        //调用method方法
        method(
                //相当于把这个继承了Animal类的匿名内部类当做一个参数传给下面那个方法
                new Animal(){
                    @Override
                    public void eat() {
                        System.out.println("调用了method方法");
                    }
                }
        );
    }
    public static void method(Animal a){   //Animal a = 子类对象        多态
        a.eat();                           //编译看左边,运行看右边
    }
}