黑马程序员 面向对象及三大特性之封装

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、面向对象

1.面向对象是相对面向过程而言

2.面向对象和面向过程都是一种思想

3.面向过程：

强调的是功能行为

4.面向对象

将功能封装进对象，强调具备了功能的对象。

5.面向对象是基于面向过程的

 

面向对象的特点

是一种符合人们思考习惯的思想

可以将复杂的事情简单化

将程序员从执行者转换成了指挥者

完成需求时：

先要去找具有所需的功能的对象来用。

如果该对象不存在，那么创建一个具有所需功能的对象。

这样简化开发并提高复用

面向对象分析

确定对象和类(名词)；

确定数据结构

面向对象设计

进一步确定对象，及对象与对象之间的关系。

面向对象编程

类、创建对象，使用对象，指挥对象做事情。

举例：

<span style="font-size:18px;">class Student{
	String stuName;
	char stuSex;
	int stuAge;
	void sayHello(){
		System.out.println("我是"+stuName+"性别"+stuSex+"年林"+stuAge);
	}
}
class Demo{
	public static void main(String[] args){
		Student stu1=new Student();
		stu1.sayHello();
		stu1.stuName="刘德华";
		stu1.stuSex='男';
		stu1.stuAge=57;
	

		System.out.println(stu1.stuName);
		System.out.println(stu1.stuSex);
		System.out.println(stu1.stuAge);
		Student stu3=null;
	}
}</span>

成员变量：

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

成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

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

局部变量：

局部变量只定义在局部范围内，如：函数内，语句内等。

局部变量存在于栈内存中。

作用的范围结束，变量空间会自动释放。

局部变量没有默认初始化值。

 

<span style="font-size:18px;">class Car//对Car这类事物进行描述
{
	String color = "red";
	int num = 4;
	void show()
	{
		System.out.println("color="+color+"..num="+num);
	}
}
class CarDemo 
{
	public static void main(String[] args) 
	{
		Car c = new Car();//建立对象
		c.color = "black";//对对象的属性进行修改
		c.show();//使用对象的功能。
	}
}
</span>

匿名对象

匿名对象是对象的简化形式

匿名对象两种使用情况

当对对象方法仅进行一次调用的时

匿名对象可以作为实际参数进行传递

例如：

<span style="font-size:18px;">class MyMath{
	double getPI(){
		return 3.1415;
	}
}
class Tools{
	void printPI(MyMath m){
		System.out.println(m.getPI());
	}
	
}
class NiMingDemo 
{
	public static void main(String[] args) 
	{
		//1.当对对象方法仅进行一次调用的时
	//	MyMath math = new MyMath();
		double pi = new MyMath().getPI();//匿名对象，new之后直接访问成员属性或成员方法；
		System.out.println(pi);

		System.out.println(pi);
		System.out.println("--------------------------");
		//2.2.匿名对象可以作为实际参数进行传递
		Tools tools = new Tools();
	//	MyMath math = new MyMath();
		tools.printPI(new MyMath());//将匿名对象传递到方法；因为我们的程序内不需要MyMath的引用；

		

	}
}</span>

二、面向对象的三大特性之一封装

封装

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

l好处：

将变化隔离。

便于使用。

提高重用性。

提高安全

封装原则：

将不需要对外提供的内容都隐藏起来。

把属性都隐藏，提供公共方法对其访问。

private关键字：

是一个权限修饰符。

用于修饰成员(成员变量和成员函数)

被私有化的成员只在本类中有效。

public关键字：

是一个权限修饰符。

用于修饰成员(成员变量和成员函数)

被公有化的成员在所有类中都可以访问。

常用之一：

将成员变量私有化，对外提供公有对应的set，get方法对其进行访问。提高对数据访问的安全性。

 

举例：

<span style="font-size:18px;">class Student{
	/*******成员变量*******/
	//全部设为私有private
	//姓名
	private String stuName;
	//性别
	private char stuSex;
	//年龄
	private int stuAge;

	

	//提供共有的public设置和访问的接口
	/***stuName****/
	public void setStuName(String stuName){
		//此时局部变量stuName 将覆盖成员变量stuName
		//在这个方法内，使用stuName时，是局部变量的stuName
		stuName = stuName;
		this.stuName = stuName;//给成员变量stuName赋值
	}
	public String getStuName(){
		return this.stuName;
	}
	/***stuAge****/
	public void setStuAge(int age){
		this.stuAge = age;
	}
	public int getStuAge(){
		return this.stuAge;
	}
	/***stuSex****/
	public void setStuSex(char s){
		this.stuSex = s;
	}
	public char getStuSex(){
		return this.stuSex;
	}
	
}
class Demo 
{
	public static void main(String[] args) 
	{
		Student stu = new Student();
		stu.setStuName("张学友4444");
		System.out.println(stu.getStuName());
		

	}
}</span>

