JavaSE-Day(7)学习笔记

Java系统学习-JavaSE篇
字数统计: 6.9k字   |   阅读时长: 29分

面向对象

成员变量和局部变量的区别

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
38
39
40
41
42
43
44
45
46
/*
	成员变量和局部变量的区别?
		A:在类中的位置不同
			成员变量：在类中方法外
			局部变量：在方法定义中或者方法声明上
		B:在内存中的位置不同
			成员变量：在堆内存
			局部变量：在栈内存
		C:生命周期不同
			成员变量：随着对象的创建而存在，随着对象的消失而消失
			局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
		D:初始化值不同
			成员变量：有默认初始化值
			局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
			
		注意事项：
			局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
*/
class Varialbe {
	//成员变量
	//int num = 10;
	int num; //0
	
	public void show() {
		//int num2 = 20; //局部变量
		//可能尚未初始化变量num2
		//int num2; //没有默认值
		int num2 = 20;
		System.out.println(num2);
		
		//int num = 100;
		System.out.println(num);
	}
}


class VariableDemo {
	public static void main(String[] args) {
		Varialbe v = new Varialbe();
		
		System.out.println(v.num); //访问成员变量
		
		v.show();	
			
	}
}

方法的形式参数是类名的时候如何调用

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
38
39
40
41
42
/*
	形式参数的问题：
		基本类型：形式参数的改变不影响实际参数
		引用类型：形式参数的改变直接影响实际参数
*/
//形式参数是基本类型
class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}

//形式参数是引用类型
class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
	public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
		s.show();
	}
}

class ArgsTest {
	public static void main(String[] args) {
		//形式参数是基本类型的调用
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println("result:"+result);
		System.out.println("--------------");
		
		//形式参数是引用类型的调用
		//需求：我要调用StudentDemo类中的method()方法
		StudentDemo sd = new StudentDemo();
		//创建学生对象
		Student s = new Student();
		sd.method(s); //把s的地址给到了这里
	}
}

匿名对象的概述和应用

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
38
39
40
41
42
43
44
45
46
47
48
49
/*
	匿名对象：就是没有名字的对象。
	
	匿名对象的应用场景：
		A:调用方法，仅仅只调用一次的时候。
			注意：调用多次的时候，不适合。
			那么，这种匿名调用有什么好处吗?
				有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
		B:匿名对象可以作为实际参数传递
*/
class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	public void method(Student s) {
		s.show();
	}
}

class NoNameDemo {
	public static void main(String[] args) {
		//带名字的调用
		Student s = new Student();
		s.show();
		s.show();
		System.out.println("--------------");
		
		//匿名对象
		//new Student();
		//匿名对象调用方法
		new Student().show();
		new Student().show(); //这里其实是重新创建了一个新的对象
		System.out.println("--------------");
		
		
		//匿名对象作为实际参数传递
		StudentDemo sd = new StudentDemo();
		//Student ss = new Student();
		//sd.method(ss); //这里的s是一个实际参数
		//匿名对象
		sd.method(new Student());
		
		//在来一个
		new StudentDemo().method(new Student());
 	}
}

封装和private

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
封装(理解)
    (1)隐藏实现细节，提供公共的访问方式
    (2)好处：
        A:隐藏实现细节，提供公共的访问方式
        B:提高代码的复用性
        C:提高代码的安全性
    (3)设计原则
        把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
    (4)private是封装的一种体现。
        封装：类，方法，private修饰成员变量

private关键字(掌握)
    (1)私有的意义，可以修饰成员变量和成员方法
    (2)特点：
        被private修饰的后的成员只能在本类中被访问
    (3)private的应用：
        以后再写一个类的时候：
            把所有的成员变量给private了
            提供对应的getXxx()/setXxx()方法

