Java中小细节

String类型的创建方式：

1.String 变量=“内容”；

当创建两个变量内容相同时，二者的内容是相等的

原因：以该形式创建字符串会存储在字符串常量池，而同样的内容在常量池中只会存储一份，避免造成空间浪费，所以是相等的

注意：==

对于基本数据类型来说，==比较的是值是否相同

对于引用数据类型来说 ，==比较的是地址是否相同

2.String 变量 = new String("内容")；

new关键字在堆里面开辟内存空间，与直接""不同，变量先是指向0xc,然后再由0xc指向字符

所以当这种情况下，用==判断是不相等的

==和equals 的区别

==和equals不同，我们可以点开其定义，这里不难发现，equals的比较放是拿每个字符分别进行比较，所以这个时候 a c 是相等的

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

String类的常用方法

 根据位置获取指定的字符

String a="123456789";
char x=a.charAt(3);
System.out.println(x);

截取字符串

String z=a.substring(3,4);
System.out.println(z);

判断是否有子串

System.out.println(a.contains("45"));

字串替换

a.replace("45","dd");
System.out.println(a);

字符串分割

String str ="apple,banana,orange";
String[] parts = str.split(",");
for(int i=0;i< parts.length;i++){
    System.out.println(parts[i]);
}

继承

继承的本质就是代码的复用，是子类复用父类的代码，父类是用不了子类的代码

注意：

java的继承层次当中是不能相互继承的

一个类可以被多个类中当中父类，一个子类只能用一个父类（java仅支持单继承） 

四种权限的区别 

 public修饰的代码，本类和其他类都是可以访问的private修饰的代码，本类是可以访问的，但是其他类不可以访问

构造器

要求：构造器必须和类名相同

        当在类中有一个默认的不显示的无参数的构造器，那么那个无参构造器就会被覆盖

        构造器不需要写返回类型

        一个类当中可以有多个构造函数

例子

public class A {
    private String name;
    private int age;
    private char sex;
    private int sno;

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

重载和重写

重载在一个类中，重写在不同类中

为什么会有重写

继承的本质是代码的复用，在复用的过程当中父类的方法的实现不一定完全
方法重写之后，子类对象调用的也是重写后的方法
方法的重写:发生在父子类当中，子类重新实现父类方法的功能

执行顺序

拿一个案例来举例：

public class Test extends Base {
    public Test() {
        System.out.println("test constructor");
    }

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

    //static修饰的代码块在ma1n方法执行之前执行，其目的是修饰main方法
    static {
        System.out.println("test static");
    }
}
class Base {
    static {
        System.out.println("base static");
    }

    public Base() {
        System.out.println("base constructor");
    }
}

运行结果：

原理：

        在程序运行过程中，先是扫描.java文件并生成.class，此时main函数提供入口，从这里进入，但当所要进入放入的类有父类的时候，程序先是去扫描父类并生成对应的.class文件，所以在该程序中，先运行父类代码块，输出base static。

        父类完毕后接着是子类，运行子类代码块，输出test static。

        随后在编译完毕后，进入main函数，new Test();提供构造器，运行构造函数，同样也是按照先父类后子类的顺序所以先后输出base constructor和 test constructor。

流程图如下：