黑马程序员—【Java基础篇】之面向对象

最新推荐文章于 2024-05-07 14:33:09 发布

WL8721

最新推荐文章于 2024-05-07 14:33:09 发布

阅读量657

点赞数

文章标签： java 黑马程序员设计模式面向对象

本文链接：https://blog.csdn.net/wl8721/article/details/45167365

版权

黑马Java学习笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

------- android培训、java培训、期待与您交流！ ---------

这篇分享和总结Java之面对对象。

主要学习型内容有：1.面向对象概念；2. 类与对象的关系；3 .封装；4. 构造函数；5. this关键字；6 static关键字；7 单例设计模式。一共七个部分，接下来一一总结。

一、面向对象概念

第一句话:万物皆对象。传说这是老妖精才能说的话，我们现在说，是很装格调哈，来起吧，伙伴们。

“java是一种面向对象的编程语言，也就是说对象是这种语言的基础，没有对象了，就没有了java。”我个人觉得这句话很经典，所以就接过来用一下。

举个例子：如把鸡蛋装进冰箱。

c语言强调的是功能行为：打开冰箱——>把鸡蛋装进冰箱——>关闭冰箱。

Java面向对象的思想就是强调冰箱具有功能的对象：冰箱打开，冰箱存储，冰箱关闭。感觉上就是过程是你自己亲自在做，而面向对象却是你指挥着对冰箱去做。

1、理解

一种符合人们思考习惯的思想；可以将复杂的事情简单化；先要去找具有所需的功能的对象来用；将程序员从执行者转换成了指挥者。

面向对象的三个特征：封装性，继承性，多态性。

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

Java设计的过程，其实就是在管理和维护对象之间的关系。多态性。

人是一个对象，人有吃饭，睡觉以及学习等等的行为（可称为功能），那么就是将吃饭、睡觉以及学习等功能封装进人这个的事物中，让人去执行这些功能，是人在调用这些方法，从而简化了过程。

二、类与对象的关系

1、类与对象的关系

先看一个示例图：

图纸就是类；根据图纸造出来的一辆辆汽车就是对象。

类（class）：可以理解为是构造对象的一个蓝图或者模板，是抽象的概念；反过来说，对象是以类为模型创造的具体实例，是对类的一种具体化、形象化。
类：对生活中事物的描述
对象：对类的具体实现，是实实在在存在的实体。
例如：汽车的设计
类：指的是汽车的设计图纸
对象：指实际生产出来的汽车。

/** 
需求：定义一个汽车类，要求设计出汽车的型号（即名字），颜色，轮胎个数，行驶速度，并且让汽车行驶起来（即打印出每个汽车的颜色、轮胎数、速度）并比较两辆汽车之间那个性能更好：即速度快慢 
思路： 
    1.创建一个构造函数，即一个汽车类，对其的颜色，轮胎数
    2.创建一个汽车对象，实现其功能 
    3.构造一个方法，比较两辆车之间的速度
*/
class Car{   
    String name;  
    String color;  
    int nums;  
    double speed;  
    Car(String name,String color,int nums,double speed)  
    {  
        this.name = name;  
        this.color = color;  
        nums = 4;  
        this.speed = speed;  
        System.out.println(name + "是一辆" + color + "，轮胎数是：" + nums + "，可以行驶的速度是：" + speed);  
    }  
      
    public void compare(Car c)  
    {  
        if(this.speed > c.speed)  
        {  
            System.out.println(this.name + "行驶得更快。");  
            return;  
        }  
        System.out.println(c.name + "行驶得更快。");  
        return;  
    }  
}  
  
class CarDemo  
{  
    public static void main(String[] args)   
    {  
        Car x = new Car("Jeep","红色",4,500);  
        Car y = new Car("法拉利","橙色",4,600);  
        x.compare(y);  
    }  
}

