标签：
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方法的格式详细解释
标签：
原文地址：http://www.cnblogs.com/hoop-superman/p/5495680.html
