黑马程序员技术交流社区

标题: 【长沙校区】助你成功！【Java基础笔记】面相对象上篇 [打印本页]
作者: 袁文博老师    时间: 2016-1-21 17:10
标题: 【长沙校区】助你成功！【Java基础笔记】面相对象上篇
本帖最后由 袁文博老师 于 2016-1-21 17:10 编辑

同样的课程、老师、就业，更好的学习环境，更低的学习成本!
内地学员，选择长沙校区，靠谱！！！
报名热线：0731-85833115
QQ:51106849
【长沙校区】助你成功！【Java基础笔记】
——面相对象 上篇
概述：
1.      面向对象是相对于面相过程而言的另一种编程思想；
2.      面向过程是以函数为基础，完成各种操作，强调的是过程；
3.      面向对象是以对象为基础，通过对象调用对象中的函数，完成各种操作，强调的是功能；
4.      面向对象基于面向过程；
举例：
         学习android 开发；
面相过程：
步骤：
1.      自己看书；
2.      自己自学；
3.      遇到问题自己解决问题；
以上步骤的黑色加粗字体都是一种行为，用代码表现就是一个一个的函数。面相过程是分析解决问题的步骤，然后一步一步用函数去实现步骤，主体是功能行为；
面相对象：
         步骤：
1.      找一个老师；
2.      老师讲书上内容；
3.      老师给你讲课；
4.      遇到问题老师帮你解决问题；
以上步骤的黑色加粗字体依旧是行为，而红色加粗字体老师就是一个对象，老师具备讲书，讲课，解决问题的函数，我们就可以直接通过老师这个对象来为自己服务。面相对象是把需要做的事务分解成一个一个的对象，而后要完成某个事务时，创建那个对应的对象来解决整个事务，比如创建老师对象来教自己学android开发。
面相对象的特点和特征：
特点：
1.      一种符合人思维习惯的思维；
2.      将复杂事情变得简单化；
3.      从执行者转换成了指挥者；
举例：
         生活中的琐事，叫外卖、打的、买菜、打电话、看电视等等，这些都是我们通过生活中的具有某个特定功能的对象来帮我们实现的，比如，买菜，我们直接找到超市就可以买菜，而超市就相当于是代码里面的对象，这个对象可以帮我们提供各种菜；
特征： 封装、继承、多态（后面一一讲解）
类与对象
类与对象的关系：
1.      使用计算机语言就是不断地在描述现实生活中的事物。
2.      java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
3.      对象即是该类事物实实在在存在的个体。
举例：
         类：老师、学生、汽车、电话等，生活中的抽象描述；然而每个类，都有它独特的属性或者说特征，比如老师类的姓名、年龄、所属国家、所属学校等等的特征，而这些特征就是定义为这个类的属性。而这个老师类的行为，比如老师讲书、老师讲课、老师解决问题等等的行为，就是定义为类中的方法；
         对象：某一个类中，具体的对象，例如：老师类中某个具体的老师，而在代码中，我们要某个老师来为自己服务，那就创建这个老师类的对象，通过对象调用类中的方法，来为自己使用；
代码举例：
  1. class Teacher{
  2.         String name;    //姓名
  3.         int age;                        //年龄
  4.         String country;  //国家
  5.         String school;   //学校
  6.         
  7.         //老师讲书的方法（函数）
  8.         public void teachBook(){
  9.                 System.out.println("老师讲书本上的知识！");
  10.         }
  11.         //老师讲课方法
  12.         public void teach(){
  13.                 System.out.println("老师正在讲课！");
  14.         }
  15.         //老师解决问题的方法
  16.         public void solveProblem(){
  17.                 System.out.println("老师帮我解决问题！");
  18.         }
  19. }   
  20. public class Object_Demo {
  21.         public static void main(String[] args) {
  22.                  Teacher teacher = new Teacher();                //创建一个老师对象
  23.                  teacher.name="冯佳";                                    //为老师姓名属性赋值
  24.                  teacher.age = 23;                                                
  25.                  teacher.country="中国";
  26.                  teacher.school="传智播客.黑马程序员";
  27.                  teacher.teacherInformation();        //调用老师类中的方法，查看老师信息
  28.                  teacher.teachBook();                     //调用老师讲书的方法
  29.                  teacher.teach();                              //调用老师讲课的方法
  30.                  teacher.solveProblem();                //调用老师解决问题的方法
  31.         }
  32. }
复制代码
输出结果：

