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

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

 

面向对象(Object-Oriented,简称OO)就是一种常见的程序结构设计方法。
面向对象思想的基础是将相关的数据和方法放在一起,组合成一种新的复合数据类型,然后使用新创建的复合数据类型作为项目的基础。

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

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

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

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

 

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

 

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

 

/*

 * 类和对象的关系。

 *

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

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

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

 *

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

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

 *

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

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

 */

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

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语句

 

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

注意:

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

 

构造方法的定义:

语法格式:

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

       [< 语句>]

}

默认的构造函数特点:

  • 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培训、期待与您交流! ----------

你可能感兴趣的:(黑马程序员—Java面向对象(类和对象、封装、构造方法、this关键字、static关键字))