private的引出

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/*
	定义一个学生类：
		成员变量：name，age
		成员方法：show()方法
		
	我们在使用这个案例的过程中，发现了一个问题：
		通过对象去给成员变量赋值，可以赋值一些非法的数据。
		这是不合理的。
		应该是这个样子的：在赋值之前，先对数据进行判断。
		判断到底在哪里做比较合适呢?
		StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。	
		所以，这个判断应该定义在Student类中。
		而我们在成员变量的位置可不可以进行数据判断呢?
		是不可以的，因为做数据校验，必须要依靠一些逻辑语句。
		逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法
		来对数据进行校验。
	
	按照我们前面的分析，我们给出了一个方法进行校验。
	但是呢，它偏偏不调用方法来赋值，还是直接赋值了，
	这样我们的方法就没有起到作用。
	我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。
	怎么去强制要求不能直接使用成员变量呢?
		针对这种情况，Java就提供了一个关键字 private
		
	private:私有的。可以修饰成员变量和成员方法。
		注意：被private修饰的成员只能在本类中访问。
		
	其实我讲到现在讲解的是一个封装的思想。
	封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
*/
class Student {
	//姓名
	String name;
	//年龄
	private int age;
	
	//写一个方法对数据进行校验
	/*
		返回值类型：void
		参数列表：int a
	*/
	public void setAge(int a) {
		if(a < 0 || a > 120) {
			System.out.println("你给的年龄有问题");
		}else {
			age = a;
		}
	}
	
	
	//show()方法,显示所有成员变量值
	public void show() {
		System.out.println("姓名："+name);
		System.out.println("年龄："+age);
	}
}

class StudentDemo {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		s.show();
		System.out.println("--------------");
		
		//给成员变量赋值
		s.name = "林青霞";
		//s.age = 27;
		s.setAge(27);
		s.show();
		System.out.println("--------------");
		
		//给age赋值
		//s.age = -27; //这个数据是不合理的
		//通过方法给值
		s.setAge(-27);
		s.show();
		System.out.println("--------------");
	}
}

private关键字的概述和特点

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
/*
	private:
		是一个权限修饰符
		可以修饰成员变量和成员方法
		被其修饰的成员只能在本类中被访问
*/
class Demo {
	//int num = 10;
	//用private修饰
	private int num = 10;
	
	public void show() {
		System.out.println(num);
	}
	
	private void method() {
		System.out.println("method");
	}
	
	public void function() {
		method();
	}
}

class PrivateDemo {
	public static void main(String[] args) {
		Demo d = new Demo();
		//不能方法私有的成员变量
		//System.out.println(d.num);
		d.show();
		//不能访问私有的成员方法
		//d.method();
		d.function();
	}
}

private的应用标准案例

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
/*
	封装和private的应用：
		A:把成员变量用private修饰
		B:提高对应的getXxx()和setXxx()方法
*/
//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String n) {
		name = n;
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}
	
	//年龄赋值
	public void setAge(int a) {
		age = a;
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		
		//使用成员变量
		//错误：被私有修饰了，外界不能直接访问了
		//System.out.println(s.name+"---"+s.age);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//给成员变量赋值
		//s.name = "林青霞";
		//s.age = 27;
		//通过方法给赋值
		s.setName("林青霞");
		s.setAge(27);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

this关键字的概述和应用

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/*
	我们曾经曰：起名字要做到见名知意。
	
	this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。
	
		注意：谁调用这个方法，在该方法内部的this就代表谁。
		
	this的场景：
		解决局部变量隐藏成员变量
*/
//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String name) { //name = "林青霞";
		//name = name; //变量的使用规则：就近原则
		//这里是类名，目前还没有说过类似的用法，所以这个是有问题的
		//这里的调用只能通过对象名
		//这个对象如果存在，它应该代表的是Student的一个对象。
		//那么，谁能够代表当前类的对象呢? java就提供了一个关键字 this
		//Student.name = name;
		this.name = name;
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}
	
	//年龄赋值
	public void setAge(int age) {
		this.age = age;
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		
		//给成员变量赋值
		s.setName("林青霞");
		s.setAge(27);
		//获取数据
		System.out.println(s.getName()+"---"+s.getAge());
	}
}
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
38
39
40
41
/*
	标准的代码改进版
	
	this:哪个对象调用那个方法，this就代表那个对象
*/
class Student {
	private String name;
	private int age;
	
