一、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中的信息
网友评论