黑马程序员 Java面向对象(封装,构造函数,this关键字,静态static)

------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------

面向对象(概述)

              面向对象是相对面向过程而言,它们都是一种思想.

              面向过程强调的是功能行为.

              面向对象是将功能封装成对象,强调具备了功能的对象.

 

面向对象(举例)

              想去电脑城买个电脑.

              面向过程:自己去查阅电脑的参数配置以及价格,然后去电脑城讨价还价购买,因为不太懂可能还会被坑.

              面向对象:找一个懂电脑的人帮你去买,他就是一个对象,具备买电脑的功能,你使用他就行.

       

              软件公司接了一个单子.

              面向过程:老板自己也会写代码,自己去写耗费的时间精力会很大,完成的也不见得好.

              面向对象:老板去找一些具备写代码这个功能的对象,也就是招几个程序员来写.

 

面向对象(类与对象的关系)

              类就是对现实生活中事务的描述.

              对象就是这类事务,是实实在在存在的个体.

             

              映射到java中,描述就是class定义的类.

              具体对象就是在堆内存中用new建立的实体.

 

              描述事务其实就是在描述事务的属性和行为.

              属性对应是类中变量,行为对应类中的函数(方法).

 

面向对象(成员变量和局部变量)

              成员变量作用于整个类中,在堆内存中,因为他随着对象的存在而存在.

              局部变量作用于函数中,或者语句中,在栈内存中.

              成员变量都有默认初始化值,不赋值也可以参与运算;

              局部变量没有默认初始化值,不赋值不能参与运算.

  

面向对象(封装概述)

              封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式.

              好处:1,将变化隔离; 2,便于使用; 3,提高复用性; 4,提高安全性.

              封装原则:1,将不需要对外提供的内容都隐藏起来;

                             2,把属性都隐藏,提供公共方法对其访问.

 

面向对象(封装private)

              private:私有,权限修饰符;用于修饰类中的成员(成员变量,成员函数).

              注意:私有仅仅是封装的一种表现形式.

              将age私有化以后,类以外即使建立了对象也不能直接访问.

              就需要在Person类中提供访问age的方式.

              之所以对外提供访问方式,就是因为可以再访问方式中加入逻辑判断等语句.

              classPerson
              {
                     privateint age;//封装原则:把属性都隐藏,提供公共方法对其访问
                     publicvoid setAge(int a)
                     {
                            if(a>0 && a<130)
                            {
                                   age= a;
                                   speak();
                            }
                            else
                                   System.out,println("feifaage");
                     }
                     publicint getAge() //一个成员属性通常对应两个访问方法:set和get.
                     {
                            returnage;
                     }
                     voidspeak()
                     {
                            System.out.println("age="+age)
                     }
              }
              classPersonDemo
              {
                     publicstatic void main(String[] args)
                     {
                            Personp = new Person();
                            p.setAge(-20);
                     }
              }

面向对象(构造函数)

              1,函数名与类名相同;   2,不用定义返回值类型; 3,不可以写return语句.

              构造函数额作用是给对象进行初始化,不写的话系统会默认加一个空参数的构造函数.

              多个构造函数以重载的方式存在.

 

              构造函数和一般函数的区别:

              构造函数是在对象一建立就运行,给对象初始化.

              一般函数是被对象调用才执行,是给对象添加对象具备的功能.

              一个对象建立,构造函数只运行一次.

              一般函数可以被对象调用多次.

             

              当分析事物时,该事物一存在就具备一些属性或者行为,那么就把这些内容定义在构造函数中.

 

面向对象(构造代码块)

              构造代码块在开发中见不到,但是面试时很多笔试题中有.

              {

                     System.out.println("run");

              }

              没有名字,单独一个代码区块.

              对象一建立就运行,而且优先于构造函数执行.

              构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化.

 

面向对象(this关键字)

              this:用于区分局部变量和成员变量同名的情况.

              哪个对象在调用this所在的函数,this就代表哪个对象.

 

              当定义类中的功能时,该函数(功能)内部需要用到调用该函数的对象时,这时用this来表示这个对象.

              也就是但凡本类功能内部使用了本类对象,都用this表示.

              classPerson
              {
                     privateString name;
                     privateint age;
                     Person(intage)
                     {
                            this.age= age;
                     }
                     Person(Stringname)
                     {
                            this.name= name;
                     }
                     Person(Stringname,int age)
                     {
                            this.name= name;
                            this.age= age;
                     }
              }

 

面向对象(this关键字在构造函数间调用)

              this语句:用于构造函数之间进行互相调用.

              this语句只能定义在构造函数的第一行,因为初始化时要先执行.

              classPerson
              {
                     privateString name;
                     privateint age;
                     Person(intage)
                     {
                            this.age= age;
                     }
                     Person(Stringname)
                     {
                            this.name= name;
                     }
                     Person(Stringname,int age)
                     {
                            //this.name= name;
                            this(name);//this语句只能用于构造函数间.
                            this.age= age;
                     }
              }

