在学校时学的比较乱，趁暑假再系统的学一遍
访问权限控制
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
