JAVA基础-面向对象之封装

JAVA学习笔记 专栏收录该内容
11 篇文章 0 订阅


1、面向对象概念

1.1、理解面向对象

(1)面向对象是相对面向过程而言的。

(2)面向对象和面向过程都是一种思想。面向对象是将功能封装进对象,强调具备了功能的对象。面向过程强调的是功能行为。

(3)面向对象是基于面向过程的。

1.2、面向对象的特点

面向对象有三个特征:封闭、继承、多态。

2、类与对象的关系

(1)类就是对现实生活中事物的描述。

(2)对象就是这类事物实实在在存在的个体。

(3)在Java中,描述就是用class关键字定义的类,具体对象就是对应Java在堆内存中用new关键字建立的实体,描述事物其实就是在描述的属性和行为,属性对应类中的变量,行为对应类中的方法,定义类就是在定义事物的属性和行为,属性和行为共同成为类中的成员。

示例:

Class  Car

{

    String  color;  //描述颜色

    void  run(){}   //描述行为

}

说明:定义了一个Car类,类中定义了color属性(成员变量)和run行为(成员方法)。

有了类,可用new关键字产生该类的一个实体:

Car  c=new  Car();

说明:c是一个Car一个实体对象,是一个类类型变量,而类类型变量指向对象。

产生对象后,可以使用对象访问对象的成员,访问格式为:对象名.对象成员,如c.color访问Car的color属性。

3、成员变量与局部变量

(1)成员变量作用于整个类中,且在内存中成员变量因为对象的存在才存在于堆内存中。

(2)局部变量作用于函数中或者语句中,存在栈内存中。

4、匿名对象

匿名对象是对象的简化形式。

匿名对象的使用方式:

(1)当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化,如果对一个对象进行多个成员调用,必须给这个对象起个名字。

(2)匿名对象可以将对象作为实际参数进行传递。

5、封装

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

5.1、封装的好处

(1)将变化隔离

(2)便于使用

(3)提高重用性

(4)提高安全性

5.2、封装原则

(1)将不需要对外提供的内容都隐藏起来。

(2)把属性都隐藏起来,提供公共方法对其访问。

5.3、private

private表示私有。一种权限修饰符,用于修饰类中的成员(成员变量、成员函数),私有只在本类中有效。被private修饰的成员不可以被对象直接访问,如果私有成员需要在本类以外被访问,就需要在本类中提供访问该成员的方法。

示例:

class  Person

{

         private  int  age;

         public  void  setAge(int  a) //定义set方法对私有成员age进行修改

         {

                   Age=a;

         }

}

说明:声明了一个Person类,类中age属性被私有,并提供setAge方法对属性age进行操作,当通过Person  p=new Person()声明一个对象p时,不能用p.age直接访问,只能通过p对象调用setAge方法访问age。

注意:封装不代表私有,私有仅仅是封装的一种表现形式。

5.4、构造函数

    特点:函数名与类名相同,不用定义返回值类型,不可以写return语句。

    作用:给对象进行初始化,因为对象一建立就会调用与之对应的构造函数。

注意:多个构造函数是以重载的形式存在的。当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数,这个默认的构造函数的权限与所属类一致辞。当在类中自定义了构造函数后,默认的构造函数就没有了。

格式:类名(参数列表){}

示例:

class  Person

{

         private  String  name;

         Person(String  n) //定义构造函数

         {

                   name=n;

         }

}

说明:声明了一个Person类,类中定义了一个成员变量name和一个构造函数Person(String  n),此时若要建立一个Person类的实例对象,只能Person  p=new Person(“n”),而不能Person  p=new  Person(),因为此时已没有默认的不带参数列表的构造函数。

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

(1)在写法上,构造函数与一般函数有不同。

(2)在运行上,构造函数在对象一建立时就运行,给对象初始化。而一般函数是需要对象调用才执行,是给对象添加对象具备的功能。

(3)一个对象建立,构造函数中运行一次,而一般方法可以被对象调用多次。

什么时候定义构造函数:

当分析事物时,该事物一存在就具备一些特性或行为,那么就可以将这些内容定义在构造函数中。

5.5、构造代码块

    作用:给对象进行初始化。对象一建立就运行,而且优先于构造函数执行。