成员变量与局部变量
成员变量：又可以叫成员属性或者全局变量
1．  定义在类中方法外，在类的任意地方都可以使用；
2．  成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中；
3．  有默认初始化值；
基本数据类型：
byte、short、int、long 默认初始化值为 0 ；
char默认初始化值为‘ ’ ;(单个空字符)
float、double默认初始化值为 0.0 ;
boolean默认初始化值为 false;
             引用数据类型：默认初始化值为 null ;
局部变量：
1．  局部变量只定义在局部范围内，如：方法内，语句内，代码块内等，只在所属的大括号区域内有效；
2．  局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放；
3．  局部变量没有默认初始化值，在使用前，必须赋值；
代码举例：
  1. public class Object_Demo {
  2.         int a ;    //成员变量 默认初始化值为0
  3.         public static void main(String[] args) {
  4.                 Object_Demo od=new Object_Demo(); //创建Object_Demo类的对象
  5.                 od.show();           //调用od对象的show()方法
  6.         }
  7.         
  8.         //定义一个show方法，打印成员变量a
  9.         public void show(){
  10.                 System.out.println(a);
  11.         }  
  12. }
复制代码
输出结果：

错误举例：

内存图示意：

构造函数
概述：
1.      构造函数名与本类类名相同；
2.      没有返回值类型；
3.      为对象初始化；
构造函数与成员方法区别：
         构造函数：
1.      在类被创建时调用，并且只调用一次，为对象初始化；
2.      多个构造函数以重载的方式存在（参数列表不同），在创建对象时，类名后面括号中传入什么参数，相对应调用的就是哪个重载的构造函数；
3.      一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数，如果在类中定义了指定的有参构造函数，那么类中的默认无参构造函数就没有了。
4.      无返回值类型；
成员方法：
1.      普通非私有成员方法通过对象调用，可通过对象多次调用；
2.      静态成员方法通过对象或者类名直接调用；
3.      有返回值类型，void为空返回值；
代码举例：
  1. class Teacher{
  2.         private String name;    //姓名
  3.         private int age;                //年龄
  4.         private static String country; //国家
  5.         private static String school;  //学校

  7.         public Teacher(){        //无参构造函数，在没有其它有参构造函数时，编译器会自动帮你创建一个
  8.         }   
  9.         
  10.         public Teacher(String name,int age){                                   //有参构造函数，为类的成员属性初始化值
  11.                 //通过this()可以调用本类中其它构造函数，一定要在第一行(注释除外),否则报错，因为初始化动作要先执行
  12.                 this(name, age,"中国","传智播客.黑马程序员");     
  13.                 this.name=name;
  14.                 this.age=age;
  15.         }
  16.         
  17.         public Teacher(String name,int age,String country,String school){ //有参构造函数，为类的成员属性初始化值
  18.                 this.name=name;
  19.                 this.age=age;
  20.                 this.country=country;
  21.                 this.school =school;
  22.         }
  23.          //重写toString()方法，把成员属性输出
  24.         @Override
  25.         public String toString() {                        
  26.                 return "Teacher [name=" + name + ", age=" + age + ", country="
  27.                                 + country + ", school=" + school + "]";
  28.         }
  29. }   
复制代码
  1. public class Object_Demo {  
  2.         public static void main(String[] args) {
  3.                 Teacher t1 =new Teacher(); //创建对象，调用无参构造函数
  4.                 System.out.println(t1.toString());  //调用重写toString()方法
  5.                 //创建t2对象，并通过有参构造函数为对象属性赋值，t1对象没有为对象赋值
  6.                 Teacher t2 =new Teacher("冯佳",23,"中国","传智播客.黑马程序员");
  7.                 System.out.println(t2.toString()); //调用toString()方法
  8.                
  9.         }
  10. }
复制代码
输出结果：


