黑马程序员—Java面向对象(类和对象、封装、构造方法、this关键字、static关键字)

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

面向对象(Object-Oriented，简称OO)就是一种常见的程序结构设计方法。

面向对象思想的基础是将相关的数据和方法放在一起，组合成一种新的复合数据类型，然后使用新创建的复合数据类型作为项目的基础。

Java语言是纯粹的面向对象的程序设计语言，这主要表现为Java完全支持面向对象的三种基本特征:继承、封装和多态。Java语言完全以对象为中心，Java程序的最小程序单位是类，整个Java程序由一个一个的类组成。

Java完全支持使用对象、类、继承、封装、消息等基本概念来进行程序设计,允许从现实世界中客观存在的事物(即对象)出发来构造软件系统，在系统构造中尽可能运用人类的自然思维方式。

面向对象是相对于面向过程而言的，面向过程强调的是功能行为，是具体的执行者。而面向对象强调的是具备了功能的对象，由面向过程的执行者变成了指挥者，调用对象的功能，指挥者对象做事情。他是一种符合人们思考问题的一种习惯的思想，能够将复杂的问题简单化。

面向对象有三个特征：封装(encapsulation)、继承(inheritance)、多态(polymorphism)

 

开发其实就是找对象使用，没有对象，就自己创建一个对象。

 

找对象、建立对象、使用对象、维护对象的关系。

 

/*

 * 类和对象的关系。

 *

 * 现实生活中的对象：张三、李四。

 * 想要描述：提取对象中的共性内容，对具体的抽象。

 * 描述时：这些对象的共性有：姓名、性别、年龄、学习java的功能。

 *

 * 映射到java中，描述就是class定义的类

 * 具体对象就是对应java在堆内存中用new建立的实体。

 *

 * 类就是：对现实生活中事物的描述。

 * 对象：就是这类事物，实实在在存在的个体。

 */



l 
可以理解为：

•   类就是图纸

•   汽车就是堆内存中的对象

类的定义：

类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述，是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。所以类代表的是总体，而不代表某个特定的个体。

 

在类中定义其实都称之为成员。成员有两种：

1：成员变量：其实对应的就是事物的属性。

2：成员函数：其实对应的就是事物的行为。

所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。

定义类：

语法格式：

[< 修饰符>] class < 类名>

{

    [<属性声明>]

    [<构造器声明>]

    [<方法声明>]

}

说明：修饰符public：类可以被任意访问

    类的正文要用{  }括起来

定义属性：

语法格式：

[<修饰符>]  类型  < 属性名> [=初值] ;

说明：修饰符 private: 该属性只能由该类的方法访问。

    修饰符 public: 该属性可以被该类以外的方法访问。

    类型：任何基本类型，如int、boolean或任何类。

定义方法：

 

语法格式：

    <修饰符> <返回类型> <方法名>([< 参数表>]) {

            [< 语句>]

}

说明： 修饰符：public,private,protected等。

    返回类型：return语句传递返回值。没有返回值：void。

对象的创建和引用：

使用 new +构造方法 创建一个新的对象；

使用 “对象名.对象成员” 的方式访问对象成员（包括属性和方法）；

 

 

//描述汽车.描述事物其实就是在描述事物的属性和行为。

//属性对应类中的变量，行为对应类中的函数(方法)。

 

//其实定义类，就是在描述事物，定义事物的属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法(函数))。

 

/*

 *  成员变量和局部变量：

    成员变量作用于整个类中。

    局部变量作用于函数中，或者语句中。

    在内存中的位置：

    成员变量：在堆内存中，因为对象的存在才在内存中存在。

    局部变量：存在于栈内存中。

*/

 

比如说，我们描述一个汽车类。汽车是一类事物，它有很多属性，其中包括颜色属性、轮胎个数属性，还有运行的run的方法，我们可以通过面向对象的思想把它描述成一个类。代码如下：

定义一个汽车类：

class Car

{

    //描述颜色

    String color = "红色";

    //描述轮胎数

    int num = 4;

   

    //运行行为

    void run()

    {

       System.out.println(color+"..."+num);

    }

    public static void main(String[] args)

    {

       Car c = new Car();

       c.num = 8;

       c.run();

    }

}

 

实例化一个汽车对象和指挥对象做事情的具体过程：

public classCarDemo

{

    public static void main(String[] args)

    {

       //生产汽车，在java中通过new操作符来完成。

       //其实就是在堆内存中产生一个实体。

       Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。

      

       //需求：将已有车的颜色改成蓝色，指挥对象做事情。在java中的指挥方式是：   对象.对象成员

       c.color = "blue";

      

       c.run();//blue 4轮胎

      

       Car c1 = new Car();

       c1.run();//红色4轮胎

 

       //匿名对象使用方法之一：当对对象的方法只调用一次时，可以用匿名对象完成，这样写比较简化。

       //如果对一个对象进行多个成员进行调用，必须给这个对象起个名字。

       //匿名对象的使用方式二：可以用匿名对象作为实际参数进行传递。

       new Car().num = 9;

       new Car().color = "blue";

       new Car().run();

 

       Car q = new Car();

       Show(q);

    }

   

    //需求：汽车修配厂。对汽车进行改装，将来的车改成黑色3个轮胎。

    public static void Show(Car c)

    {

       c.num = 3;

       c.color = "black";

       c.run();

    }

}

 

