Java中的面向对象的概念，类与对象，封装，构造函数，this关键字，static关键字

喜欢ヅ旅行 2023-03-13 12:24 43阅读 0赞

**目录**

面向对象的概念

类与对象的关系

封装

构造函数

this关键字

static关键字

单例设计模式

--------------------

# 面向对象的概念 #

如何理解面向对象？

>  *   面向对象是相对面向过程而言
>  *   面向对象和面向过程都是一种思想
>  *   面向过程 强调的是功能行为
>  *   面向对象 将功能封装进对象，强调具备了功能的对象
>  *   面向对象是基于面向过程的

面向对象的特点：

>  *   是一种符合人们思考习惯的思想
>  *   可以将复杂的事情简单化
>  *   将程序员从执行者转换成了指挥者
>  *   完成需求时：
> 
>                    先要去找具有所需的功能的对象来用；
> 
>                    如果该对象不存在，那么创建一个具有所需功能的对象 ；
> 
>                    这样简化开发并提高复用。

面向对象开发，设计，特征：

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。

设计的过程：其实就是在管理和维护对象之间的关系。

面向对象的特征：

*  封装(encapsulation)
 *  继承(inheritance)
 *  多态(polymorphism)

# 类与对象的关系 #

java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

对象：即是该类事物实实在在存在的个体。

类与对象的关系如图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70][]

可以理解为：  
• 类就是图纸  
• 汽车就是堆内存中的对象

类的定义：

>  *   生活中描述事物无非就是描述事物的属性和行为。如：人有身高，体重等属性，有说话，打球等行为
>  *  Java中用类class来描述事物也是如此。属性：对应类中的成员变量。行为：对应类中的成员函数
>  *   定义类其实在定义类中的成员(成员变量和成员函数)

成员变量和局部变量的区别？

>  成员变量：
> 
> （1）成员变量定义在类中，在整个类中都可以被访问。
> 
> （2）成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
> 
> （3）成员变量有默认初始化值。 
> 
> 局部变量：  
> •  局部变量只定义在局部范围内，如：函数内，语句内等。  
> •  局部变量存在于栈内存中。  
> •  作用的范围结束，变量空间会自动释放。  
> •  局部变量没有默认初始化值，必须给定初始值才能使用。

创建对象和使用对象：

class Car//对Car这类事物进行描述
    {
    String color = "red";
    int num = 4;
    void show()
    {
    System.out.println("color="+color+"num="+num);
    }
    }
    class CarDemo
    {
    public static void main(String[] args)
    {
    Car c1 = new Car();//建立对象
    c1.color="blue"; //对对象的属性进行修改
    Car c2 = new Car();
    c.show();//使用对象的功能。
    }
    }

>  创建对象的语句：
> 
> Car c = new Car();  
> 
> c就是一个类类型变量。记住：类类型变量指向对象。（如下图所示）

对象的内存结构如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 1][]

注意：每次new创建的对象在堆内存中都会相应的创建。

> 匿名对象：
> 
> 形式：new Car().run()；就是不定义类类型变量，直接用对象来访问方法。
> 
> 匿名对象是对象的简化形式；
> 
> 匿名对象两种使用情况；
> 
> •  当对对象方法仅进行一次调用时可以使用，如果对一个对象进行多个成员调用，必须给这个对象起个名字；  
> •  匿名对象可以作为实际参数进行传递。

匿名对象作为实际参数进行传递的例子：

