第六------面向对象进阶

目录

一、封装

1概述

2.封装原则

3. 例如下代码

二、this关键字

三、static关键字

1.概述

2.重点

四、包

1.包介绍

2.包的使用原则

3.import导包关键字

五、代码块（代码区域）

六、main方法详解

七、单例设计模式

---

一、封装

1概述

• 封装的意义在于保护或者防止代码(数据)被我们无意中破坏。
• 保护成员属性，不让类以外的程序直接访问和修改;

2.封装原则

• 隐藏对象的属性和实现细节，仅对外公开访问方法，并且控制访问级别

3. 例如下代码

class Person{        
    private String name ;  // 表示姓名        
    private int age ; // 表示年龄        
    void tell(){            
        System.out.println("姓名：" + name + "；年龄：" + age) ;        
    }    
};    
public class Demo{        
    public static void main(String args[]){            
        Person per = new Person() ;            
        per.name = "张三" ;            
        per.age = -30 ;            
        per.tell() ;        
    }    
};

以上的操作代码并没有出现了语法错误，但是出现了逻辑错误 （年龄-30岁） 
在开发中， 为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得 操作。
 修改后如下代码:（private修饰属性）

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 ;
            else{
                System.out.println("年龄设置不合理，自动设置为1");
                age = 1;
            } 
	}
	public String getName(){ 
		return name ; 
	}
	public int getAge(){ 
		return age ; 
	} 
};
public class Demo10{ 
	public static void main(String args[]){ 
		Person per = new Person() ;
		per.setName("张三") ; 
		per.setAge(-30) ; 
		per.tell() ; 
	} 
};

修改年龄属性时需要调用函数， 因此可以通过函数来控制输入的参数是否合理，并给出相应提示，大大的降低出错概率：

二、this关键字

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：    

· 调用类中的属性

· 调用类中的方法或构造方法

· 表示当前对象

三、static关键字

1.概述

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

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

简单理解：    

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

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

2.重点

a.  静态成员 在类加载时加载并初始化。

b.  无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )

c.  在访问时： 静态不能访问非静态 , 非静态可以访问静态 !（静态表示对象未创建也可调用，而非静态必须等到对象创建完毕。所以使用静态时，对象可能还未创建，因此不能访问非静态）

四、包

1.包介绍

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

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

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

2.包的使用原则

a 、包中java文件的定义：        

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

        格式：        package 包名;                

b  、 包的定义：        

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

c、规范由来：        

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

3.import导包关键字

a.格式：

import 包名.类名;

b.如何导包

当所需的工具类不在当前包中时，需要通过import进行导包；

如果不想通过import导包的话，也可以通过使用类全名的方法实现相同的功能；

package com.kkb.dome1;
//第一种方式
//import java.util.Scanner;
public class Demo{
    public static void main( String[] args){
        //Scanner input = new Scanner(System.in);
        //类的全名称(第二种方式)
        java.util.Scanner input = new java.util.Scanner(System.in);

    }
}

c.什么情况不需要导包？

• 一些常用的系统包;
• 比如String类型，包含在java.lang包中；
• 使用当前包中的类；

五、代码块（代码区域）

普通代码块 ：

        在执行的流程中 出现的 代码块，即编写在顺序执行的代码流程中的代码块，我们称其为普通代码块。
 
构造代码块： 

        在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。与构造方法不同，构造方法不一定会被执行（构造方法可能会重载，这样使用无参构造方法就不会调用一参或两参的构造方法）；所以当多个构造方法需要同一种操作时，可以使用代码块（可以有多个）；

 
静态代码块 ： 

        在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会 执行一次的代码块。(因为类只加载一次，所以静态代码块只执行一次。)
 
同步代码块：

        在后续多线程技术中学习。
 
面试题： 构造方法 与 构造代码块 以及 静态代码块的执行顺序：        

        静态代码块 -->  构造代码块 -->  构造方法

package com.kaikeba.demo4;

public class Dome {

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

        }
        Person p1 = new Person();
        Person p2 = new Person();
	}

}
class Person{
	private String name;
	private int age;
	/*
	 * 构造代码块，随着对象的每次创建，执行一次。 且执行在构造方法之前：
	 * 
	 * 区别于构造方法的是：
	 * 无论用户调用那一构造方法来创建对象，构造代码块都必然执行。
     *与构造方法不同，构造方法不一定会被执行（构造方法可能会重载，这样使用无参构造方法就不会调            
     *用一参或两参的构造方法）；所以当多个构造方法需要同一种操作时，可以使用代码块（可以有多个   
     *)；
	 * 
	 */
	{
		System.out.println("构造代码块，对象创建时执行1");
	}
	
	/**
	 * 静态代码块，随着类的加载（第一次使用），静态代码块执行。
	 *因为类只加载一次，所以静态代码块只会执行一次。
	 */
	static {
		System.out.println("静态代码块执行");
	}
	
	
	public Person() {
		System.out.println("构造方法，对象创建时执行2");
	}
	
	public Person(String name) {
		System.out.println("构造方法，对象创建时执行2");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	void say(){
		System.out.println("姓名："+name+",年龄："+age);
	}



}

六、main方法详解

 main()方法一直写到了今天：

public static void main(String args[])    

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

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

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

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

· main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main    · String[] args：字符串数组，接收参数的

public class StaticDemo10{    
    public static void main(String args[]){         
        for(int i=0;i<args.length;i++){            
            System.out.println(args[i]) ;        
        }    
    } 
};

所有的参数在执行类的时候以空格进行分割。

java StaticDemo10 1 2 3 4 5 6 7

但是，如果现在我要输入的是以下几种参数“hello world”、“hello vince”、“hello mjw”。 因为以空格分割，所以以上的三组参数会当做六组参数输入，那么此时如果要想完成有空格的内容输入，则参数需 要使用“"”括起来。

java StaticDemo10 "hello world" "hello vince" "hello mjw"

七、单例设计模式

单例设计模式是我们学习的第一个设计模式，也是比较重要的一个设计模式，单例设计模式会伴随这你的开发生涯，不 管你是初级程序员，还是以后晋级到高级程序员，你都会接触到单例设计模式，今天，我们就学习单例设计模式的两种 实现方式。

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

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

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

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

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!");    
    } 
}