	public String getName() {
		return name; //这里其实是隐含了this
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
}

class StudentTest2 {
	public static void main(String[] args) {
		//创建一个对象
		Student s1 = new Student();
		s1.setName("林青霞");
		s1.setAge(27);
		System.out.println(s1.getName()+"---"+s1.getAge());
		
		//创建第二个对象
		Student s2 = new Student();
		s2.setName("刘意");
		s2.setAge(30);
		System.out.println(s2.getName()+"---"+s2.getAge());
	}
}

this关键字的内存图解

tupian1

标准手机类代码及其测试

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/*
	作业：请把手机类写成一个标准类，然后创建对象测试功能。
	
	手机类：
		成员变量：
			品牌：String brand;
			价格：int price;
			颜色：String color;
		成员方法：
			针对每一个成员变量给出对应的getXxx()/setXxx()方法。
		最后定义测试：
			创建一个对象，先通过getXxx()方法输出成员变量的值。这一次的结果是：null---0---null
			然后通过setXxx()方法给成员变量赋值。再次输出结果。这一次的结果是：三星---2999---土豪金
*/
class Phone {
	//品牌
	private String brand;
	//价格
	private int price;
	//颜色
	private String color;
	
	//getXxx()和setXxx()方法
	public String getBrand() {
		return brand;
	}
	
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public int getPrice() {
		return price;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
	
	public String getColor() {
		return color;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
}

class PhoneTest {
	public static void main(String[] args) {
		//创建手机对象
		Phone p = new Phone();
		
		//直接输出默认值
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
		
		//给成员变量赋值
		p.setBrand("三星");
		p.setPrice(2999);
		p.setColor("土豪金");
		//再次输出
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
	}
}

构造方法概述和格式

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
/*
	构造方法：
		给对象的数据进行初始化

	格式：
		A:方法名与类名相同
		B:没有返回值类型，连void都没有
		C:没有具体的返回值
*/
class Student {
	private String name; //null
	private int age; //0
	
	public Student() {
		System.out.println("这是构造方法");
	}
}

class ConstructDemo {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		System.out.println(s); //Student@e5bbd6
	}
}

构造方法的重载及注意事项

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
/*
	我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?
	
	构造方法的注意事项:
		A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
		B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
			注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
		
	给成员变量赋值有两种方式：
		A:setXxx()
		B:构造方法
*/

class Student {
	private String name;
	private int age;

	public Student() {
		//System.out.println("我给了，你还给不");
		System.out.println("这是无参构造方法");
	}
	
	//构造方法的重载格式
	public Student(String name) {
		System.out.println("这是带一个String类型的构造方法");
		this.name = name;
	}
	
	public Student(int age) {
		System.out.println("这是带一个int类型的构造方法");
		this.age = age;
	}
	
	public Student(String name,int age) {
		System.out.println("这是一个带多个参数的构造方法");
		this.name = name;
		this.age = age;
	}
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

class ConstructDemo2 {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		s.show();
		System.out.println("-------------");
		
		//创建对象2
		Student s2 = new Student("林青霞");
		s2.show();
		System.out.println("-------------");
		
		//创建对象3
		Student s3 = new Student(27);
		s3.show();
		System.out.println("-------------");
		
		//创建对象4
		Student s4 = new Student("林青霞",27);
		s4.show();
	}
}

成员方法的分类及使用

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/*
    类的组成：成员变量，成员方法
    今天我们又加入了一个新的成员：构造方法。
    以后再提类的组成：
        1、成员变量
        2、构造方法
        3、成员方法
            根据返回值：
                void类型
                非void类型
            形式参数：
                空参方法
                非空参方法
*/
class Student {
    public String getString() {
        return "helloworld";
    }

    public void show() {
        System.out.println("show");
    }
    
    public void method(String name) {
        System.out.println(name);
    }
    