this关键字

特点：1.this代表其所在函数所属对象的引用。构造方法之间可以互相调用，但是不能使用方法名，使用this();

2.调用其它构造方法的语句必须是这个构造方法的第一句话；

换言之：this代本类对象的引用。

当在函数内需要用到调用该函数的对象时，就用this。

局部变量隐藏全局变量

构造函数中用

初始化代码块

 

函数：

1.位于类体中；
2.如果存在"初始化代码块"时，是在"初始化代码块"之后执行；
3.构造函数的规则：
1).跟类名相同；
2).不能有返回值的声明，甚至是void
4.构造函数，可以重载
5.如果定义了带参的构造器，那么Java不再自动添加默认构造器；

举例：

 

 

<span style="font-size:18px;">private String stuName;
	private int stuAge;

	//定义一个默认的，无参的构造函数
	Student(){
	}
	//定义一个带参数的构造函数
	Student(String stuName,int stuAge){
		
		this.stuAge = stuAge;
	}
	
	Student(String stuName){
		this.stuName = stuName;
	}
	Student(int stuAge){
		this.stuAge = stuAge;
	}
	
	
	//初始化代码块
	{
		System.out.println("Student的初始化代码块！");
	}
	void show(){
		System.out.println("我叫：" + stuName + " ,年龄：" + stuAge);
	}


}
class Demo {
	public static void main(String[] args){

		Student stu = new Student();//调用默认构造器
		stu.stuName = "张学友";
		stu.stuAge = 40;

		Student stu1 = new Student("刘德华",45);//调用带两个参数的构造方法
		stu.show();
		Student stu2 = new Student("刘德华");//调用一参数String的构造方法
		Student stu3 = new Student(45);	//调用一个参数i</span>nt的构造方法

注意：

默认构造函数的特点。

多个构造函数是以重载的形式存在。

 

static关键字：


1.可以修饰类成员（成员属性、成员方法、内部类），不能修饰"顶层类";
2.被static修饰的，都是"静态的"，在没有"类"的"对象"存在的情况下，就已经存在的
3.可以通过"对象名"、"类名"访问；
4.子类可以覆盖父类的静态成员，但子类中的成员也必须是静态的；
5."静态方法"不能访问"非静态成员变量"
6."静态方法"可以访问"静态成员变量"以及"其它静态方法
7.被所有对象共享；
8.任何访问方式，都是访问的同一个内存区域；
9.任何的访问方式都可以更改其值，更改后，通过其它访问将是新值
10.static成员变量的应用一
存储当前对象的数量
11.static成员变量的应用二
作为整个应用程序的全局变量

<span style="font-size:18px;">class Teacher{
	void show(){
		System.out.println(Student.num);
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		Student stu = new Student();
		System.out.println(stu.num);//通过对象名访问
			
		System.out.println(Student.num);//通过类名访问
	


	}
}</span>

单例设计模式

解决的问题：保证一个类在内存中的对象唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的

<span style="font-size:18px;">//饿汉式
class Single{ 
private Single(){} 		//私有化构造函数。 
private static Single s = new Single(); 	//创建私有并静态的本类对象。
 public static Single getInstance(){ 	//定义公有并静态的方法，返回该对象。 
return s; 
} 
} </span>

<span style="font-size:18px;">//懒汉式:延迟加载方式。
 Class Single2{ 
private Single2(){} 
private static Single2 s = null; 
public static Single2 getInstance(){ 
if(s==null) 
s = new Single2(); 
return s; 
}
 }</span>

构造方法的特点

 

1.方法名同类名相同；
   2.没有返回值类型，甚至是void;
   3.不能返回任何值；
   4.构造方法可以重载；
   5.构造方法可以接收参数；
   6.构造方法是自动执行，当实例化一个此类对象的时候；
   7.实例化一个对象的时候，只能执行一个构造方法；
   8.构造方法可以调用构造方法，使用this([参数]);
   9.构造方法可以被修饰为private(私有的)；

注意：
  1.如果我们不指定构造方法的话，系统会自动为我们的类添加一个默认构造方法：无参、不做任何事情；
  2.如果我们指定了构造方法，那么系统将不再自动添加默认构造方法；