标签：
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
主要内容：《 思想概述、设计实现、成员变量和局部变量、类名作为形参、匿名对象、封装、private关键字、this关键字 》
面向对象是基于面向过程的编程思想
面向对象思想特点
是一种更符合我们思想习惯的思想
可以将复杂的事情简单化
将我们从执行者变成了指挥者
软件整个的开发流程：
1.分析；
2.设计；
3.编程(开发)：
需求：给传智播客北京校区做一套系统，要求能记录学员信息、教师信息、员工信息、课程、班级、正在上课的班级.....
以"面向对象"的方式：
1.面向对象分析：
1).要明确系统中要记录哪些信息：
Java基础班学员：学科、学号，姓名、性别、年龄；
IOS班学员：学科、学号、姓名、性别、年龄；
JavaEE班学员：学科、学号、姓名、性别、年龄
....
Java基础讲师：编号、学科、姓名、性别、年龄；
IOS讲师：编号、学科、姓名、性别、年龄；
JavaEE讲师：编号、学科、姓名、性别、年龄；
....
....学前咨询的员工：
2.面向对象设计：将上述信息进行"分类"，并明确每个"类"中的具体成员：
1.学员类：
学科：
学号：
姓名：
性别：
年龄：
2.讲师类：
编号：
学科：
姓名：
性别：
年龄：
3.员工类：
........
3.面向对象开发：代码实现：
1.定义类：
学员类：
讲师类：
员工类:.....
//可以将多个类定义到同一个.java文件中，但是这个文件中，只能有一个public类。而且这个public类的
//类名，必须和文件名同名。
//定义学生类
1 class Student{ 2 //属性-->成员变量：就跟我们以前定义变量一样，只不过这个变量定义在"类体中" 3 String stuNo;//学员编号 4 String name;//姓名 5 char sex;//性别； 6 int age;//年龄； 7 int score; //分数 8 //行为 9 }
1 class Demo 2 3 { 4 5 public static void main(String[] args) 6 7 { 8 9 //我要记录一个学员信息： 10 11 Student s = new Student();//在内存中产生空间 12 13 System.out.println("**********堆空间的默认值********"); 14 15 //先打印属性值 16 17 System.out.println(s.stuNo); 18 19 System.out.println(s.name); 20 21 System.out.println(s.sex); 22 23 System.out.println(s.age); 24 25 System.out.println(s.score); 26 27 System.out.println("**********************************"); 28 29 //可以对空间进行访问，并赋值 30 31 s.stuNo = "it001"; 32 33 s.name = "刘德华"; 34 35 s.sex = ‘男‘; 36 37 s.age = 20; 38 39 s.score = 88; 40 41 //访问数据成员 42 43 System.out.println("学号：" + s.stuNo); 44 45 System.out.println("姓名：" + s.name); 46 47 System.out.println("性别：" + s.sex); 48 49 System.out.println("年龄：" + s.age); 50 51 System.out.println("分数：" + s.score); 52 53 54 55 //记录第二个学员信息： 56 57 Student stu2 = new Student(); 58 59 stu2.stuNo = "it002"; 60 61 stu2.name = "张学友"; 62 63 stu2.sex = ‘男‘; 64 65 stu2.age = 22; 66 67 stu2.score = 90; 68 69 } 70 71 } 72 73
定义学生类： 类名：Student 属性：姓名：性别：年龄： 行为：自我介绍:学习: class Student{ //属性-->成员变量 String name;//OK的。当实例化(new)时，在堆空间中会自动初始化； // String name = null;//OK的。显示初始为：null; char sex; // char sex = ‘男‘;//OK的 int age; //行为-->成员方法：跟我们以前学习的"方法"是一样的。可以有返回值，可以形参。 //这里我们定义"成员方法"时，先暂时不需要：public static //成员方法，可以访问"成员变量" void show(){ System.out.println("大家好，我叫：" + name + "，性别：" + sex + "，今年：" + age + " 岁！"); } void study(){ System.out.println("我们学习Java"); } //以下语句不能出现在类体中 System.out.println("aaaa");//不可以 for(int i = 0;i < 10 ;i++){ } }
类似还有手机类的定义；
局部变量：定义在"方法"内；可以是任何的Java类型；
区别：
1.定义的位置：
1)员变量：定义在"类体"中；
2).局部变量：定义在某个"方法"内；
2.内存中的位置：
1).成员变量：在"堆"中；
2).局部变量(基本数据类型)：在"栈"中；
3.生命周期：
1).成员变量：实例化一个对象时，在堆中产生；如果没有任何引用来引用这块空间，后期由
"垃圾回收器"不定期检查，并清理。
2).局部变量：当所在的作用域代码块被执行，变量产生空间；当变量所在的作用域代码块执行完毕，会被立即从栈中清除掉；
4.初始化方式和初始化值：
1).成员变量：
初始化方式：由Java自动初始化；
初始化值：整数：0
浮点：0.0
符：‘\u0000‘
布尔：false
String和其他引用类型：null;
2).局部变量：
初始化方式：必须手动显示的初始化，否则不能访问此变量的值；
Java不会为其赋予默认的初始值；
1 class Student 2 3 { 4 5 //成员变量 6 7 String name; 8 9 int age = 20;//OK的。定义，并同时初始值。 10 11 // age = 20;//这种语句不能出现在类体中； 12 13 char sex; 14 15 void show(){ 16 17 //局部变量 18 19 int num = 20; 20 21 } 22 23 } 24 25 class Demo 26 27 { 28 29 public static void main(String[] args) 30 31 { 32 33 //局部变量 34 35 int num = 10; 36 37 //局部变量:for循环结束后，i变量消失 38 39 for(int i = 0;i < 10 ;i++){ 40 41 } 42 43 //局部变量：b:在if体被执行时，变量b被创建。只要if语句完毕，b变量就立即消失； 44 45 if(1 == 1){ 46 47 int b = 10; 48 49 50 51 } 52 53 int a; 54 55 // a = a + 10;//错误的，编译错误 56 57 a = 10;//OK 58 59 System.out.println(a); 60 61 } 62 63 }
1 class Student{ 2 String name; 3 int age ; 4 char sex; 5 } 6 class StudentTools{ 7 void printStudent(Student stu){ 8 // stu.name = "章子怡"; 9 System.out.println(stu.name + "," + stu.age + "," + stu.sex); 10 } 11 } 12 class Demo 13 { 14 public static void main(String[] args) 15 { 16 Student stu1 = new Student();//stu1 = 0x2233 17 stu1.name = "刘德华"; 18 stu1.age = 20; 19 stu1.sex = ‘男‘; 20 // System.out.println(stu1.name + "," + stu1.age + "," + stu1.sex); 21 // printStudent(stu1);//把stu1的引用传给了方法:printStudent(0x2233) 22 StudentTools st = new StudentTools(); 23 st.printStudent(stu1); 24 Student stu2 = new Student();//stu2 = 0x4455 25 stu2.name = "张学友"; 26 stu2.age = 22; 27 stu2.sex = ‘男‘; 28 // System.out.println(stu2.name + "," + stu2.age + "," + stu2.sex); 29 // printStudent(stu2);//printStudent(0x4455) 30 st.printStudent(stu2); 31 } 32 //定义方法，打印一个Student对象的信息 33 public static void printStudent(Student stu){//形参：表示接受一个"Student对象的引用(地址)" 34 stu.name = "章子怡"; 35 System.out.println(stu.name + "," + stu.age + "," + stu.sex); 36 } 37 }
匿名对象：
1.没有名字的对象；
new Student();
2.有些时候，我们在以下情况下，可以使用匿名对象的方式：
1.对于某个类中的某个方法，只需要调用一次；
2.如果某个方法需要"某个对象的引用"(也就是形参是某个对象的引用)，如果我们调用方不需要这个形参的对象，只需要给方法传递一个引用即可，这时，可以使用传递一个匿名对象；
1 class Student{ 2 String name; 3 int age ; 4 char sex; 5 } 6 class StudentTools{ 7 void printStudent(Student stu){ 8 System.out.println(stu.name + "," + stu.age + "," + stu.sex); 9 } 10 } 11 class Demo 12 { 13 public static void main(String[] args) 14 { 15 //以前我们定义的对象都是有名字的； 16 //我们可以利用这个名字，反复的访问堆中的内容； 17 Student stu = new Student(); 18 stu.name = "章子怡"; 19 stu.age = 20; 20 stu.sex = ‘女‘; 21 //匿名对象 22 new Student(); 23 //例如：如果只需要调用一次StudentTools类的方法printStudent().这时，可以定义一个匿名的StudentTools类对象 24 new StudentTools().printStudent(stu); 25 //例如：调用printStudent()方法也可以传递一个匿名的Student对象 26 new StudentTools().printStudent(new Student()); 27 } 28 }
1.之前我们使用类时，都是直接访问"成员变量"；实际上这是一种不安全的方式；
2.封装的概念：
1).将成员变量对外隐藏(private(私有的))
2).对外可以有选择的提供set和get方法，对成员属性进行设置值和获取值的操作；
class Student{ private String name; private int age; void show(){ System.out.println("我叫：" + name); } void setName(String s){ name = s; } void setAge(int a){ if(a < 15 || a > 50){ //抛出异常 } age = a; } String getName(){ return name; } int getAge(){ return age; } } class Demo { public static void main(String[] args) { Student stu = new Student(); // stu.name = "刘德华";//当数据成员被私有化后，不能直接访问了； // stu.age = 20;//当数据成员被私有化后，不能直接访问了； stu.setName("刘德华"); stu.setAge(20); System.out.println(stu.getName() + "," + stu.getAge()); } }
private:是一个Java的访问修饰符，属于Java的关键字；作用就是控制成员的访问限制；
Java中的访问修饰符：public,protected,(默认(什么都不写)),private(从限制最少到限制最多)
private修饰符：限制成员，只能在本类的内部被其它成员访问。在其它类中，不能被访问。
1 class Student{ 2 private String name; 3 private int age; 4 private char sex; 5 //对外的get和set方法 6 void setName(String n){ 7 name = n; 8 } 9 String getName(){ 10 return name; 11 } 12 void setAge(int a){ 13 age = a; 14 } 15 int getAge(){ 16 return age; 17 } 18 void setSex(char c){ 19 sex = c; 20 } 21 char getSex(){ 22 return sex; 23 } 24 } 25 class Demo { 26 public static void main(String[] args) { 27 Student stu = new Student(); 28 // stu.setName = "刘德华";//错误，不是访问方法 29 stu.setName("刘德华"); 30 stu.setAge(20); 31 stu.setSex(‘男‘); 32 System.out.println(stu.getName() + "," + stu.getAge()+"," + stu.getSex()); 33 } 34 }
在这个方法中怎么来区分是被哪个对象调用的？
1.我们知道：方法体空间被多个对象共享。多个对象都会调用同一个方法体，
2.在方法体内，如果访问成员变量的话，会隐式的使用this关键字：
3.我们可以显示的使用this
4.this是一个隐式的变量：
在实例化这个类的对象时，会为其赋值。值为：当前对象的引用；
5.我们可以显示的使用this调用当前对象的：成员变量和成员方法；
6.有一种情况需要我们必须显示的使用this去访问成员变量：
当"局部变量"覆盖了同名的"成员变量"时。
在局部变量所在的方法内，要想访问被覆盖的成员变量，需要使用this即可访问；
1 class Student{ 2 3 String name; 4 5 void show(){ 6 7 String name = "章子怡";//局部变量，覆盖同名的"成员变量" 8 9 System.out.println("大家好：我叫：" + name);//如果直接使用name变量，就近原则 10 11 System.out.println("成员变量的name = " + this.name);//使用this访问成员变量的name属性 12 13 } 14 15 void fun(){ 16 17 show();//OK的 18 19 this.show();//OK的。效果同上面是一样的。 20 21 } 22 23 } 24 25 class Demo { 26 27 public static void main(String[] args) { 28 29 Student stu = new Student(); 30 31 stu.name = "刘德华"; 32 33 stu.show(); 34 35 } 36 37 }
java--努力且进步着：面向对象（1）《java进阶篇》--黑马程序员
标签：
原文地址：http://www.cnblogs.com/linmusen/p/4709230.html
