07.01 成员变量和局部变量的区别
1.在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
2.在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
3.生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
4.初始化值不同
成员变量 有默认的初始化值
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
07.02 方法的形式参数是类名的调用
例:
1 class Demo
2 {
3 public static void main(String[] args)
4 {
5 //创建学生对象
6 Student s = new Student();
7 StudentDemo sd = new StudentDemo();
8 sd.method(s);
9 }
10 }
11 class StudentDemo
12 {
13 //形式参数是引用类型
14 public void method(Student s)
15 {
16 s.show();
17 }
18 }
19 class Student
20 {
21 public void show()
22 {
23 System.out.println("学生爱学习");
24 }
25 }
07.03 匿名对象的概述和应用
匿名对象:就是没有名字的对象。是对象的一种简化表示形式
匿名对象的两种使用情况:
1.对象调用方法仅仅一次的时候
2.作为实际参数传递
例:
1 class Demo
2 {
3 public static void main(String[] args)
4 {
5 //匿名对象调用方法
6 new Student().show();
7 }
8 }
9 class Student
10 {
11 public void show()
12 {
13 System.out.println("学生爱学习");
14 }
15 }
匿名对象调用完毕就是垃圾，垃圾回收器会在适当的时间回收，提高内存的使用效率
07.04 封装的概述
封装概述:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
例:
1 class Student
2 {
3 String name;
4 //将age私有，只能在Student类中访问
5 private int age;
6
7 //提供对外访问的方法获取age的值
8 public int getAge()
9 {
10 return age;
11 }
12 //提供对外访问的方法，并可以对传入的a的值进行判断，满足条件则赋值给age，不满足则不赋值
13 public void setAge(int a)
14 {
15 age = a;
16 }
17 public void show()
18 {
19 System.out.println("姓名:"+name+" "+"年龄:"+age);
20 }
21 }
07.05 封装的好处和设计原则
封装好处:
1.隐藏实现细节，提供公共的访问方式
2.提高了代码的复用性
3.提高安全性
封装原则:将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。
07.06 private关键字的概述和特点
private关键字:是一个权限修饰符。可以修饰成员(成员变量和成员方法)，被private修饰的成员只在本类中才能访问。
private最常见的应用:
1.把成员变量用private修饰
2.提供对应的getXxx()/setXxx()方法
07.07 private的应用标准案例
1 class Demo
2 {
3 public static void main(String[] args)
4 {
5 Student s = new Student();
6 //给成员变量赋值
7 s.setName("小强");
8 s.setAge(25);
9
10 System.out.println(s.getName()+":"+s.getAge());
11 }
12 }
13 class Student
14 {
15 private String name;
16 //将age私有，只能在Student类中访问
17 private int age;
18
19 //提供对外访问的方法获取name的值
20 public String getName()
21 {
22 return name;
23 }
24 //提供对外访问的方法设置name的值
25 public void setName(String n)
26 {
27 name = n;
28 }
29 //提供对外访问的方法获取age的值
30 public int getAge()
31 {
32 return age;
33 }
34 //提供对外访问的方法设置age的值
35 public void setAge(int a)
36 {
37 age = a;
38 }
39 }
07.08 this关键字的概述和应用
this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
当局部变量隐藏成员变量时使用this
例:
1 class Student
2 {
3 private String name;
4 //将age私有，只能在Student类中访问
5 private int age;
6
7 //提供对外访问的方法获取name的值
8 public String getName()
9 {
10 return name;
11 }
12 //提供对外访问的方法设置name的值
13 public void setName(String name)
14 {
15 this.name = name;
16 }
17 //提供对外访问的方法获取age的值
18 public int getAge()
19 {
20 return age;
21 }
22 //提供对外访问的方法设置age的值
23 public void setAge(int age)
24 {
25 this.age = age;
26 }
27 }
07.09 this关键字的内存图解
07.10 标准的手机类代码及其测试
1 class Demo
2 {
3 public static void main(String[] args)
4 {
5 Phone p = new Phone();
6 System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
7 p.setBrand("小米");
8 p.setPrice(1999);
9 p.setColor("白色");
10 System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
11 }
12 }
13 class Phone
14 {
15 private String brand;//品牌
16 private int price;//价格
17 private String color;//颜色
18
19 public String getBrand()
20 {
21 return brand;
22 }
23 public void setBrand(String brand)
24 {
25 this.brand = brand;
26 }
27
28 public int getPrice()
29 {
30 return price;
31 }
32 public void setPrice(int price)
33 {
34 this.price = price;
35 }
36
37 public String getColor()
38 {
39 return color;
40 }
41 public void setColor(String color)
42 {
43 this.color = color;
44 }
45 }
运行结果:
品牌:null 价格:0 颜色:null 品牌:小米价格:1999 颜色:白色
07.11 构造方法概述和格式
构造方法作用概述:给对象的数据进行初始化
构造方法格式:
1.方法名与类名相同
2.没有返回值类型，连void都没有
3.没有具体的返回值
例:
07.12 构造方法的重载及注意事项
构造方法注意事项:
1.如果不提供构造方法，系统会给出默认构造方法
2.如果提供了构造方法，系统将不再提供
3.构造方法也是可以重载的
07.13 成员方法的分类及使用
方法具体划分:
根据返回值:1.有明确返回值方法 2.返回void类型的方法
根据形式参数:1.无参方法 2.带参方法
例:
1 class Demo
2 {
3 public static void main(String[] args)
4 {
5 Student s = new Student();
6 String str = s.getString();
7 System.out.println(str);
8 s.show();
9 s.method("小强");
10 }
11 }
12 class Student
13 {
14 private String name;
15 private int age;
16 //有明确返回值的无参方法
17 public String getString()
18 {
19 return "hello";
20 }
21 //返回void类型的无参方法
22 public void show()
23 {
24 System.out.println("show run");
25 }
26 //返回void类型的带参方法
27 public void method(String name)
28 {
29 System.out.println("name:"+name);
30 }
31 }
07.14 一个标准学生类的代码及测试
类的组成:
1.成员变量
2.构造方法[无参构造方法 / 带参构造方法]
3.成员方法[getXxx() / setXxx()]
给成员变量赋值的方式
1.无参构造方法 + setXxx()
2.带参构造方法
1 /*
2 学生类:
3 成员变量:name，age
4 构造方法:无参，带两个参
5 成员方法:getXxx()/setXxx()
6 show():输出该类的所有成员变量值
7
8 给成员变量赋值:
9 A:setXxx()方法
10 B:构造方法
11
12 输出成员变量值的方式:
13 A:通过getXxx()分别获取然后拼接
14 B:通过调用show()方法搞定
15 */
16 //测试类
17 class Demo
18 {
19 public static void main(String[] args)
20 {
21 //方式1给成员变量赋值
22 //无参构造+setXxx()
23 Student s1 = new Student();
24 s1.setName("小明");
25 s1.setAge(27);
26 //输出值
27 System.out.println(s1.getName()+"---"+s1.getAge());
28 System.out.println("----------------------------");
29
30 //方式2给成员变量赋值
31 Student s2 = new Student("小强",30);
32 s2.show();
33 }
34 }
35
36 class Student
37 {
38 //姓名
39 private String name;
40 //年龄
41 private int age;
42
43 //构造方法
44 public Student()
45 {
46 }
47
48 public Student(String name,int age)
49 {
50 this.name = name;
51 this.age = age;
52 }
53
54 public String getName()
55 {
56 return name;
57 }
58
59 public void setName(String name)
60 {
61 this.name = name;
62 }
63
64 public int getAge()
65 {
66 return age;
67 }
68
69 public void setAge(int age)
70 {
71 this.age = age;
72 }
73
74 //输出所有的成员变量值
75 public void show()
76 {
77 System.out.println(name+"---"+age);
78 }
79 }
07.15 一个标准的手机的代码及测试
1 //测试类
2 class Demo
3 {
4 public static void main(String[] args)
5 {
6 //创建对象
7 Phone p = new Phone();
8
9 //给成员变量赋值
10 p.setBrand("小米");
11 p.setPrice(2299);
12 p.setColor("白色");
13
14 //获取值
15 System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
16 }
17 }
18
19 //定义手机类
20 class Phone
21 {
22 //品牌
23 private String brand;
24 //价格
25 private int price;
26 //颜色
27 private String color;
28
29 //无参构造方法
30 public Phone()
31 {
32 }
33
34 //getXxx()和setXxx()方法
35 public String getBrand()
36 {
37 return brand;
38 }
39 public void setBrand(String brand)
40 {
41 this.brand = brand;
42 }
43
44 public int getPrice()
45 {
46 return price;
47 }
48 public void setPrice(int price)
49 {
50 this.price = price;
51 }
52
53 public String getColor()
54 {
55 return color;
56 }
57 public void setColor(String color)
58 {
59 this.color = color;
60 }
61 }
07.16 创建对象做了哪些事情
Student s = new Student();在内存中做了哪些事情?
1.加载Student.class文件进内存
2.在栈内存为s开辟空间
3.在堆内存为学生对象开辟空间
4.对学生对象的成员变量进行默认初始化
5.对学生对象的成员变量进行显示初始化
6.通过构造方法对学生对象的成员变量赋值
7.学生对象初始化完毕，把对象地址赋值给s变量
07.17 什么时候定义成员变量
如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。变量的范围越小越好，因为能及时的被回收。
07.18 长方形案例练习
定义一个长方形类,定义求周长和面积的方法，然后定义一个测试类Demo，进行测试。
1 /*
2 成员变量:长，宽
3 成员方法:
4 求周长:(长+宽)*2;
5 求面积:长*宽
6 */
7 import java.util.Scanner;
8 class ChangFangXing
9 {
10 //长方形的长
11 private int length;
12 //长方形的宽
13 private int width;
14
15 public ChangFangXing()
16 {
17 }
18
19 //仅仅提供setXxx()即可
20 public void setLength(int length)
21 {
22 this.length = length;
23 }
24
25 public void setWidth(int width)
26 {
27 this.width = width;
28 }
29
30 //求周长
31 public int getZhouChang()
32 {
33 return (length + width) * 2;
34 }
35
36 //求面积
37 public int getArea()
38 {
39 return length * width;
40 }
41 }
42
43 //测试类
44 class Demo
45 {
46 public static void main(String[] args)
47 {
48 //创建键盘录入对象
49 Scanner sc = new Scanner(System.in);
50
51 System.out.println("请输入长方形的长:");
52 int length = sc.nextInt();
53 System.out.println("请输入长方形的宽:");
54 int width = sc.nextInt();
55
56 //创建对象
57 ChangFangXing cfx = new ChangFangXing();
58 //先给成员变量赋值
59 cfx.setLength(length);
60 cfx.setWidth(width);
61
62 System.out.println("周长是:"+cfx.getZhouChang());
63 System.out.println("面积是:"+cfx.getArea());
64 }
65 }
07.19 员工类案例练习
1 /*
2 成员变量:员工编号，姓名，年龄
3 构造方法:无参构造方法
4 成员方法:
5 getXxx()/setXxx();
6 show();
7 */
8
9 class Employee
10 {
11 //员工编号
12 private String employeeId;
13 //姓名
14 private String name;
15 //年龄
16 private int age;
17
18 //构造方法
19 public Employee()
20 {
21 }
22
23 //getXxx()/setXxx()
24 public String getEmployeeId()
25 {
26 return employeeId;
27 }
28
29 public void setEmployeeId(String employeeId)
30 {
31 this.employeeId = employeeId;
32 }
33
34 public String getName()
35 {
36 return name;
37 }
38
39 public void setName(String name)
40 {
41 this.name = name;
42 }
43
44 public int getAge()
45 {
46 return age;
47 }
48
49 public void setAge(int age)
50 {
51 this.age = age;
52 }
53
54 //显示所有成员信息的方法
55 public void show()
56 {
57 System.out.println("员工编号:"+employeeId+" 姓名:"+name+" 年龄:"+age);
58 }
59 }
60
61 //测试类
62 class Demo
63 {
64 public static void main(String[] args)
65 {
66 //创建对象
67 Employee e = new Employee();
68
69 //给成员变量赋值
70 e.setEmployeeId("ID8899");
71 e.setName("旺财");
72 e.setAge(18);
73
74 //获取数据
75 //System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());
76
77 //使用show方法
78 e.show();
79 }
80 }
07.20 实现加减乘除并测试
1 import java.util.Scanner;
2 class MyMath
3 {
4 //加法功能
5 public int add(int a,int b)
6 {
7 return a + b;
8 }
9
10 //减法功能
11 public int sub(int a,int b)
12 {
13 return a - b;
14 }
15
16 //乘法功能
17 public int mul(int a,int b)
18 {
19 return a * b;
20 }
21
22 //除法功能
23 public int div(int a,int b)
24 {
25 return a / b;
26 }
27 }
28
29 //测试类
30 class Demo
31 {
32 public static void main(String[] args)
33 {
34 //创建键盘录入对象
35 Scanner sc = new Scanner(System.in);
36
37 System.out.println("请输入第一个操作数:");
38 int num1 = sc.nextInt();
39 System.out.println("请输入第二个操作数:");
40 int num2 = sc.nextInt();
41
42 //创建MyMath对象，并使用
43 MyMath mm = new MyMath();
44
45 System.out.println(num1+"+"+num2+"="+mm.add(num1,num2));
46 System.out.println(num1+"-"+num2+"="+mm.sub(num1,num2));
47 System.out.println(num1+"*"+num2+"="+mm.mul(num1,num2));
48 System.out.println(num1+"/"+num2+"="+mm.div(num1,num2));
49 }
50 }
运行结果:
请输入第一个操作数: 8 请输入第二个操作数: 2 8+2=10 8-2=6 8*2=16 8/2=4
07.21 static关键字的引入
例:
1 class Person
2 {
3 String name;
4 //使用static修饰的数据称为对象的共享数据
5 static String country = "中国";
6 public void show()
7 {
8 System.out.println("姓名:"+name+" 国家:"+country);
9 }
10 }
11
12 class Demo
13 {
14 public static void main(String[] args)
15 {
16 Person p1 = new Person();
17 p1.name = "小明";
18 p1.show();
19
20 Person p2 = new Person();
21 p2.name = "小红";
22 p2.country = "美国";
23 p2.show();
24 p1.show();
25
26 }
27 }
运行结果:
姓名:小明 国家:中国 姓名:小红 国家:美国 姓名:小明 国家:美国
07.22 static关键字的特点
1.static是一个修饰符，用于修饰成员(成员变量和成员函数)
2.static修饰的成员被所有的对象共享
3.static优先于对象存在，因为static成员随着类的加载就已经存在了
4.static修饰的成员可以被对象调用，也可以直接被类名调用，格式为：类名.静态成员
5.static修饰的数据是共享数据，对象中存储的是特有数据
07.23 static的内存图解
07.24 static的注意事项
1.在静态方法中是没有this关键字的
2.静态方法只能访问静态的成员变量和静态的成员方法
3.主函数是静态的，如果要在主函数中调用非静态成员可以创建一个对象来调用
07.25 静态变量和成员变量的区别
1.所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
2.内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
3.内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
4.调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
07.26 main方法的格式详细解释