    public String function(String s1,String s2) {
        return s1+s2;
    }
}

class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        
        //调用无参无返回值方法
        s.show();
        
        //调用无参有返回值方法
        String result = s.getString();
        System.out.println(result);
        
        //调用带参无返回值的方法
        s.method("林青霞");
        
        //调用带参带返回值的方法
        String result2 = s.function("hello","world");
        System.out.println(result2);
    }
}

一个标准学生类的代码及测试

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*
	一个标准代码的最终版。
	
	学生类：
		成员变量：
			name，age
		构造方法：
			无参，带两个参
		成员方法：
			getXxx()/setXxx()
			show()：输出该类的所有成员变量值
			
	给成员变量赋值：
		A:setXxx()方法
		B:构造方法
		
	输出成员变量值的方式：
		A:通过getXxx()分别获取然后拼接
		B:通过调用show()方法搞定
*/
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//构造方法
	public Student() {
	}
	
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	//输出所有的成员变量值
	public void show() {
		System.out.println(name+"---"+age);
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//方式1给成员变量赋值
		//无参构造+setXxx()
		Student s1 = new Student();
		s1.setName("林青霞");
		s1.setAge(27);
		//输出值
		System.out.println(s1.getName()+"---"+s1.getAge());
		s1.show();
		System.out.println("----------------------------");
		
		//方式2给成员变量赋值
		Student s2 = new Student("刘意",30);
		System.out.println(s2.getName()+"---"+s2.getAge());
		s2.show();
	}
}

一个标准手机类的代码及测试

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/*
	标准的手机类练习
	
	手机类：
		成员变量：brand,price,color
		构造方法：无参构造
		成员方法：getXxx()/setXxx()
*/
//定义手机类
class Phone {
	//品牌
	private String brand;
	//价格
	private int price;
	//颜色
	private String color;
	
	//无参构造方法
	public Phone() {}
	
	//getXxx()和setXxx()方法
	public String getBrand() {
		return brand;
	}
	
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public int getPrice() {
		return price;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
	
	public String getColor() {
		return color;
	}
	
	public void setColor(String color) {
		this.color = color;
	} 
}

//手机测试类
class PhoneTest {
	public static void main(String[] args) {
		//创建对象
		Phone p = new Phone();
		
		//给成员变量赋值
		p.setBrand("诺基亚");
		p.setPrice(199);
		p.setColor("土豪金");
		
		//获取值
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
	}
}

创建对象做了哪些事情

1
2
3
4
5
6
7
(1)把Student.class文件加载到内存
    (2)在栈内存为s开辟空间
    (3)在堆内存为学生对象申请空间
    (4)给学生的成员变量进行默认初始化。null,0
    (5)给学生的成员变量进行显示初始化。林青霞,27
    (6)通过构造方法给成员变量进行初始化。刘意,30
    (7)对象构造完毕，把地址赋值给s变量

tupian111

什么时候定义成员变量

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/*
	定义一个类Demo,其中定义一个求两个数据和的方法，
	定义一个测试了Test，进行测试。
	
	变量什么时候定义为成员变量：
		如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。
		
	变量到底定义在哪里好呢?
		变量的范围是越小越好。因为能及时的被回收。
*/

//方式1
/*
class Demo {
	public int sum() {
		int a = 10;
		int b = 20;
		int c = a + b;
		return c;
	}
}
*/
//方式1满足了我们的要求，但是不好。
//因为参与操作的数据现在是固定的。

//方式2
/*
class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}
*/

//方式2可以满足我们的要求，但是呢我们学习过来面向对象的思想。
//我就再想，a，b可不可以定义为成员变量呢?
//如果可以，我们再改进一版
class Demo {
	int a;
	int b;
	
