java面向对象部分

在学校时学的比较乱，趁暑假再系统的学一遍

访问权限控制

private：私有，只能被本身类访问

什么都不写：默认，只能被类本身和同包中的其他类访问

protected：受保护的，只能被类本身和同包中的其他类访问，也能被子类访问

public：公有的，允许在任何地方被访问

instanceof

判断某个对象是否是给定的类，是返回true，不是返回false

public class Person {
    String name;
    int age;
    String sex;
}

public class Worker extends Person{}

public class Student extends Person{}

public class Main {
    public static void main(String[] args) {
        Person person = new Student();
        if(person instanceof Student) { //true
            System.out.println("yes");
        }
    }
}

同时也能判断是否是它的子类。

public class Main {
    public static void main(String[] args) {
        Person person = new Student();
        if(person instanceof Person) { //true
            System.out.println("yes");
        }
    }
}

抽象类

抽象类包含抽象方法，抽象方法只有方法头而没有方法体，具体实现由它的子类实现。

抽象方法定义：

public abstract class Person {
   	···
    public abstract void test();
    ···
}

子类必须为抽象类或者实现父类的抽象方法。

public class Student extends Person{
	······
    @Override
    public void test() {
        System.out.println("我是学生");
    }
    ······
}

抽象类不能直接通过new来实例化，因为在抽象类中，行为（方法）没有具体实现。

可以定义一个抽象类的对象变量，但只能new它的非抽象子类，因为子类中实现了父类的抽象方法

抽象方法的访问范围无法设置为私有，因为抽象类中的抽象方法必须由子类实现，所以必须能够被外部访问

接口

比抽象类还抽象，另外接口也不是类。它描述类具有什么功能，但不给出具体实现（java8之前）。

接口的定义：

public interface Study {
    public abstract void exam();
}

接口中的方法默认为公共的抽象方法，所以public abstract可省略不写

同时，接口内的方法也不能够去实现

在接口中，也只能够定义常量，默认为public final，可省略不写。Java8之后，提供了具体实现接口中的方法，default与static

public interface Study {
    public final int a = 1;
    public abstract void exam();

    public static void doHomework() {
        //静态方法
    }

    public default void listen() {
        //默认方法
    }
}

枚举类

本质就是一个类，继承自enum，枚举类中的每一个实例实际上就是public static final类型的常量。

定义方式：

public enum Status {
    RUNNING, STUDYING, SLEEPING;
}

在Student类中定义好枚举类的对象与get和set方法。

private Status status;

public Status getStatus() {
    return status;
}

public void setStatus(Status status) {
    this.status = status;
}

接下来为Student对象给定需要的枚举值

Student student = new Student("xiaoMing", "male", 19);
student.setStatus(Status.RUNNING);

常用方法：

values();//取出枚举类中所有值

Status[] st = Status.values();

基本包装类

特殊包装类

BigInteger,可以表示非常大的数，并且没有限制

---

String类

String本身也是一个类。

创建方式：可以直接用双引号创建一个对象，当然 也可以象征性的new。

如果使用双引号创建对象，为了优化效率，始终同一个对象：

public static void main(String[] args) {
    String s = "hello world";
    String s1 = "hello world";
    System.out.println(s == s1);
}
// true

但如果通过new创建出的对象，即使内容相同，也是不同的对象。

因此，如果我们只是想比较字符串的内容相等，应该使用equals方法。

charAt方法

在cpp中，访问字符串中的字符可以直接像数组那样通过下标访问，但java不允许。

参数：charAt(int index)

public static void main(String[] args) {
    String s = "hello world";
    System.out.println(s.charAt(0)); // h
}

substring方法

参数：

substring(beginIndex)

substring(beginIndex, endIndex) ，注意为左闭右开。

    public static void main(String[] args) {
        String s = "hello world";
        String s1 = s.substring(0, 3);
        String s2 = s.substring(s.length() - 4);
        System.out.println(s1); // hel
        System.out.println(s2); // orld
    }

split方法

分割字符串，通过指定字符进行字符串分割。

    public static void main(String[] args) {
        String s = "hello world";
        String[] str = s.split(" "); // 以空格为分割
        for(String i : str) {
            System.out.println(i);
        }
    }

---

StringBuilder类

String类的对象本身不能修改，String s = "hello", s只是对象的引用，并不是对象本身。对象存放在内存中，当重新创建一个字符串对象 "world"，让 s = “world”，只是将s指向了这个对象，原来的对象"hello"还在内存中并没有改变。这是一种断开-再连接的操作，所以当要进行大量字符串修改时，应该避免使用String，这样会降低性能

一般用StringBuilder，专门用来构造字符串的，可对字符串进行拼接，裁剪等操作。

append方法

    public static void main(String[] args) {
        String s = "hello world";
        StringBuilder builder = new StringBuilder();
        builder.append(s).append(" are you ok?");
        System.out.println(builder.toString()); // hello world are you ok?
    }

---

成员内部类

在类的内部定义成员内部类，既然是类，那内部类同样有成员变量，方法等。

我们知道，要使用成员变量或方法时，需要通过对象来调用，同样的，要想创建内部类的对象，我们需要通过对象来调用。

public class Test {
    public class Inner {
        public void test() {
            System.out.println("成员内部类");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        Test.Inner inner = test.new Inner();
        inner.test();
    }
}

外部无法直接访问成员内部类的成员变量：

很好理解，内部类Inner都没创建对象，外部无法直接引用它的字段。

当成员内部类定义了同名的变量，我们通过加上该内部类依附的外部类名称来区别：

public class Test {
    String name = "123";
    
    public class Inner {
        String name = "abc";
        public void test() {
            System.out.println("就近？" + name); // abc
            System.out.println("成员内部类：" + this.name); // abc
            System.out.println("外部name：" + Test.this.name); // 123
        }
    }
}

2023.6.23

---