Java笔记之面向对象 上（七）_public class test

一、方法的重载

1.基本介绍

方法重载：简单说就是一个类中可以同时存在多个同名的方法，但要求同名方法中的参数列表不同

2.快速入门

public class test{
	public static void main(String[] args) {
		test1 t = new test1();
		t.p();		//无参数p方法！
		t.p(1);		//一个参数p方法！
		t.p(1,2);	//两个参数p方法！
		t.p(1,3.0);	//一个int形参一个double形参的p方法！
	}
}

class test1{
	
	public void p() {
		System.out.println("无参数p方法！");
	}

	public void p(int x) {
		System.out.println("一个参数p方法！");
	}

	public void p(int x,int y) {
		System.out.println("两个参数p方法！");
	}

	public void p(int x,double y) {
		System.out.println("一个int形参一个double形参的p方法！");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3.注意事项

• 重载方法名必须相同
• 形参列表一定不同，返回值随意

本节示例

定义一个类，重载方法max，返回两个int的最大值，返回两个double的最大值，返回三个double的最大值

public class test{
	public static void main(String[] args) {
		test1 t = new test1();
		//方法一
		System.out.println(t.max(5,6));
		//方法二
		System.out.println(t.max(3.0,2.4));
		//方法三
		System.out.println(t.max(7.8,6.2,20.1));
	}
}

class test1{
	public int max(int x,int y) {
		//这里使用三元运算符
		return x>y?x:y;
	}

	public double max(double x,double y) {
		return x>y?x:y;
	}

	public double max(double x,double y,double z) {
		double max1 = x>y?x:y;
		return max1>z?max1:z;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

4.可变参数

基本介绍：对于重载方法功能相等，但参数不同就可以使用可变参数进行优化

注意事项

1. 可变参数的实参可以是0-n个
2. 可变参数的实参就是利用数组
3. 形参中只能有一个可变参数
4. 当可变参数和基本参数混用时，可变参数要放到最后

示例

public class test{
	public static void main(String[] args) {
		test1 t = new test1();
		int arr[] = {1,2,3};
		int s = t.sums(5,arr);
		System.out.println(s);	// 11
	}
}

class test1{
	public int sums(int num, int arr[]){
		for (int i = 0 ; i<arr.length ; i++) {
			num +=arr[i];
		}
		return num;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

二.变量的作用域

全局变量

1. 全局变量一般指类的属性，作用域在整个类中
2. 可以不赋值直接使用，因为有默认值
3. 生命周期较长，伴随对象的创建而创建，对象销毁而销毁
4. 可以被本类或其他类使用
5. 可以加修饰符

局部变量

1. 一般是指在成员方法中定义的变量
2. 可以不赋值直接使用，因为有默认值
3. 生命周期较短，伴随代码块的执行而创建，代码块结束而销毁
4. 不能被其他类使用，只能在本类对应的方法中使用
5. 不能加修饰符

注意事项

• 全局变量和局部变量可以重名，但是遵守就近原则
• 同一个作用域中 如同一个方法中 局部变量不能重名

三.构造方法（重要）

1.基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化

语法格式

[修饰符]　方法名(形参列表){
　　方法体;
}

2.快速入门

public class test{
	public static void main(String[] args) {
		//在创建对象是，类中构造方法将被调用，并且可以直接传值
		Person penson = new Person("zhangsan",20);
		System.out.println(penson.name);	//zhangsan
		System.out.println(penson.age);		//20
	}
}

class Person{
	String name;
	int age;
	
	//有参构造方法
	public Person(String pNmae, int pAge){
		name = pNmae;
		age = pAge;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.使用细节

1. 方法名和类名相同
2. 没有返回值
3. 构造方法可以默认，也可以是public…等
4. 一个类被创建对象时，构造方法会被调用（创建），在创建对象的同时也可以对有参构造方法传值
5. 构造方法的调用, 由系统完成
6. 一个类可以定义多个不同的构造方法，即构造方法的重载
7. 一个类中有一个无参的默认构造方法，如果用户定义了，则默认方法将会覆盖
8. 构造方法默认类中会有，看不到，但是确实存在，建议自己手写无参构造方法
9. 如果自定义了一个有参构造方法，则又需要使用无参的构造，则必须自己定义一个无参构造方法

public class test{
	public static void main(String[] args) {
		//一个参数,另一个参数有默认值
		Person penson = new Person("zhangsan");
		//两个参数
		Person penson1 = new Person("lisi",20);
		
		System.out.println(penson.name+" "+penson.age);	 //zhangsan  0
		System.out.println(penson1.name+" "+penson1.age); //lisi 20
	}
}

class Person{
	String name;
	int age;
	
	//有两个参构造方法
	public Person(String pNmae, int pAge){
		name = pNmae;
		age = pAge;
	}

	//有一个参构造方法
	public Person(String pNmae){
		name = pNmae;
	}
}

class Dog{
	/*
	无参构造器，系统会自动创建，创建对象的时候也会调用这个无参构造方法
	只是我们看不见,但是确实有
	Dog(){

	} 
	 */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

Dog中的无参构造可以通过，找到java文件路径打开cmd，输入javap Dog.class查看到其中的无参构造方法

四.this关键字

为什么要学习this关键字

案例引入：

public class test{
	public static void main(String[] args) {
		Person person = new Person("zhangsan",20);
		person.p();		
	}
}

class Person{
	String name;
	int age;

	public Person(String dName,int dAge){
		name = dName;
		age = dAge;
	}
	/*
	如果想把dName换成name,dAge换成age，则会引起作用域的一个问题
	下面这种情况就会出现name=name，都是局部变量的name，而全局变量name为null，age为0
	如果想像下面这写，则需要用this
	*/
	//public Person(String name,int age){
	// 	name = name;
	// 	age = age;
	//}
	
	public void p(){
		System.out.println(name+" "+age);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

1.基本介绍

this是指java虚拟机中会给每个对象分配this，代表当前对象

public class test{
	public static void main(String[] args) {
		Person person = new Person("zhangsan",20);
		person.p();		
	}
}

class Person{
	String name;
	int age;
	
	//功能与以上代码一样，this.name = name;则与上面name = dName等价
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	public void p(){
		System.out.println(name+" "+age);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.使用细节

• this 关键字可以用来访问本类的属性、方法、构造器
• this 用于区分当前类的属性和局部变量
• 访问成员方法的语法：this.方法名(参数列表)

public class test{
	public static void main(String[] args) {
		Person person = new Person("zhangsan",20);
		person.p();		
	}
}

class test1{
	
	public void t1(){
		System.out.println("我是t1");
	}

	public void t2(){
		//调用本类中的t1方法，有两种，一种直接调用，另一种用this
		t1();
		this.t1();

		System.out.println("我是t2");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 访问构造器语法：this(参数列表) 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)且必须放在第一 条语句

public class test{
	public static void main(String[] args) {
		new test1();	//test1(int x)构造器！	test1()构造器！
	}
}

class test1{
	public test1(){
		this(2);
		System.out.println("test1()构造器！");
	}

	public test1(int x){
		System.out.println("test1(int x)构造器！");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• this 不能在类定义的外部使用，只能在类定义的方法中使用