Java面向对象概述

面向对象介绍

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

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

过程和对象在我们的程序中是如何体现的呢？

过程其实就是方法；对象是将函数等一些内容进行了封装。

 

面向对象特点：

1）将复杂的事情简单化。

2）面向对象将以前的过程中的执行者，变成了指挥者。

3）面向对象这种思想是符合现在人们思考习惯的一种思想。

 

Java 是一个支持并发、基于类和面向对象的计算机编程语言。下面列出了面向对象软件开发的优点：

1）代码开发模块化，更易维护和修改。

2）代码复用。

3）增强代码的可靠性和灵活性。

4）增加代码的可理解性。

 

面向对象编程有很多重要的特性，比如：封装，继承，多态和抽象。

 

类和对象

类(class)和对象(object)是Java语言的基本元素，是面向对象的核心概念。

类是对某一类事物的描述，是抽象的、概念上的定义；类是一个模板，它描述一类对象的行为和状态。

对象是实际存在的该类事物的每个个体，因此也称为实例（instance）。对象是类的一个实例，有状态和行为。

面向对象程序设计的重点是类的设计。

定义类其实是定义类中的成员(成员变量和成员方法)。

 

类

类可以看成是创建Java对象的模板。

类的成员：属性、方法、构造器（构造方法）

/** 类：人*/
public class Person {
    String name; //属性：姓名
    int age;  //属性：年龄
    String contry; //属性：国家

    public Person(){ //构造方法：无参构造
    }
    public Person(String name, int age){ //构造方法：有参构造
        this.name = name;
        this.age = age;
    }
    void say(){ //方法：说话
        System.out.println("说话");
    } 
    void eat(){ //方法：吃东西
        System.out.println("吃东西");
    }
    void sleeping(){ //方法：睡觉
        System.out.println("睡觉");
    }
}

 

一个类可以包含以下类型变量：

局部变量：

在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

public class  ClassName{
    public void printNumber（）{
        int a; // 局部变量
    }
    // 其他代码
}

成员变量：

成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

public class  ClassName{
    int a; // 成员变量
    public void printNumber（）{
        // 其他代码
    }
}

静态变量（类变量）：

类变量也声明在类中，方法体之外，但必须声明为static类型。

由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

不同的对象的实例变量将被分配不同的内存空间， 如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。

public class  ClassName{
    static int a; // 静态变量
    public void printNumber（）{
        // 其他代码
    }
}

 

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

1）定位范围不同（声明位置不同）

成员变量定义在类中，在整个类中都可以被访问。

局部变量只定义在局部范围内，如：方法内，参数中，代码块内等。

2）作用范围不同

成员变量在这个类中有效。

局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。

3）数据存储位置不同

成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在的堆内存中。

局部变量存在于栈内存中。作用的范围结束，变量空间会自动释放。

4）初始值不同

成员变量有默认初始化值。

局部变量没有默认初始化值，每次必须显式初始化。也就是说必须先声明，再赋值，最后才使用。

5）修饰不同

成员变量的权限修饰符可以根据需要，选择任意一个。

局部变量声明时不指定权限修饰符。

注意：在一个类中，局部变量可以与成员变量同名，但是局部变量优先，如果非要访问成员变量的属性，则必须使用 this.变量名。this 代表当前这个对象，也就是当前谁调用这个方法则这个对象就是谁。

 

成员变量和静态变量的区别：

1）两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象的回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2）调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3）别名不同

成员变量所属于对象，所以也称为实例变量。

 静态变量所属于类，所以也称为类变量。

4）数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

 

构造方法：

构造方法的名字和类名相同，并且没有返回值。

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法，，也就是不带参数的构造方法。

构造方法主要用于为类的对象定义初始化状态。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

我们不能直接调用构造方法，必须通过new关键字来自动调用，从而创建类的实例。

public class Person{
    public Person(){ // 无参数构造
    }
    public Person(String name){ // 这个构造器仅有一个参数：name     
    }
}

 

创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。

实例化：使用关键字new来创建一个对象。

初始化：使用new创建对象时，会调用构造方法初始化对象。

public class Person{
   public Person(String name){
      //这个构造器仅有一个参数：name
      System.out.println("名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Person rose = new Person( "rose" );
   }
}

 

访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法，如下所示：

/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问类中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.methodName();

下面的例子展示如何访问实例变量和调用成员方法：

page com.zwj.test; // 包，防止名字相同的类产生冲突

public class Person{
   int age;
   public Person(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("名字是 : " + name ); 
   }
   // 设置年龄
   public void setAge( int personAge ){
       age = personAge ;
   }
   // 获取年龄
   public int getAge( ){
       System.out.println("年龄为 : " + age); 
       return age;
   }
   
   public static void main(String []args){
      /* 创建对象 */
      Person rose = new Person( "rose" );
      /* 通过方法来设定age */
      rose.setAge( 18 );
      /* 调用另一个方法获取age */
      rose.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + rose.age); 
   }
}

 

源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

1）一个源文件中只能有一个public类（最多一个）

2）一个源文件可以有多个非public类

3）源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是User，那么源文件应该命名为User.java。

4）如果一个类定义在某个包中，那么package语句应该在源文件的首行。

5）如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。

6）import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

 

Java包

包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

 

Import语句

在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。