public static void main(String[] args) {
        show(new Car());
      }
      public static void show(Car c)
      {
        c.num=3;
        c.color="black";
        c.run();
      }
    }
    class Car{
      String color="red";
      int num=4;
      void run()
      {
        System.out.println(color+","+num);
      }

![2020051318475856.png][]

# 封装 #

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

好处：  
•  将变化隔离。  
•  便于使用。  
•  提高重用性。  
•  提高安全性

封装原则：  
•  将不需要对外提供的内容都隐藏起来。  
•  把属性都隐藏，提供公共方法对其访问。

访问类型：

> private关键字：
> 
>  *   是一个权限修饰符;
>  *   用于修饰成员(成员变量和成员函数);
>  *    被私有化的成员只在本类中有效 ;
>  *    将成员变量私有化，对外提供对应的set() ，get()方法对其进行访问。提高对数据访问的安全性.
>  *   如果看到一个类中有set()和get()代表这类中肯定存在私有变量。

class Person{
      private int age;
    /*将age私有化以后，类以外即使建立了对象也不能直接访问。
    但是人应该有年龄，就需要在Person类中提供对应访问age的方式。
    */
      public void setAge(int a)
      {
        age=a;
      }
      public int getAge()
      {
        return age;
      }
      void speak()
      {
        System.out.println("age="+age);
      }
    }

# 构造函数 #

构造函数特点：

> 特点：
> 
>  *   函数名与类名相同，是一个特殊的成员函数；
>  *   不用定义返回值类型（不是void类型）；
>  *   不可以写return语句。
> 
> 作用：给对象进行初始化。
> 
> 注意：
> 
> （1）在一个类中如果没有自定义构造函数那么系统会提供一个默认的构造函数，参数为空Person()\{\}；
> 
>         当在类中自定义了构造函数后，系统提供的默认构造函数就没有了。
> 
> （2）构造函数是可以重载的；
> 
> （3）什么时候定义构造函数呢？  
> 当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

构造函数和一般成员函数的区别？

> （1）在运行上有不同：  
>      构造函数是在对象一建立就运行。给对象进行初始化。  
>      而一般成员函数是对象调用才执行，是给对象添加对象具备的功能。
> 
> （2）一个对象建立，构造函数只运行一次。而一般成员函数可以被该对象调用多次。

构造代码块是什么？

> 构造代码块：
> 
> 作用：给对象进行初始化。  
>     对象一建立就运行，而且优先于构造函数执行。  
>     和构造函数的区别：  
>     构造代码块是给所有对象进行统一初始化，  
>     而构造函数是给对应的对象初始化。
> 
>     构造代码快中定义的是不同对象共性的初始化内容。

class Person{
      private int age;
      private String name;
      //构造代码块
      {
        cry();  //所有对象的共性内容
      }
      //空参数的构造函数
      Person()
      {
        System.out.println("A:name="+name+",age="+age);
      }
      //带一个参数的构造函数
      Person(String n)
      {
        name=n;
        System.out.println("B:name="+name+",age="+age);
      }
      //带两个参数的构造函数
      Person(String n,int a)
      {
        name=n;
        age=a;
        System.out.println("C:name="+name+",age="+age);
      }
      public void cry()
      {
        System.out.println("everyone will cry");
      }
    }
    public class demo{
    public static void main(String[] args) {
        Person p=new Person();  //调用空参数的构造函数
        p.cry();
        Person p1=new Person("Li"); //调用一个参数的构造函数
        p1.cry();
        Person p2=new Person("Li",20); 调用两个参数的构造函数
        p2.cry();
      }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 2][]

# this关键字 #

特点：this代表其所在函数所属对象的引用 （this代表本类对象的引用）。

什么时候使用this关键字呢？  
当在函数内需要用到调用该函数的对象时，就用this。

> this：就代表本类的对象，到底代表哪一个呢？
> 
> this代表它所在函数所属对象的引用。  
> 简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

public class Demo {
      public static void main(String[] args) {
        Person p=new Person(20);
        p.speak();
        Person p1=new Person("Li");
        p1.speak();
        Person p2=new Person("Li",30);
        p2.speak();
      }
    
    }
    class Person{
      private int age;
      private String name;
      //空参数的构造函数
      Person(int age)
      {
        this.age=age;
      }
      //带一个参数的构造函数
      Person(String name)
      {
        this.name=name;
      }
      //带两个参数的构造函数
      Person(String name,int age)
      {
        this.name=name;
        this.age=age;
      }
      public void speak()
      {
        System.out.println("name="+this.name+",age="+this.age);
        this.show();
      }
      public void show()
      {
        System.out.println(this.name);
      }
    }

![20200513204120202.png][]

注意：对于成员变量如果没有赋初值时整型为0，字符串为null。

> this 语句还可以用在构造函数中进行相互调用；
> 
> 注意：this语句只能定义在构造函数的第一行。因为初始化要先执行。

public class HelloWorld {
      public static void main(String[] args) {
        new Person();
      }
    }
    class Person
    {
      private String name;
      private int age;
      {
        System.out.println("构造代码块执行");
      }
      Person()
      {
        this("Li"); //先使用this语句进行初始化，出现在构造函数第一行
        System.out.println("name="+name);
      }
    
    }

![20200514221432849.png][]

# static关键字 #

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

> 被修饰后的成员具备以下特点：
> 
>  *   随着类的加载而加载。也就说：静态会随着类的消失而消失。说明它的生命周期最长；
>  *   优先于对象存在(比对象先存在，对象是后建立的，静态是先存在的)；
>  *   被所有对象所共享；
>  *   可以直接被类名调用：当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。形式：类名.静态成员
> 
> 使用注意：
> 
>  *   静态方法只能访问静态成员（非静态方法既可以访问静态也可以访问非静态）；
>  *   静态方法中不可以写this，super关键字（因为静态优先于对象存在（静态变量建立的时候对象还未建立）。所以静态方法中不可以出现this）；
>  *   主函数是静态的
> 
> 静态的利与弊：
> 
>  *  利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。 可以直接被类名调用
>  *  弊：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)