	public int sum() {
		return a + b;
	}
}
//虽然这种方式可以，并且好像是符合了面向对象的思想。
//但是不好。
//因为我们曾经说过：类是一组相关的属性和行为的集合。
//并且类是通过事物转换过来的
//而类中的成员变量就是事物的属性
//属性是用来描述事物的
//同理：成员变量其实是用来描述类的。

//测试类
class Test {
	public static void main(String[] args) {
		//创建对象
		//方式1测试
		/*
		Demo d = new Demo();
		System.out.println(d.sum());
		*/
		
		//方式2测试
		/*
		Demo d = new Demo();
		int a = 10;
		int b = 20;
		System.out.println(d.sum(a,b));
		*/
		
		//方式3测试
		Demo d = new Demo();
		d.a = 10;
		d.b = 20;
		System.out.println(d.sum());
	}
}

长方形案例练习

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
/*
	定义一个长方形类,定义 求周长和面积的方法，
	然后定义一个测试了Test2，进行测试。

	长方形的类：
		成员变量：
			长，宽
		成员方法：
			求周长：(长+宽)*2;
			求面积：长*宽
			
	注意：
		import必须出现在所有的class前面。
*/

import java.util.Scanner;

class ChangFangXing {
	//长方形的长
	private int length;
	//长方形的宽
	private int width;
	
	public ChangFangXing(){}
	
	//仅仅提供setXxx()即可
	public void setLength(int length) {
		this.length = length;
	}
	
	public void setWidth(int width) {
		this.width = width;
	}
	
	//求周长
	public int getZhouChang() {
		return (length + width) * 2;
	}
	
	//求面积
	public int getArea() {
		return length * width;
	}
}

class Test2 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入长方形的长：");
		int length = sc.nextInt();
		System.out.println("请输入长方形的宽：");
		int width = sc.nextInt();
		
		//创建对象
		ChangFangXing cfx = new ChangFangXing();
		//先给成员变量赋值
		cfx.setLength(length);
		cfx.setWidth(width);
		
		System.out.println("周长是："+cfx.getZhouChang());
		System.out.println("面积是："+cfx.getArea());
	}
}

员工类案例练习

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
/*
	需求：
		定义一个员工类,自己分析出几个成员，
		然后给出成员变量，构造方法，getXxx()/setXxx()方法，
		以及一个显示所有成员信息的方法。并测试。

	分析：
		员工
			成员变量：
				员工编号，姓名，年龄
			构造方法：
				无参构造方法
			成员方法：
				getXxx()/setXxx()
				show();
*/
class Employee {
	//员工编号
	private String employeeId;
	//姓名
	private String name;
	//年龄
	private int age;
	
	//构造方法
	public Employee() {}
	
	//getXxx()/setXxx()
	public String getEmployeeId() {
		return employeeId;
	}
	
	public void setEmployeeId(String employeeId) {
		this.employeeId = employeeId;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	//显示所有成员信息的方法
	public void show() {
		System.out.println("员工编号是："+employeeId+"的这个人是："+name+"的年龄是："+age);
	}
}

class EmployeeTest {
	public static void main(String[] args) {
		//创建对象
		Employee e = new Employee();
		
		//给成员变量赋值
		e.setEmployeeId("czbk9527");
		e.setName("唐伯虎");
		e.setAge(18);
		
		//获取数据
		//System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());
	
		//我们在Employee类中定义了一个show方法。所以，我们改进一下，使用show方法
		e.show();
	}
}

自己实现加减乘除并测试

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
38
39
40
41
42
43
44
45
46
47
/*
	定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
*/
import java.util.Scanner;

class MyMath {
	//加法功能
	public int add(int a,int b) {
		return a + b;
	}
	
	//减法功能
	public int sub(int a,int b) {
		return a - b;
	}
	
	//乘法功能
	public int mul(int a,int b){
		return a * b;
	}
	
	//除法功能
	public int div(int a,int b) {
		return a / b;
	}
}

//测试类
class MyMathTest {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入第一个操作数：");
		int firstNumber = sc.nextInt();
		System.out.println("请输入第二个操作数：");
		int secondNumber = sc.nextInt();
		
		//创建MyMath对象，并使用
		MyMath mm = new MyMath();
		
