Java语言基础篇（四）

Java语言基础篇（四）

一、面向对象程序设计

1、概念

面向对象程序设计（OOP，Object Oriented Programming），是一种计算机编程架构，由对象所组成，对用户公开特定的功能部分，隐藏具体的实现内容，即它不关心对象的具体实现，只需满足用户的需求即可。面向对象的重点是类和对象。

2、面向对象的三大特性

• 封装
• 继承
• 多态
• 抽象（面试时，假如面试官问到面向对象的四大特性有哪些，就把抽象也给回答上）

二、封装

1、定义

封装是面向对象三大特性之一，它将数据（属性）和行为（方法）组合在一个类中，对对象的调用者隐藏数据的实现方式，它不能让类中的方法直接访问其他类中的实例域，而是通过对象的方法与对象的数据进行交互。

2、作用

封装的作用：

• 给对象赋予“黑盒”特性
• 提高代码的重用性（复用）和可靠性（安全）

3、访问修饰符

• 定义：访问修饰符又可以叫做权限修饰符，可以用来修饰类、成员变量和成员方法。
• 分类：
  • default
  • private
  • protected
  • public
• 访问修饰符的作用范围

修饰符	当前类	同一包	子类（可不同包）	不同包
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

4、其他修饰符

1. final修饰符
   final修饰符可以修饰类、方法及变量，表示“最终” 的意思。
   ① final修饰的类不能继承，其中所有方法自动升为final方法，不包括域（属性），如String类，StringBuffer等。
   ② final修饰的方法不能被子类重写。
   ③ final修饰的变量为常量，只能赋值一次，不能再次修改。
   ④ final修饰的成员变量必须在声明的同时进行赋值，赋值机会只有一次，即在构造方法中进行赋值才能使用。
2. static修饰符
   static修饰符可以修饰方法及变量，表示“静态”的意思。
   静态成员变量属于类，不属于任何独立的对象，因此无需创建类的实例就可以访问到静态成员变量。static的变量在类装载时便被初始化。
   ① 一个类的静态成员方法只能访问静态成员变量。
   ② 一个类的静态成员方法不能够直接调用非静态成员方法。
   ③ 可以通过类的实例.静态成员方法来进行访问，但不推荐这样使用；
   ④ 静态方法中不存在当前对象，因此不能使用 this，当然也不能使用 super；
   ⑤ 静态方法不能被非静态方法覆盖；
   ⑥ 构造方法不允许声明为 static 的；
   ⑦ 局部变量不能使用static修饰。
3. this修饰符
   this用来表示当前类的实例。
   作用：
   ① 在构造方法中作为方法名表示调用当前类的其他构造方法。
   ② 调用当前类的其他成员变量或者成员方法。
4. super修饰符
   super是一个指示编译器调用超类方法的特殊关键字。
   作用：
   ① 调用父类中声明为private的变量。
   ② 调用在子类中已被覆盖的方法。
   ③ 作为方法名表示父类构造方法。

三、类和对象

1、类

• 定义：类是对现实生活中一类具有共同属性和行为的事物的抽象，是构造对象的模板，是Java程序的基本组成单位。

• 本质：

  • 类是对象的数据类型。
  • 类是相同属性和行为的一组对象集合。

• 类的组成

  • 属性：在类中通过成员变量（类中方法外的变量）来实现。
  • 行为：在类中通过成员方法来实现。

• 识别类的简单规则：分析问题然后寻找名词，成员方法可以查找问题中出现的动词。

• 类的定义
  格式：

  public class 类名 {
  	//成员变量
  	数据类型 变量名;
  	...
  	//成员方法
  	数据访问修饰符 返回的数据类型 方法名() {
  	
  	}
  }
  

  例子：

  public class User {
  	//成员变量
  	private String name;
  	private Integer age;
      //成员方法
      public String eat() {
      	System.out.println("吃饭");
      }
  }
  

• 类之间的关系

  • 依赖（“user-a”）：这种关系是最常见的，也是最明显的，例如在类的一个方法操作另外一个类的对象。
    例子：

    class A {
       public void testA() {
           B b = new B();
           b.testB();
       }
    }
    
    class B {
       public void testB() {
           System.out.println("B say hello!");
       }
    }
    	
    

  • 聚合（“has-a”）：这种关系是具体的，也易于理解，即一个类中包含另外一个类。
    例子：

    class A {
       private B b;
    }
    
    class B {
       private A a;
    }
    

  • 继承（“is-a”）：这种关系的本质就是特殊和一般，即子类继承于父类，子类拥有了父类的成员变量和方法。
    例子：

    class A {
        public String s;
        
        public void sayHello() {
        	System.out.println("hello");
        }
    }
    
    class B extends A {
        
    }
    

2、对象

• 概念：对象是类的实例，是类的具体表现形式，在现实生活中是能够看得见摸得着的真实存在的实体。

