一、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中的信息