		System.out.println("加法结果："+mm.add(firstNumber,secondNumber));
		System.out.println("减法结果："+mm.sub(firstNumber,secondNumber));
		System.out.println("乘法结果："+mm.mul(firstNumber,secondNumber));
		System.out.println("除法结果："+mm.div(firstNumber,secondNumber));
	}
}

static关键字的引入

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
static关键字(理解)
    (1)静态的意思。可以修饰成员变量和成员方法。
    (2)静态的特点：
        A:随着类的加载而加载
        B:优先与对象存在
        C:被类的所有对象共享
            这其实也是我们判断该不该使用静态的依据。
            举例：饮水机和水杯的问题思考
        D:可以通过类名调用
            既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
    (3)静态的内存图
        静态的内容在方法区的静态区
    (4)静态的注意事项；
        A:在静态方法中没有this对象
        B:静态只能访问静态(代码测试过)
    (5)静态变量和成员变量的区别
        A:所属不同
            静态变量：属于类，类变量
            成员变量：属于对象，对象变量，实例变量
        B:内存位置不同
            静态变量：方法区的静态区
            成员变量：堆内存
        C:生命周期不同
            静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
            成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
        D:调用不同
            静态变量：可以通过对象名调用，也可以通过类名调用
            成员变量：只能通过对象名调用
    (6)main方法是静态的
        public:权限最大
        static:不用创建对象调用
        void:返回值给jvm没有意义
        main:就是一个常见的名称。
        String[] args:可以接收数据，提供程序的灵活性
            格式：java MainDemo hello world java
                  java MainDemo 10 20 30
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/*
	定义一个人类
	
	姓名和年龄都是变化的，这个我能接收，因为每个人的姓名和年龄是不同的。
	但是，我们现在选取的几个人都是中国人，他们的国籍是一样的。
	一样的国籍，我每次创建对象，在堆内存都要开辟这样的空间，
	我就觉得有点浪费了。怎么办呢? 
		针对多个对象有共同的这样的成员变量值的时候，
		Java就提高了一个关键字来修饰：static。
*/
class Person {
	//姓名
	String name;
	//年龄
	int age;
	//国籍
	//String country;
	static String country;
	
	public Person(){}
	
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public Person(String name,int age,String country) {
		this.name = name;
		this.age = age;
		this.country = country;
	}
	
	public void show() {
		System.out.println("姓名："+name+",年龄："+age+",国籍："+country);
	}
}

class PersonDemo {
	public static void main(String[] args) {
		//创建对象1
		Person p1 = new Person("邓丽君",16,"中国");
		p1.show();
		
		//创建对象2
		//Person p2 = new Person("杨幂",22,"中国");
		//p2.show();
		Person p2 = new Person("杨幂",22);
		p2.show();
		
		//创建对象3
		//Person p3 = new Person("凤姐",20,"中国");
		//p3.show();
		Person p3 = new Person("凤姐",20);
		p3.show();
		
		p3.country = "美国";
		p3.show();
		
		p1.show();
		p2.show();
	}
}

static关键字的特点

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
/*
	static的特点：(它可以修饰成员变量，还可以修饰成员方法)
		A:随着类的加载而加载
			回想main方法。
		B:优先于对象存在
		C:被类的所有对象共享
			举例：咱们班级的学生应该共用同一个班级编号。
			其实这个特点也是在告诉我们什么时候使用静态?
				如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
			举例：
				饮水机(用静态修饰)
				水杯(不能用静态修饰)
		D:可以通过类名调用
			其实它本身也可以通过对象名调用。
			推荐使用类名调用。
			
			静态修饰的内容一般我们称其为：与类相关的，类成员
*/
class Student {
	//非静态变量
	int num = 10;
	
	//静态变量
	static int num2 = 20;
}

class StudentDemo {
	public static void main(String[] args) {
		Student s = new Student();
		System.out.println(s.num);
		
		System.out.println(Student.num2);
		System.out.println(s.num2);
	}
}

