面向对象进阶

二、面向对象进阶

2.1 封装private

观察以下代码：

public class Demo {

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张三";
        person.age = -30;
        person.tell();
    }
}
public class Person{
     String name; //表示姓名
     int age;//表示年龄

    void tell(){
        System.out.println("姓名：" + name + "；年龄：" + age);
    }
}
结果：姓名：张三；年龄：-30

以上代码运行正常，但出现了逻辑错误 （年龄：-30）

在开发中，为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作。

修改代码如下：

public static void main(String[] args) {
    Person person = new Person();
    person.setName("张三");
    person.setAge(-30);
    person.tell();
}

public class Person {
    private String name ; // 表示姓名
    private int age ; // 表示年龄
    void tell(){
        System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ;
    }
    public void setName(String str){
        name = str ;
    }
    public void setAge(int a){
        if(a>0&&a<150)
            age = a ;
    }
    public String getName(){
        return name ;
    }
    public int getAge(){
        return age ;
    }
}

2.2 this

在Java基础中，this关键字是一个最重要的概念。

使用this关键字可以完成以下的操作：

• 调用类中的属性
• 调用类中的方法或构造方法
• 在一个构造方法中，调用另一个构造方法时，调用的代码必须写在构造方法的第一行。
• 表示当前对象

2.3 static

static表示“静态”的意思，可以用来修饰成员变量和成员方法(后续还会学习 静态代码块 和 静态内部类)。

static的主要作用在于创建独立于具体对象的域变量或者方法

简单理解：

​ – 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

​ – 并且不会因为对象的多次创建 而在内存中建立多份数据

重点

1. 静态成员 在类加载时加载并初始化。
2. 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
3. 在访问时： 静态不能访问非静态 , 非静态可以访问静态 !

例：

class StaticDemo{
    /**
    *静态修饰的方法，被调用时，有可能对象还未创建
    */
    static void say(){
        System.out.println("注意防护！")
    }
    /**
    *通过对象来创建
    */
    void say2(){
        System.out.println("数据挖掘！")
        say();
    }
}
public class Demo{
    public static void main(String[] args){
        StaticDemo.say();
    }
}

2.4 代码块

（1）普通代码块

​ 在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定–“先出现先执行”

public static void main(String[] args){
    /**
    *编写在顺序执行的代码流程中的代码块
    */
    {
        int a = 10;
        System.out.println(a);
    }
    System.out.println("a");
}

（2）构造代码块

​ 直接在类中定义且没有加static关键字的代码块称为构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函数。

public class CodeBlock {
    /**
    *构造代码块，随着对象的每次创建，执行一次。且执行在构造方法之前
    *区别于构造方法的是：
    *	无论用户调用哪一个构造方法来常见对象，构造代码块都必然执行
    */
    {
        System.out.println("构造代码块");
    }
     
    public CodeBlock(){
        System.out.println("无参构造函数");
    }
    public CodeBlock(String str){
        System.out.println("有参构造函数");
    }
}

（3）静态代码块

​在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。

静态代码块，随着类的加载（第一次使用），静态代码块执行

因为类只加载一次，所以静态代码块只执行一次

public class CodeBlock {
    /**
    *构造代码块
    */
    {
        System.out.println("构造代码块");
    }
    /**
    *静态代码块
    */
    static{
        System.out.println("静态代码块");
    }   
}

（4）同步代码块

​ 在后续多线程技术中学习。

面试题：

问：构造方法 与 构造代码块 以及 静态代码块的执行顺序：

答：静态代码块 --> 构造代码块 --> 构造函数 -->普通代码块

2.5 包

2.5.1 包的介绍

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

2、包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

2.5.2 包的使用规则

–包中java文件的定义：

在.java文件的首部， 必须编写类所属哪个包

格式： package 包名;

–包的定义：

通常由多个单词组成， 所有单词的字母小写， 单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目名.模块名…”。

–规范由来：

由于Java面向对象的特性，每名Java开发人员都可以编写属于自己的Java Package，为了保障每个Java Package命名的唯一性，在最新的Java编程规范中，要求开发人员在自己定义的包名前加上唯一的前缀。由于互联网上 的域名称是不会重复的，所以多数开发人员采用自己公司在互联网上的域名称作为自己程序包的唯一前缀。

例如： com.java.xxx

2.6 权限修饰符

修饰符	类	包	子类	其他包
public	v	v	v	v
protected	v	v	v	x
default	v	v	x	x
private	v	x	x	x

2.7 main方法详解

main()方法：

public static void main(String args[]) 

以上的各个参数的含义如下： 

· public：表示公共的内容，可以被所有操作所调用 

· static：表示方法是静态的，可以由类名称直接调用。

· void：表示没有任何的返回值操作 

· main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main 

· String[] args：字符串数组，接收参数的 

如：

public class Demo{ 

	public static void main(String args[]){ 

		for(int i=0;i<args.length;i++){ 

			System.out.println(args[i]) ; 

		} 
	} 
}
//运行:java Demo 1 2 3
//输出：
1
2
3

2.8 单例设计模式

单例设计模式是我们学习的第一个设计模式，也是比较重要的一个设计模式，单例设计模式会伴随这你的开发生涯，不

管你是初级程序员，还是以后晋级到高级程序员，你都会接触到单例设计模式，今天，我们就学习单例设计模式的两种 实现方式。

单例设计模式：保证程序在内存中只有一个对象存在（被程序所共享)

单例设计模式的两种实现方式：

一、懒汉式：随着类的加载在内存中对象为null，当调用 getInstance 方法时才创建对象（延迟加载）

二、饿汉式：随着类的加载直接创建对象（推荐开发中使用）

单例设计模式的实现步骤：

1．保证一个类只有一个实例，实现方式：构造方法私有化

2．必须要自己创建这个实例，实现方式：在本类中维护一个本类对象（私有，静态）

3．必须向整个程序提供这个实例，实现方式：对外提供公共的访问方式（getInstance方法，静态）

懒汉式实现如下：

class Single{ 
    
    private Single(){} 
    
    private static Single s1 = null; 
    
    public static Single getInstance(){ 
        if(s1 == null){ 
            s1 = new Single(); 
        }
        return s1; 
    } 
}

饿汉式实现如下：

class Single2{ 
    
    private Single2(){} 
    
    private static Single2 s = new Single2(); 
    
    public static Single getInstance(){ 
        return s; 
    }
    void print(){ 
        System.out.println("Hello World!"); 
    } 
}