上面汽车的例子中，a、b和c是局部变量，定义在了方法中，存在于栈内存中；而name、color、nums和speed都是成员变量，存在于堆内存中，随着类的加载而加载。

2、成员变量与局部变量

不同处：

（1）作用范围
a. 成员变量：作用于整个类中；
b. 局部变量：作用于函数中，或者作用于语句块中；
（2）内存中的位置
a. 成员变量：在堆内存中，因为对象的存在才在内存中存在；
b. 局部变量：在栈内存中，随着函数的结束而消亡；
（3）初始化方式
a. 成员变量：随着类的初始化而初始化，在堆内存中被加载，有默认值，可直接参与运算；
b. 局部变量：随着方法的加载而加载进栈内存中，无初始化值，必须被初始化才能参与运算；

3、匿名对象

对象的简化形式：匿名对象。例： new Car();

匿名对象两种使用情况
（1）当对对象方法仅进行一次调用的时。
（2）匿名对象可以作为实际参数进行传递。
注：如果对一个对象进行多个成员调用，必须给这个对象起个名字。

匿名对象与实名对象的区别：

但是这个对象实体在方法结束后，垃圾回收机制会将其作为垃圾回收。而非匿名对象则不同，当不使用了，会在某一时刻被回收，或是随着主函数的结束而被回收。

三、封装(Encapsulation)

1、概念

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

2、好处

（1）将变化隔离。
（2）便于使用。
（3）提高重用性。
（4）调高安全性。

3、原则

（1）将不需要对外提供的内容都隐藏起来。
（2）把属性都隐藏，提供公共方法对其访问。

4、说明

（1）私有仅仅是封装的一种表现形式，如包也是一种封装形式

（2）之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高了代码的健壮性。

5、private(私有)关键字

（1）用于修饰成员(成员变量和成员函数)
（2）被私有化的成员只在本类中有效。
（3）常用之一：
将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性；是一个权限修饰符。

例如：

class Person//描述人对象的类  
{  
    private int age;//人对象的年龄属性，private（关键字）  
    public void setAge(int a)//提供访问方法，并判断是否有效  
    {  
        if(a>0 && a<130)  
        {  <pre name="code" class="java"><span style="white-space:pre">		</span>age = a;<pre name="code" class="java"><span style="white-space:pre">		</span>speak();
<pre name="code" class="java"><span style="white-space:pre">	</span>}  
        else{  
            System.out.println("非法数值");  
<span style="white-space:pre">	</span>}  
     }
    public int getAge()//提供公共获取方法，同时返回int值，必须return语句。<pre name="code" class="java"> {  
        return age;  
    }  
    private void speak()//私有说功能  
    {  
        System.out.println("age="+age);  
    }  
}  
  
class PersonDemo    
{  
    public static void  main(String[] args)  
    {  
        Person p = new Person();//创建人对象 ，主函数调用。 
        p.setAge(-50);//利用封装提供public访问方法进行修改年龄属性  
        p.speak();  
    }  
}

四、构造函数

1、特点

(1) 函数名与类名相同。

(2) 不用定义返回值类型。

(3) 不可以写return语句。

2、作用

(1) 给对象进行初始化。

3、注意事项

当一个类中没有定义构造函数时，那么系统就会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。

4、构造函数和一般函数区别

运行上不同：构造函数式在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给是对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。

5、什么时候定义构造函数？

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

6、构造代码块

（1）作用：给对象进行初始化；对象一建立就运行，而且优先于构造函数运行。（2）构造代码块构造函数的区别 a、构造代码块是给所有的对象进行初始化，即每个对象都会有的特性。 b、而构造函数是给对应的对象初始化； c 、构造代码块中定义的是不同对象共性的初始化内容。