和构造函数的区别:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化。构造代码块中定义的是不同对象共性的初始化内容。

格式:{ 对象初始化语句 }。

示例:

class  Person

{

         private  String  name;

//定义构造代码块

         {

                   System.out.println(“Peson  code  run”);

         }

         Person(String  n)

         {

                   name=n;

         }

}

说明:在Person中定义了一个构造代码块,当用new建立一个对象时,程序首先会调用该构造代码块,即会打印Person code  run。

5.6、this关键字

作用:当类中局部变量和成员同名时this用于区分局部变量和成员变量。this就代表本类的对象,代表它所在函数所属对象的引用,即哪个对象在调用this所在的函数,this就代表哪个对象。

格式:this.成员

示例:

class  Person

{

         private  String  name;

         Person(String  name)

         {

                   This.name=name;

         }

}

说明:在类Person中定义了私有成员变量name,定义了构造函数Person(String  name),Person函数中有局部变量与成员变量name同名,此时为了区别构造函数中的局部变量和类中成员变量,在调用成员变量name时用this.name调用。

应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。但凡本类功能内部使用到了本类对象,都用this表示。

示例:

class  Person

{

         private  String  name;

         private  int  age;

         Person(String  name,int  age)

         {

                   this.name=name;

                   this.age=age;

         }

         public  boolean  compareAge(Person  p)

         {

                   retrun  this.age==p.age;

         }

}

说明:定义了一个类Person,类有定义了一个比较年龄的功能函数compareAge,当建立两个对象p1和p2,当用p1调用compareAge方法p1.compareAge(p2)时,this.age就代表p1对象的age,this就代表了p1。

this语句:只用于构造函数之间进行互相调用,因为一般函数不能直接调用构造函数。this语句只能是在构造函数中的第一个语句。因为初始化要先执行。

格式:this(函数元素,…)

示例:

class  Person

{

         private  String  name;

         private  int  age;

         Person(String  name)

         {

                   this.name=name;

         }

         Person(String  name,int  age)

         {

                   this(name);//this语句相当于调用构造函数Person(name);

                   this.age=age;

         }

}

说明:定义了一个类Person,类中定义了两个构造函数Person(String  name)和Person(String  name,int  age),当在Person(String  name,int  age)要调用Person(String  name)时,用this语句。

5.7、static关键字

static关键字也是一种修饰符,用于修饰成员(成员变量和成员函数)。

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

-随着类的加载而加载。

-优先于对象存在。

-被所有对象所共享。

-可以直接被类名调用。

注意:

-静态方法只能访问静态成员。非静态即可以访问静态也可以访问非静态。

-静态方法中不可以写this,super关键字,因为静态优先于对象存在。

-主函数是静态的。

示例:

class  Person

{

         private  String  name;

         static  String  country=”CN”; //定义静态成员

         Person(String  name)

         {

                   this.name=name;

         }

}

说明:定义了一个类Person,类中定义了一个静态变量country,此时静态变量country会随着类的加载而加载,属于所有Person类对象的共享数据,且可以被类名直接调用,格式为:Person.country。

静态成员在内存中存储在方法区中,静态成员变量也被称为类变量,类变量与成员变量的区别:

(1)存放位置:类变量随着类的加载而存在于方法区中,成员变量随着对象的建立而存在于堆内存中。

(2)生命周期:类变量生命周期最长,随着类的消失而消失,成员变量生命周期随着对象的消失而消失。

静态的利弊:

    利:对对象的共享数据进行单独空间的存储,节省空间,没有必要在每一个对象中都存储一份。可以直接被类名调用。

弊:生命周期过长。访问出现局限性(只能访问静态)。

什么时候定义静态变量:当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

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

静态的应用:每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,形成一个工具类,当其他应用程序需要用其中的功能时,找到这个工具类就可以了,方便复用。

示例:

classArrayTool  //定义一个操作数组的工具类

