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

最新推荐文章于 2018-06-15 13:22:06 发布

ice1988

最新推荐文章于 2018-06-15 13:22:06 发布

阅读量443

点赞数

本文链接：https://blog.csdn.net/gbc499590301/article/details/8579970

版权

------- 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; x<arr.length; x++)
              {
                     if(arr[x]>arr[max])
                            max= x;
              }
              returnarr[max];
       }
      
       /**
       获取一个整形数组中的最小值。
       @paramarr 接收一个int类型的数组。
       @return会返回一个该数组中最小值。
       */
       publicstatic int getMin(int[] arr)
       {
              intmin = 0;
              for(intx=1; x<arr.length; x++)
              {
                     if(arr[x]<arr[min])
                            min= x;
              }
              returnarr[min];
       }
       /**
       给int数组进行选择排序。
       @paramarr 接收一个int类型的数组。
       */
       publicstatic void selectSort(int[] arr)
       {
              for(int x=0; x<arr.length-1 ; x++ )
              {
                     for(inty=x+1; y<arr.length; y++)
                     {
                            if(arr[x]>arr[y])
                            {
                                   swap(arr,x,y);
                            }
                     }
              }
       }
       /**
       给int数组进行冒泡排序。
       @paramarr 接收一个int类型的数组。
       */
       publicstatic void bubbleSort(int[] arr)
       {
              for(int x=0; x<arr.length-1 ; x++ )
              {
                     for(inty=0; y<arr.length-x-1; y++)
                     {
                            if(arr[y]>arr[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<arr.length; x++)
              {
                     if(x!=arr.length-1)
                            System.out.print(arr[x]+",");
                     else
                            System.out.println(arr[x]+"]");
              }
       }
}
 
/*
一个类中默认会有一个空参数的构造函数，
这个默认的构造函数的权限和所属类一致。
如果类被public修饰，那么默认的构造函数也带public修饰符。
如果类没有被public修饰，那么默认的构造函数，也没有public修饰。
默认构造构造函数的权限是随着的类的变化而变化的。
*/

面向对象(静态代码块)

格式：

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学习型技术博客、期待与您交流！ ---------

ice1988

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员 Java面向对象(封装,构造函数,this关键字,静态static)

------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------面向对象(概述) 面向对象是相对面向过程而言,它们都是一种思想. 面向过程强调的是功能行为. 面向对象是将功能封装成对象,强调具备了功能的对象. 面向对象(举例)
复制链接

扫一扫