<span style="font-family:SimSun;"><span style="font-size:12px;">class Person
{  private String name;</span></span><pre name="code" class="java"><span style="font-family:SimSun;font-size:12px;">   private  int  age;
{
    System.out.println("Person")//构造代码块
    cry();
}</span>

五、this知识点

毕老师上课的一个例子：

class Person  //声明Person类
{  
    private String name;  
    private int age;  
    Person(int age)//局部变量时age，成员变量也是age  
    {  
        this.age = age;//对象传进来的age给了全局变量age。 
    }  
    Person(String name)  
    {  
        this.name = name;//这里用this表示调用构造方法的对象  
    }  
    Person(String name,int age)  
    {  
        this.name = name;  
        this.age = age;  
    }  
  
    public void speak()  
    {  
        System.out.println("name="+name+"...age="+age);  
        show();  
    }  
    public void show()  
    {  
        System.out.println(this.name);  
    }  
}

1、特点

this代表其所在函数所属对象的引用。换言之：this代本类对象的引用。

2、什么时候使用this关键字呢？

当在函数内需要用到调用该函数的对象时，就用this。

六、static(静态)关键字

1、存在的意义

内存有一片地方是静态方法区，专门存放静态常量和方法的区域，当一个变量或者方法是所有对象都共有的，那么为了提高效率和内存使用率，就产生了static。

2、特点

（1）随着类的加载而加载，在类中生命周期最长；
（2）优先于对象而存在；
（3）可以被所有对象共享；
（4）可以直接被类名调用。

3、用途

（1）修饰成员：成员变量和成员方法。

（2）当成员被static修饰后，就多了一种调用方式，即可以被对象和类名调用。

4、静态常量和非静态常量

（1）静态成员变量又称为类变量。

（2）非静态成员变量又被称为实例变量。

（3）实例变量和类变量的区别

a、存放位置

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

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

b、生命周期

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

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

5、静态的利弊

（1）利

可以直接被类名调用。

（2）弊

存放在内存里，生命周期过长。
访问出现局限性。（静态虽好，只能访问静态）

对对象的共享数据进行单独空间的存储，节省空间。

public class Math
{    
    public static final double π = 3.14;//final将PI设置为不可再定义的常量   
}

如果省略了static，PI就变成了一个实例常量，那么，每一个Math对象就都有自己的一个PI拷贝了，这样的话，对内存也是一种占用。

class Student  
{  
    private int id; //定义私有变量id； 
    private static int studentId = 1; //定义静态 int studentId； 
    //获取id的访问器  
    public int getId()  
    {  
        return id;  
    }  
    public void setId()  
    {  
        id = studentId;  
        studentId++;  
    }  
}

6、静态的应用

/** 
这是一个可以对数组进行相关操作的工具类，该类提供了取数组的最值、排序等功能。 
@author 王永华
@version V1.8
*/  
//类名权限要最大才能创建说明书文档  
public class ArrayTool   
{  
    /** 
    空参数构造函数 
    */  
    private ArrayTool(); //私有化构造函数是为了让其不能创建对象。  
    {  
      
    }  
  
    /** 
    这个功能用于得到int类型数组中的最大值 
    @param arr 接收一个int类型的数组 
    @return 返回接收的该数组的最大值 
    */  
    public static int getMax(int[] arr)  
    {  
        int max=0;  
        for (int x=1;x<arr.length ;x++ )  
        {  
            if(arr[x]>arr[max])  
                max=x;  
        }  
        return arr[max];  
    }  
      
    /** 
    这个功能用于得到int类型数组中的最小值 
    @param arr 接收一个int类型的数组 
    @return 返回该数组的最小值 
    */  
    public static int getMin(int[] arr)  
    {  
        int min=0;  
        for (int x=1;x<arr.length ;x++ )  
        {  
            if(arr[x]<arr[min])  
                min=x;  
        }  
        return arr[min];  
    }  
  
    /** 
    对int类型数组进行选择升序排列 
    @param arr 接收一个int类型的数组 
    */  
    public static void selectSort(int[] arr)  
    {  
        for (int x=0;x<arr.length-1 ; x++)  
        {  
            for (int y=x+1; y<arr.length; y++)  
            {  
                if(arr[x]>arr[y])  
                    swap(arr,x,y);  
            }  
        }  
    }  
  
    /** 
    对int类型数组进行冒泡升序排列 
    @param arr 接收一个int 类型数组 
    */  
    public static void bubbleSort(int[] arr)  
    {     
        for (int x=0;x<arr.length-1;x++ )  
        {  
            for (int y=0;y<arr.length-x-1;y++ )  
            {     
                if(arr[y]>arr[y+1])  
                    swap(arr,y,y+1);  
            }  
        }  
    }  
  
    /** 
    对数组中的两个元素进行位置交换 
    @param arr 接收一个int类型的数组 
    @param a 要置换的元素角标 
    @param b 要置换的元素角标 
    */  
    private static void swap(int[] arr,int a,int b)  
    {  
        arr[a]=arr[b]+(arr[b]=arr[a])*0;  
    }  
  
    /** 
    遍历数组：打印数组中所有元素，形式为：[elemet1,elemet2,...] 
    @param arr 接收一个int类型的数组 
    */  
    public static void printArray(int[] arr)  
    {  
        System.out.print("[");  
        for (int x=0; x<arr.length-1; x++)  
        {  
            System.out.print(arr[x]+",");  
        }  
        System.out.println(arr[arr.length-1]+"]");  
    }  
}

通过以上我们可以发现，一下将要解决的问题。

（1）当每个应用程序都有共同之处，可将其封装，提高其复用性。

（2）注意事项

a. 对象时用于封装数据的；
b. 对数据的操作方法，若没用到方法中特有的数据，则无需创建对象而占用多余的内存。

（3）静态代码块

a. 随着类的加载而执行，且优先于主函数；

b. 只执行一次，类再创建对象，则不再执行，已经存在于内存中。
格式：

static  
   {语句};

七、单例设计模式

1、概念

解决某一问题最行之有效的方法，java中共有23种设计模式，其中单利设计模式就是其中一种。

2、单例设计模式

单例设计模式的作用：使一个类在内存中只存在一个对象。

3、单例设计模式的具体表现形式

单利设计模式其中具体表现有：饿汉式和懒汉式；其实是两中思维的碰撞。

（1）饿汉式

特点：先初始化对象

class Single   
{  
    private Single(){}  
    private static Single s = new Single();  
    public static  Single getSingle()  
    {  
        return s;  
    }  
}  
  
class SingleText  
{  
    public static void main(String [] args)  
    {  
        Single s1 = Single.getSingle();  
        Single s2 = Single.getSingle();  
        if (s1==s2)  
            System.out.println(true);  
        else  
            System.out.println(false);        
    }  
}

（2）懒汉式

特点：对象是方法被调用时，才初始化，这也叫对象的延时加载。

class Single   
{  
    private Single(){}  
    private static Single s = null;  
    public static Single getSingle()  
    {  
        if (s==null)   
            s = new Single();  
        return s;  
    }  
}  

class SingleText  
{  
    public static void main(String [] args)  
    {  
        Single s1 = Single.getSingle();  
        Single s2 = Single.getSingle();  
        if (s1==s2)  
     System.out.println(true);  
        else  
     System.out.println(false);        
    }  
}

相比之下，我个人理解，第1种会占用内存一些，第二种少占内存一些，更加贴和，却又存在线程的安全问题。总体而言饿汉式比懒汉式更可靠。

今天到这里吧，小伙伴们明天见。

WL8721

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员—【Java基础篇】之面向对象

------- android培训、java培训、期待与您交流！ --------- 这篇分享和总结Java之面对对象。主要学习型内容有：1.面向对象概念；2. 类与对象的关系；3 .封装；4. 构造函数；5. this关键字；6 static关键字；7 单例设计模式。一共七个部分，接下来一一总结。一、面向对象概念第一句话:万物皆对象。传说这是老妖精才能说
复制链接

扫一扫