• 组成：实例域（属性）和方法（行为）

  • 实例域：是对象中的数据
  • 方法：操作数据的过程，用于操作对象及存取实例域。

• 对象的使用

  • 构造器：构造器顾名思义就是构造对象的方法或者也可以叫做构造函数，是一种特殊方法，对象由其进行创建，它指定一个初始状态并且对对象使用对象中的成员方法。
    构造器的特点：
    1. 与类同名；
    2. 每个类可以有一个以上的构造器；
    3. 可以有0个、1个或多个参数；
    4. 没有返回值；
    5. 总是伴随着new操作一起使用；
    6. 定义一个类，没构造器，系统提供默认提供一个无参构造器。
    7. 如果自定义了构造函数，那么编译器就不自动创建构造函数。可以自行定义一个无参构造函数（推荐）。

  • 创建对象
    格式：类名 对象名 = new 类名();
    示例：

    public class Main {
    	public static void main(String[] args) {
    	    //初始化新构造的对象
    		User user = new User();
    		System.out.println(user);
    		//引用一个已存在的对象
    		User user2 = user;
    		System.out.println(user2);
    	}
    }
    
    class User {
       public String name;
    }
    

    上述示例的main方法中的user是一个对象变量，它本身不是一个对象，首先必须得进行一个初始化，初始化的方式有2种，上述示例已给出，new 操作符返回的本身就是一个引用，因此，在Java中，任何对象变量的值都是对存储在另外一个地方的一个对象的引用。

  • 成员变量的使用
    格式：对象名.成员变量名;
    示例：

    public class Main {
    	public static void main(String[] args) {
    		User user = new User();
    		user.name = "如花";
    		System.out.println(user.name);
    	}
    }
    
    class User {
       public String name;
    }
    

    上诉成员变量的使用破坏了Java的封装性，在Java中有更改器方法（mutator method）和访问器方法（accessor method）来修改对象状态和访问对象

    成员变量的使用改进版：

    public class Main {
     public static void main(String[] args) {
     	User user = new User();
     	user.setName( "如花");
     	System.out.println(user.getName());
     }
    }
    
    class User {
     private String name;
     /**
     * 访问器方法
     */
     public String getName() {
     	return name;
     }
     /**
     * 更改器方法
     */
     public void setName(String name) {
     	this.name = name;
     }
    }
    

  • 成员方法的使用
    格式：对象名.成员方法名;
    示例：

     public class Main {
    	public static void main(String[] args) {
    		User user = new User();
    		user.sayHello();
    	}
    }
    
    class User {
       public String name;
       public void sayHello() {
       		System.out.println("hello!");
       }
    }
    

• 成员变量和局部变量

  • 成员变量：定义在类中成员方法之外。

  • 局部变量：定义在成员方法内或方法声明上。

  • 区别：

    • 成员变量放在堆内存中，局部变量放在栈内存中。
    • 成员变量随着对象的存在而存在，随着对象的消失而消失；局部变量随着方法的调用而存在，随着方法的调用完毕而消失。
    • 成员变量初始化有默认的初始化值；局部变量没有默认的初始化值，必须先声明和赋值才能调用。

3、初始化块

        初始化块是Java类中出现的成员，用来初始化对象。在初始化块中可以执行任何可执行的语句以及定义方法块局部变量和调用方法等。

1. 对象初始化块
   对象初始化块也叫做普通初始化块，普通初始化块是对对象进行初始化。
   demo：

   public class Person {
   
       //定义一个初始化块
       {
           System.out.println("第一个初始化块");
       }
       //定义第二个初始化块
       {
           System.out.println("第二个初始化块");
       }
       //定义无参的构造器
       public Person() {
           System.out.println("Person的无参构造器");
       }
       
       public static void main(String[] args) {
           
           new Person();
       }
   
   }
   

   运行结果如图所示：
   

2. 静态初始化块
   当普通初始化块被static修饰后就变成了静态初始化块，也被称做类初始化块。

   注意：初始化块只能被static修饰符进行修饰。

   demo：

     public class Person {
   
   	    //定义一个静态初始化块
   	    static {
   	        System.out.println("Person的静态初始化块");
   	    }
   	    
   	    //定义一个初始化块
   	    {
   	        System.out.println("Person的第一个初始化块");
   	    }
   	    //定义第二个初始化块
   	    {
   	        System.out.println("Person的第二个初始化块");
   	    }
   	    //定义无参的构造器
   	    public Person() {
   	        System.out.println("Person的无参构造器");
   	    }
   	
   	    public static void main(String[] args) {
   	
   	        new Person();
   	    }
   
   }
   
   

   运行结果如下图所示：
   

关于Java的初始化块、静态初始化块、构造函数的执行顺序请自行查阅：Java的初始化块、静态初始化块、构造函数的执行顺序及用途探究

上一篇 Java语言基础篇（三）