{

         //定义获取数组中最大值的方法

         public static int getMax(int[]arr) 

         {

                   int max=0;

                   for(int i=1;i<arr.length-1;i++)

                   {

                            if(arr[i]>arr[max])

                                     max=i;

                   }

                   return arr[max];

         }

          //定义获取数组中最小值的方法

         public static int getMin(int[] arr)

         {

                   int min=0;

                   for(inti=1;i<arr.length-1;i++)

                   {

                            if(arr[i]<arr[min])

                                     min=i;

                   }

                   return arr[min];

         }

          //定义将数据进行选择排序的方法

         public static void selectSort(int[]arr)

         {

                   for(inti=0;i<arr.length-1;i++)

                   {

                            for(intj=i+1;j<arr.length;j++)

                            {

                                     if(arr[i]>arr[j])

                                     {

                                               inttemp=arr[i];

                                               arr[i]=arr[j];

                                               arr[j]=temp;

                                     }

                            }

                   }

         }

          //定义将数组进行冒泡排序的方法

         public static void bubbleSort(int[]arr)

         {

                   for(inti=0;i<arr.length-1;i++)

                   {

                            for(intj=0;j<arr.length-i-1;j++)

                            {

                                     if(arr[j]>arr[j+1])

                                     {

                                               inttemp=arr[j];

                                               arr[j]=arr[j+1];

                                               arr[j+1]=temp;

                                     }

                            }

                   }

         }

          //定义打印数组中元素的方法

         public static void arrayPrint(int[]arr)

         {

                   System.out.print("[");

                   for(inti=0;i<arr.length;i++)

                   {

                            if(i!=arr.length-1)

                                     System.out.print(arr[i]+",");

                            else

                                     System.out.print(arr[i]+"]");

                           

                   }

         }

        

}

 

public classArrayDemo5

{

         public static void main(String[] args)

         {

                  

         }

}


说明:定义了一个操作数组的工具类,类中定义了对一个数组取最值、排序和打印的方法,这些方法都定义成静态的,当在其他程序中需要用到该类中的方法去操作数组时,可以直接通过这个工具类的类名去调用相应的方法,而不需要在程序中定义相应的方法,增强了代码的复用性。同时,因为该类是工具类,不需要被实例化,所以可以在该类中将其构造函数私有化,强制该类不能建立对象。

5.8、main函数

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

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

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

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

main:不是关键字,但是是一个特殊的单词,可以被JVM识别。

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

主函数是固定格式的:JVM识别。格式:public  static  void  main(String[] args){}。

JVM在调用主函数时,默认传入的是new String[0]。

5.9、静态代码块

作用:随着类的加载而执行,只执行一次。用于给类进行初始化。

格式:static{静态代码块中的执行语句}。

5.10、对象初始化过程:

    (1)当用new建立一个对象时,因为new用到了相应类的class文件,所以会先找到相应的class文件并加载到内存中。

    (2)执行该类中的static代码块,如果有的话,对该进行初始华。

    (3)在堆内存中开辟空间,分配内存地址。

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

    (5)对属性进行显式初始化。

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

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

  (8)将内存地址赋给栈内存中的对象变量。

5.11、单例设计模式

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

如何保证类的对象唯一:

(1)为了避免其他程序过多建立该对象,先禁止其他程序建立该对象。(将构造函数私有化)。

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

(3)为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。(提供一个方法可以获取到该对象)。

单例设计模式的两种方式:

(1)饿汉式:先初始化对象,当类一进内存时就已经创建好了对象。

示例:

class  Single

{

                   private  static  Single  s=new  Single(); //创建本类对象并将其私有

                   private  Single(){}

                   public  static  Single  getInstance() //定义获取本类对象的方法

                   {

                            return  s;

                   }

}

(2)懒汉式:对象是在方法被调用时才初始化,也叫做对象的延时加载。即当类进内存时,对象还没有存在,只有调用了方法时才建立对象。

示例:

class  Single

{

                   private  static  Single  s=null; //创建本类对象引用并指向null

                   private  Single(){}

                   public  static  Single  getInstance()//定义获取本类实例的方法

                   {

                            if(s==null) //通过双重判断解决效率的问题

                            {

                                      synchronized(Single.class) //通过同步代码块解决同步的问题

                                      {

                                               if(s==null)

                                                        s=new Single();

                                      }

                            }

                            return  s;

                   }

}

说明:由于当多个程序在调用getInstance方法时可能会发生问题,所以需要进行双重判断,并加同步。

原则:定义单例,建议使用饿汉式。

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值