static关键字的内存图解

tupian2222

static关键字的注意事项

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/*
	static关键字注意事项
		A:在静态方法中是没有this关键字的
			如何理解呢?
				静态是随着类的加载而加载，this是随着对象的创建而存在。
				静态比对象先存在。
		B:静态方法只能访问静态的成员变量和静态的成员方法
				静态方法：
					成员变量：只能访问静态变量
					成员方法：只能访问静态成员方法
				非静态方法：
					成员变量：可以是静态的，也可以是非静态的
					成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
			简单记：
				静态只能访问静态。
*/
class Teacher {
	public int num = 10;
	public static int num2 = 20;
	
	public void show() {
		System.out.println(num); //隐含的告诉你访问的是成员变量
		System.out.println(this.num); //明确的告诉你访问的是成员变量
		System.out.println(num2);
		
		//function();
		//function2();
	}
	
	public static void method() {
		//无法从静态上下文中引用非静态 变量 num
		//System.out.println(num);
		System.out.println(num2);
		
		//无法从静态上下文中引用非静态 方法 function()
		//function();
		function2();
	}
	
	public void function() {
	
	}
	
	public static void function2() {
	
	}
}

class TeacherDemo {
	public static void main(String[] args) {
		//创建对象
		Teacher t = new Teacher();
		t.show();
		System.out.println("------------");
		t.method();
	}
}

main方法的格式详解

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
/*
	main方法的格式讲解：
		public static void main(String[] args) {...}
		
		public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
		static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
		void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
		main:是一个常见的方法入口。我见过的语言都是以main作为入口。
		String[] args:这是一个字符串数组。值去哪里了?
			这个东西到底有什么用啊?怎么给值啊?
				这个东西早期是为了接收键盘录入的数据的。
				格式是：
					java MainDemo hello world java
*/
class MainDemo {
	public static void main(String[] args) {
		//System.out.println(args); //[Ljava.lang.String;@175078b
		//System.out.println(args.length); //0
		//System.out.println(args[0]); //ArrayIndexOutOfBoundsException
		
		//接收数据后
		System.out.println(args); 
		System.out.println(args.length); 
		//System.out.println(args[0]); 
		for(int x=0; x<args.length; x++) {
			System.out.println(args[x]);
		}
	}
}

赏

×

纯属好玩

扫码支持
扫码打赏，你说多少就多少

打开支付宝扫一扫，即可进行扫码打赏哦

本文标题:JavaSE-Day(7)学习笔记

文章作者:Stephencurry6666

发布时间:2020年05月26日 - 15时24分

最后更新:2020年05月26日 - 20时49分

原始链接:https://stephencurry6666.github.io/2020/05/26/JavaSE-Day(7)%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 面向对象
    1. 1.1. 成员变量和局部变量的区别
    2. 1.2. 方法的形式参数是类名的时候如何调用
    3. 1.3. 匿名对象的概述和应用
    4. 1.4. 封装和private
    5. 1.5. private的引出
    6. 1.6. private关键字的概述和特点
    7. 1.7. private的应用标准案例
    8. 1.8. this关键字的概述和应用
    9. 1.9. this关键字的内存图解
    10. 1.10. 标准手机类代码及其测试
    11. 1.11. 构造方法概述和格式
    12. 1.12. 构造方法的重载及注意事项
    13. 1.13. 成员方法的分类及使用
    14. 1.14. 一个标准学生类的代码及测试
    15. 1.15. 一个标准手机类的代码及测试
    16. 1.16. 创建对象做了哪些事情
    17. 1.17. 什么时候定义成员变量
    18. 1.18. 长方形案例练习
    19. 1.19. 员工类案例练习
    20. 1.20. 自己实现加减乘除并测试
    21. 1.21. static关键字的引入
    22. 1.22. static关键字的特点
    23. 1.23. static关键字的内存图解
    24. 1.24. static关键字的注意事项
    25. 1.25. main方法的格式详解
,
字数统计：87.6k 载入天数...载入时分秒...