封装：

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

封装的好处：

•    将变化隔离。

•    便于使用。

•    提高重用性。

提高安全性

封装的原则：

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

•    把属性都隐藏，提供公共方法对其访问。

private关键字：

•    是一个权限修饰符。

•    用于修饰成员(成员变量和成员函数)

•    被私有化的成员只在本类中有效。

常用之一：

•    将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性。

 

•     

Java中通过将数据声明为私有的(private)，再提供公开的（public）方法:getXXX和setXXX实现对该属性的操作，以实现下述目的：

–    隐藏一个类的实现细节；

–    使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

–    便于修改，增强代码的可维护性；

代码示例：

public classPerson {

    //定义一个私有化的成员属性name

    private String name;

    //定义一个私有化的成员属性age

    private int age;

    //构造函数

    public Person() {

       this.name = name;

       this.age = age;

    }

    //提供公有的访问属性name的方法

    //getName方法，返回属性name

    public String getName() {

       return name;

    }

    //setName方法，设置属性name的值

    public void setName(String name) {

       this.name = name;

    }

    //提供公有的访问属性age的方法

    //getAge方法，返回属性值age

    public int getAge() {

       return age;

    }

    //setAge方法，设置属性age的值

    public void setAge(int age) {

       this.age = age;

    }

}

构造方法：

•     构造方法的特征

–    它具有与类相同的名称；

–    它不含返回值；

–    注意：在构造方法里不含返回值的概念是不同于“void”的，在定义构造方法时加了“void”，结果这个方法就不再被自动调了。

–    不可以写return语句

 

构造方法的作用：当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码。

注意：

默认构造函数的特点。
多个构造函数是以重载的形式存在的。
 

构造方法的定义：

语法格式：

< 修饰符>  <类名>([< 参数表>]) {

       [< 语句>]

}

默认的构造函数特点：

Java语言中，每个类都至少有一个构造方法；
如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个默认的构造方法：
–  默认构造方法没有参数

–  默认构造方法没有方法体

–  默认的构造方法：Person(){}

 所以：不编写构造方法就能用new Xxx()创建类的实例。

Java类中，一旦类的定义者显式定义了一个或多个构造方法，系统将不再提供默认的构造方法；
构造器的主要作用：利用构造器参数初始化对象的属性。
 

This关键字：

this:代表对象。就是所在函数所属对象的引用。

this到底代表什么呢？哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。

开发时，什么时候使用this呢？

在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。

 

this 还可以用于构造函数间的调用。

调用格式：this(实际参数)；

this对象后面跟上 .  调用的是成员属性和成员方法(一般方法)；

this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

 

注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

 

static(静态)关键字：

/*

 * 静态：static

 * 用法：是一个修饰符，用于修饰成员（成员变量和成员函数）

 * 当成员被静态修饰后，就对了一种调用方式，除了可以被对象调用外，还可以直接被类名调用。写法格式：类名.静态成员

 *

 * static特点：

 * 1.随着类的加载而加载。

 *   也就是说，静态会随着类的消失而消失。说明他的生命周期最长。

 * 2.优先于对象而存在。

 *   明确一点：静态是先存在，对象是后存在的。

 * 3.被所有的对象所共享。

 * 4.可以直接被类名所调用。

 *

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

 * 1.存放位置。

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

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

 * 2.生命周期。

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

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

 *

 * 静态的使用注意事项：

 * 1.静态方法只能访问静态成员。

 *  非静态方法既可以访问静态也可以访问非静态。

 * 2.静态方法中不可以定义this，super关键字。

 *  因为静态优先于对象存在，所以静态方法中不可以出现this。

 * 3.主函数就是静态的。

 *

 * 静态有利有弊。

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

 *    可以直接被类名调用。

 * 弊端：生命周期过长。

 *     访问出现局限性。（静态虽好，只能访问静态。）

 */

 

class Person

{

    static String name;//成员变量，实例变量。

    static String country = "CN";//静态的成员变量，类变量。

    public static void show()

    {

       System.out.println("name="+name+"::country="+country);

    }

}

classStaticDemo

{

    public static void main(String[] args)

    {

       //Person p = new Person();

       //p.name = "张三";

       //p.show();

       //System.out.println(p.country);

      

       //System.out.println(Person.country);

       Person.show();//调用静态方法，只需通过类名.方法名即可。

    }

}

* 什么时候使用静态？

 * 要从两方面下手：

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

 *

 * 什么时候定义静态（类变量）变量呢？

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

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

 *

 * 什么时候定义静态函数呢?

 *  当功能内部没有访问到非静态数据（对象的特有数据）

 *  那么该功能可以定义成静态的。

 */

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