一、java中方法间的值传递相关

1、常量值传递

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;

    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

• 结果

a = 20
b = 10
num1 = 10
num2 = 20

2、数据传递

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    System.out.println(arr[0]);
    change(arr);
    System.out.println(arr[0]);
}

public static void change(int[] array) {
    // 将数组的第一个元素变为0
    array[0] = 0;
}

• 结果

1
0

3、对象传递，并修改对象属性值

public static void main(String[] args) {
    Student student = new Student("小张");
    System.out.println(student.getName());
    changgeName(student);
    System.out.println(student.getName());
}

public static void changgeName(Student student) {
    student.setName("小五");
}

• 结果

小张
小五

4、对象传递，让对象参数引用一个新的对象(结果：不可修改)

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Student s1 = new Student("小张");
    Student s2 = new Student("小李");
    Test.swap(s1, s2);
    System.out.println("s1:" + s1.getName());
    System.out.println("s2:" + s2.getName());
}

public static void swap(Student x, Student y) {
    Student temp = x;
    x = y;
    y = temp;
    System.out.println("x:" + x.getName());
    System.out.println("y:" + y.getName());
}

• 结果

x:小李
y:小张
s1:小张
s2:小李

总结

• Java 程序设计语言对对象采用的不是引用调用，实际上，对象引用是按 值传递的

• Java 中方法参数的使用情况：

  • 一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）
  • 一个方法可以改变一个对象参数的状态
  • 一个方法不能让对象参数引用一个新的对象

二、构造器

1、不可别重写

• Constructor 不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况

2、在 Java 无参构造器的作用

Java 程序在执行子类的构造方法之前，如果没有用 super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super()来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

3、构造器的作用

• 主要作用是完成对类对象的初始化工作
• 如果一个类不定义构造器，也会有一个默认的无参构造器
• 如果我们添加的构造器（无论是有参构造器，还是无参构造器），java就不会再添加默认无参构造器

4、构造器的特性

• 名字与类名相同
• 没有返回值，但不能用 void 声明构造函数
• 生成类的对象时自动执行，无需调用

public Student() {

}

public Student(String name) {
    this.name = name;
}

三、成员变量与局部变量的区别

1、区别

• 成员变量可以被 public,private,static 等修饰符所修饰

• 局部变量不能被访问控制修饰符及 static 所修饰

• 成员变量和局部变量都能被 final 所修饰

• 从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存

• 从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。

• 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

四、对象

1、创建与存储

• new 创建对象实例（对象实例在堆内存中）

• 对象引用指向对象实例（对象引用存放在栈内存中）

• 一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）

• 一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）

2、对象的比较

• 对象的相等，比的是内存中存放的内容是否相等

• 引用相等，比较的是他们指向的内存地址是否相等

五、面向对象三大特征

1、封装

• 把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息

• 提供一些可以被外界访问的方法来操作属性

2、继承

不同类型的对象，相互之间经常有一定数量的共同点，同时，每一个对象还定义了额外的特性使得他们与众不同

• 使用继承，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率

• 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问只是拥有

• 子类可以拥有自己属性和方法，即子类可以对父类进行扩展

• 子类可以用自己的方式实现父类的方法

3、多态

一个对象具有多种的状态。具体表现为父类的引用指向子类的实例。特点如下：

• 对象类型和引用类型之间具有继承（类）/实现（接口）的关系

• 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定

• 多态不能调用“只在子类存在但在父类不存在”的方法

• 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法

六、静态方法

• 由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员

• 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式而实例方法只有"对象名.方法名"这种方式。也就是说，调用静态方法可以无需创建对象

public class Student {

    public static String name() {
        return "同学";
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(s1.name());
        System.out.println(Student.name());
    }
}

同学
同学

七、String、StringBuffer、StringBuilder

1、是否可变

• String不可变：

String 类中使用 final 关键字修饰字符数组来保存字符串，private final char value[]，所以String 对象是不可变的。

• StringBuilder 与 StringBuffer 可变：

StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串char[]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

在 Java 9 之后，String 、StringBuilder 与 StringBuffer 的实现改用 byte 数组存储字符串 private final byte[] value

2、线程安全

• String 中的对象是不可变的，也就可以理解为常量，String线程安全

• StringBuffer 线程安全， StringBuilder 不是线程安全

AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类,StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

3、性能

• 每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象（操作少量的数据: 适用String）

• StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用（多线程操作字符串缓冲区下操作大量数据: 适用StringBuffer）

• 相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险（单线程操作字符串缓冲区下操作大量数据: 适用StringBuilder）

4、replace、replaceAll注意事项

<replace、replaceAll方法执行后必须要有String对象去接，因为String实质上是final类型，所以直接使用name.replaceAll("\r|\n", "")时，并不会修改name自身的值信息，而是生成一个新的String

public static void main(String[] args) {
    String name = "412201207017303龙井市\r智新镇卫生院\n折腾";

    System.out.println(name);

    // name.replaceAll("\r|\n", ""); 如果只是这样写，不生效
    name = name.replaceAll("\r|\n", "");

    System.out.println(name);
}

八、try-catch-finally

1、基本作用

• try块：用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。

• catch块：用于处理 try 捕获到的异常。

• finally 块：无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行，即，放回结果为finally中的return信息

public class Test {
    public static int f(int value) {
        try {
            return value * value;
        } finally {
            if (value == 2) {
                return 0;
            }
        }
    }
}

如果调用 f(2)，返回值将是 0，因为 finally 语句的返回值覆盖了 try 语句块的返回值

2、finally 块不会被执行

• 在 try 或 finally 块中用了 System.exit(int)退出程序。但是，如果 System.exit(int) 在异常语句之后，finally 还是会被执行

• 程序所在的线程死亡

• 关闭 CPU

其他情况下都会执行finally中的信息