什么时候使用静态呢？

> 什么时候定义静态成员变量（类变量）呢？
> 
> 当对象中出现共享数据时，该数据应被静态所修饰。而对象中的特有数据要定义成非静态存在于堆内存中。 
> 
> 什么时候定义静态函数呢？
> 
> 当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。

public class Text {
      public static void main(String[] args) {
        Person.show();  //使用类名来调用静态成员方法
      }
    }
    class Person
    {
      static String country="China";
      public static void show()
      {
        System.out.println(country);
      }
    }

实例变量和类变量的区别：

> String name;//成员变量（实例变量）  
> static String country = "CN";//静态的成员变量，类变量
> 
> 两者区别：
> 
>  *  存放位置(内存)：类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。
>  *  生命周期不同：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。

public class Demo {
      public static void main(String[] args) {
        Person.show();  //使用类名访问静态成员函数
        System.out.println(Person.country);  //使用类名访问静态成员变量
      }
    
    }
    class Person{
      static String country="China";
      public static void show()
      {
        System.out.println("Welcome");
      }
    }

![20200513212536779.png][]

什么是静态代码块？

> 静态代码块：
> 
> 格式：  
> static  
> \{  
>     静态代码块中的执行语句。  
> \}
> 
> 特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。

public class Demo {
      static
      {
        System.out.println("b");
      }
      public static void main(String[] args) {
        new StaticCode(4);
        new StaticCode();
      }
      static
      {
        System.out.println("c");
      }
    }
    class StaticCode{
      int num=9;
      StaticCode()
      {
        System.out.println("e");
      }
      //静态代码块
      static
      {
        System.out.println("a");
      }
      {
        System.out.println("c"+this.num);
      }
    
      StaticCode(int x)
      {
        System.out.println("d");
      }
    }

![2020051321400043.png][]

> 思考一下：Person p = new Person("zhangsan",20);这句代码在内存中执行的先后顺序。
> 
> 1）因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。  
> 2）执行该类中的static代码块，如果有的话，给Person.class类进行初始化。  
> 3）在堆内存中开辟空间，分配内存地址。  
> 4）在堆内存中建立对象的特有属性。并进行默认初始化。  
> 5）对属性进行显示初始化。  
> 6）对对象进行构造代码块初始化。  
> 7）对对象进行对应的构造函数初始化。  
> 8）将内存地址付给栈内存中的p变量。

# 单例设计模式 #

设计模式：解决某一类问题最行之有效的方法。  
java中23种设计模式：  
单例设计模式：解决一个类在内存只存在一个对象。

> 如何保证对象唯一性？
> 
>  *   为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象；
>  *   还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象；
>  *   为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
> 
> 与这三步对应的代码体现：
> 
>  *   将构造函数私有化；
>  *   在类中创建一个本类对象
>  *   提供一个方法可以获取到该对象；

//单例设计模式
    //方法一是先初始化对象。称为：饿汉式
    public class HelloWorld {
      public static void main(String[] args) {
        Student s1=Student.getInstance();  //注意访问的是私有方法
        s1.setAge(30);
        System.out.println(s1.getAge());
      }
    }
    class Student
    {
      private Student(){}
      private int age;
      private static Student s=new Student();
      public static Student getInstance()
      {
        return s;
      }
      public void setAge(int age)
      {
        this.age=age;
      }
      public int getAge()
      {
        return age;
      }
    }

![2020051421504587.png][]

//方法二：对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
    //当类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
    class Single
    {
    	private static Single s = null;
    	private Single(){}
    	public static Single getInstance()
    	{
    		if(s==null)
    		{
    			synchronized(Single.class)
    			{				
    				if(s==null)
    					s = new Single();
    			}
    		}
    		return s;
    	}
    }

记录原则：定义单例，建议使用饿汉式。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70]: /images/20230312/9926c506ccfd4ba48357fbfceef1386d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 1]: /images/20230312/600c3d4a0e0042008f0e3fe613357a64.png
[2020051318475856.png]: https://img-blog.csdnimg.cn/2020051318475856.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200513202300847.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx,size_16,color_FFFFFF,t_70
[20200513204120202.png]: https://img-blog.csdnimg.cn/20200513204120202.png
[20200514221432849.png]: https://img-blog.csdnimg.cn/20200514221432849.png
[20200513212536779.png]: https://img-blog.csdnimg.cn/20200513212536779.png
[2020051321400043.png]: https://img-blog.csdnimg.cn/2020051321400043.png
[2020051421504587.png]: https://img-blog.csdnimg.cn/2020051421504587.png