封装
概述：
是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式（换句话说就是将属性私有化，并提供共有的方法访问）；如：getName();setName();提供操作和获取name属性的方法；
Private封装：
1.      可用于修饰成员内容，包括成员变量和成员方法；
2.      被他修饰完毕后的内容，在其他类中是不能直接访问的，换句话说就是被private修饰的内容只能在本类中使用；
代码举例：

  2. class Teacher{
  3.         private String name;    //姓名
  4.         private int age;                //年龄
  5.         private static String country; //国家
  6.         private static String school;  //学校
  7.       
复制代码
  1. public class Object_Demo {  
  2.         public static void main(String[] args) {
  3.                 Teacher t =new Teacher(); //创建对象，调用无参构造函数
  4.                 //当Teacher属性被private修饰后，其它类中通过对象无法直接使用，否则报错
  5.                 //t.name="冯佳";
  6.                 //Teacher类提供了setName(String name)方法，操作name属性
  7.                 t.setName("冯佳");
  8.                 //再通过getName()方法获取name属性的值，用String类型接收
  9.                 String name =t.getName();
  10.                 //在控制台打印输出通过getName()返回的name变量
  11.                 System.out.println("name="+name);
  12.         }
  13. }
复制代码
输出结果：

this关键字
概述：
1.      this代表其所在函数所属对象的引用。换言之，this代本类对象的引用；
2.      当成员变量和局部变量重名，可以用关键字this来区分，this就是所在函数所属对象的引用；
3.      简单说，哪个对象调用了this所在的函数，this就代表哪个对象。一般方法调用默认加this；
代码举例：
  1. //设置name属性值的方法
  2.         public void setName(String name) {
  3.                 //此行代码，等号左边的name不加this，编译器会就近原则取离它最近那个变量，也就是调用者调用该方法时
  4.                 //传入的name变量自己给自己赋值,然并卵
  5. name = name;
复制代码
  1. <blockquote><span style="font-family: 宋体; line-height: 21px; background-color: rgb(255, 255, 255);">//设置age属性值的方法</span>
复制代码
this调用构造函数：
通过this在构造函数中调用其他构造函数的时候，只能定义在构造函数的第一行，因为初始化动作要先执行，否则就会报错。

Static关键字
概述：
1.      static可以修饰成员属性和成员方法；
2.      被static修饰的成员属性和成员方法，被该类的所有对象共享；
3.      被static修饰的成员属性和成员方法，随着类的加载而加载，所有优先于对象存在，因为对象需要在被创建时，才在对内存中存在；
4.      可以通过类名或对象调用，推荐直接通过类名调用；
5.      在静态方法中是没有this和super关键字,因为静态是随着类的加载而加载。而this是对象创建才存在；
6.      静态方法只能访问静态成员变量和静态成员方法，静态只能访问静态；
成员方法和静态方法：
静态变量：
1.      当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰；
2.      只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的；
3.      如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的；
静态函数：
1.      函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据；
2.      简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的；
3.      如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用；
4.      如果没有访问特有数据的方法，该对象的创建是没有意义；
用途：
         多个对象共享某一数据的时候，我们就把这个数据用static修饰；

代码举例：




    以上每个知识点，都是面向对象中同学们必须掌握的重点，很多同学在初次接触面向对象后完全蒙圈，可以理解！其它大部分同学也基本上都是这么蒙过来的，但你们能放弃吗？很明显不能，不能咋办？凉拌，白天在教室认真听课，不管能不能听懂，咱先听着，让老师说的东西先在脑子里过一遍，课间做练习的时候，摸索着来，不要以为看懂了就不动手！不动手的最后都会发现，不看老师代码，一个字不会写！这绝不是恐吓你！到了晚上，去食堂搞一碟凉菜，一边看老师或论坛各个老师的笔记，一把白天老师讲的东西从脑子里翻出来，翻出来一个知识点，就往嘴巴里噻一片凉菜，以资鼓励！这！就是凉拌！      未完待续...


作者: lingyins    时间: 2016-1-21 19:38
博哥的笔记收下了，超级干货啊。
大家都保存下来啊。
作者: 邓娇林    时间: 2016-1-28 16:45
发给童鞋们看啊
作者: aymore    时间: 2016-1-28 17:01
我居然还有地板哦
作者: 陈新新    时间: 2016-1-28 17:13
哎哟哎哟 还有报纸坐吗
作者: 阳丹老师    时间: 2016-1-28 17:15
溜溜溜
作者: xiaoxiao2015    时间: 2016-1-28 17:23
作者: 569015640    时间: 2016-1-28 17:55
博哥今天问我食堂包子多少钱一个
作者: 张美老师    时间: 2016-1-28 18:19
怒赞
作者: 洋葱头头    时间: 2016-1-28 18:43
wokao收藏一个
作者: hahwaa1    时间: 2016-3-18 22:34
支持博哥.....顶起
作者: 黄盖打周瑜    时间: 2016-3-18 22:40
博哥!给力给力!!
作者: unexpectedman    时间: 2016-3-18 22:57
太好了 今天刚学了面向对象
作者: jeremylee    时间: 2016-3-18 23:32
看晕了啊 老师...这节课就是模模糊糊的概念
作者: dedeheima    时间: 2016-3-18 23:57
博哥用心良苦啊.赞一个
作者: 胡智鹏    时间: 2016-3-19 00:03
正在学面向对象
作者: Man_hui    时间: 2016-3-19 00:12
先马克一下，慢慢学习！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2