面向对象(Static关键字)

              static关键字：用于修饰成员（成员变量和成员函数）

              被修饰后的成员具备以下特点：

                     随着类的加载而加载

                     优先于对象存在

                     被所有对象所共享

                     可以直接被类名调用

 

              实例变量(成员变量)和类变量(静态成员变量)的区别：

              1，存放位置。

                     类变量随着类的加载而存在于方法区中。

                     实例变量随着对象的建立而存在于堆内存中。

              2，生命周期：

                     类变量生命周期最长，随着类的消失而消失。

                     实例变量生命周期随着对象的消失而消失

 

              使用注意

                     静态方法只能访问静态成员

                     静态方法中不可以写this，super关键字

                     主函数是静态的

 

             

              静态有利有弊

                     利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。

                              可以直接被类名调用。

                     弊端：生命周期过长。

                              访问出现局限性。(静态虽好，只能访问静态。)

 

面向对象(main函数)

              publicstatic void main(String[] args)

              主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。

 

              主函数的定义：

                     public：代表着该函数访问权限是最大的。

                     static：代表主函数随着类的加载就已经存在了。

                     void：主函数没有具体的返回值。

                     main：不是关键字，但是是一个特殊的单词，可以被jvm识别。

                     (String[]arr):函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

 

              主函数是固定格式的：jvm识别。

              jvm在调用主函数时，传入的是new String[0];

 

面向对象(静态什么时候使用)

                     因为静态修饰的内容有成员变量和函数。

 

                     什么时候定义静态变量(类变量)呢？

                            当对象中出现共享数据时，该数据被静态所修饰。

                            对象中的特有数据要定义成非静态存在于堆内存中。

                     什么时候定义静态函数呢？

                            当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。

 

面向对象(静态的应用-工具类以及帮助文档的制作)

              每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。

              虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。

              但是发现了问题：

                     1，对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。

                     2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。

                     这时就考虑，让程序更严谨，是不需要对象的。

                     可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。

                     将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。

                     为了更为严谨，强制让该类不能建立对象，可以通过将构造函数私有化完成。

 

              接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。

              但是，很遗憾，该类中到底定义了多少个方法，对方去不清楚。因为该类并没有使用说明书。

              开始制作程序的说明书。java的说明书通过文档注释来完成。

/**
这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能。
@author 张三
@version V1.1
*/
 
//javadoc -d myhelp -author -versionArrayTool.java
 
public class ArrayTool
{
       /**
       空参数构造函数。
       */
       privateArrayTool(){}
 
       /**
       获取一个整形数组中的最大值。
       @paramarr 接收一个int类型的数组。
       @return会返回一个该数组中最大值。
       */
       publicstatic int getMax(int[] arr)
       {
              intmax = 0;
              for(intx=1; xarr[max])
                            max= x;
              }
              returnarr[max];
       }
      
       /**
       获取一个整形数组中的最小值。
       @paramarr 接收一个int类型的数组。
       @return会返回一个该数组中最小值。
       */
       publicstatic int getMin(int[] arr)
       {
              intmin = 0;
              for(intx=1; xarr[y])
                            {
                                   swap(arr,x,y);
                            }
                     }
              }
       }
       /**
       给int数组进行冒泡排序。
       @paramarr 接收一个int类型的数组。
       */
       publicstatic void bubbleSort(int[] arr)
       {
              for(int x=0; xarr[y+1])
                            {
                                   swap(arr,y,y+1);
                            }
                     }
              }
       }
       /**
       给数组中元素进行位置的置换。
       @paramarr  接收一个int类型的数组。
       @parama 要置换的位置
       @paramb 要置换的位置
       */
       private  static void swap(int[] arr,int a,int b)
       {
              inttemp = arr[a];
              arr[a]= arr[b];
              arr[b]= temp;
       }
       /**
       用于打印数组中的元素。打印形式是：[elemet1, element2,...]
       */
       publicstatic void printArray(int[] arr)
       {
              System.out.print("[");
              for(intx=0; x

面向对象(静态代码块)

              格式：

                     static

                     {

                            静态代码块中的执行语句。

                     }

             

              特点：随着类的加载而执行，只执行一次,并优先于主函数，用于给类进行初始化的。

 

 

面向对象(对象的初始化过程)

              Personp = new Person("zhangsan",20);

              该句话都做了什么事情？

                     1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。

                     2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。

                     3，在堆内存中开辟空间，分配内存地址。

                     4，在堆内存中建立对象的特有属性。并进行默认初始化。

                     5，对属性进行显示初始化。

                     6，对对象进行构造代码块初始化。

                     7，对对象进行对应的构造函数初始化。

                     8，将内存地址付给栈内存中的p变量。

 

面向对象(单例设计模式)

              设计模式：解决某一类问题最行之有效的方法。

              java中有23种设计模式.

              单例设计模式：解决一个类在内存只存在一个对象。

              想要保证对象唯一。

                     1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

                     2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

                     3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

              这三部怎么用代码体现呢？

                     1，将构造函数私有化。

                     2，在类中创建一个本类对象。

                     3，提供一个方法可以获取到该对象。

//这个是先初始化对象，称为饿汉式。
//Single类一进内存，就已经创建好了对象。
//原则：定义单例，建议使用饿汉式。
class Single
{
       privatestatic Single s = new Single();
       privateSingle(){}
       publicstatic Single getInstance()
       {
              returns;
       }
}
 
//对象是方法被调用时，才初始化，也叫做对象的延时加载，称为懒汉式。
//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
//有安全隐患，多线程的情况下需要加同步
class Single
{
       privatestatic Single s = null;
       privateSingle(){}
       publicstatic Single getInstance()
       {
              if(s==null)
              {
                     synchronized(Single.class)
                     {                         
                            if(s==null)
                                   s= new Single();
                     }
              }
              returns;
       }
}

------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------