黑马程序员---Java基础---面向对象：类的组成部分

-------  android培训 、 java培训 、期待与您交流！ ----------

面向对象：类的组成部分

一、面向对象

1.定义
面向对象相对于面向过程而言，面向过程强调的是功能行为，面向对象将功能封装进对象，强调的是具备了功能的对象。换句话说，面向过程强调的是一个主体，程序的实现是主体去完成各种功能；面向对象强调的是具备功能的个体，程序的实现是主体使用具有功能的个体去完成。
2.面向对象的特点
（1）将复杂的事情简单化
（2）面向对象，将以前的执行者变成了指挥者
（3）对象就是将函数等一些功能属性进行了封装。

3.面向对象的程序开发

（1）开发的过程：不断的创建对象，使用对象，指挥对象做事情。

（2）设计的过程：管理和维护对象之间的关系。

（3）面向对象的特征：封装、继承、多态。

二、类与对象的关系
1.类与对象的关系

类是对一类事物的共性特点的提取和描述

对象是这类事物中实实在在存在的一个个体。

2.类的定义

生活中描述事物就是在描述事物的属性和行为。

在java中我们用变量和方法来分别代表事物的属性和行为。

那么定义类其实就是在定义类中的成员（成员变量和成员方法）。

3.成员变量和局部变量的区别

（1）成员变量

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

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

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

（2）局部变量

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

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

作用的范围结束，变量空间会自动释放，通常局部变量的作用于是一对大括号。

局部变量没有默认初始化值。
三、封装
1.封装 的概念
是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
2.封装原则
将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其进行访问，以保证属性的安全性。
类是一个封装体，而函数是java中最小的一个封装体。

3.封装的好处

将变化隔离

便于使用

提高复用性

提高安全性
四、private权限修饰符
1.封装的一种表现形式；
2.并且它也是权限修饰符中的一种，用于修饰类中的成员（成员变量和成员函数）；
3.私有成员只在本类中有效；
4.由于外部类是没办法直接访问此成员变量的，所以必须提供一种公共的方法来访问它（即get和set方法）。
作用：
提高了此成员变量的安全性，防止非法的赋值情况出现。

例子：这就是对私有成员变量的访问方法。

class Person  
{  
    //定义一个私有变量  
    private int age;  
  
    //下面提供公共的方法来访问  
    public void setAge(int age)  
    {  
        //此处还可以写上判断条件，来判断给的age值是否合法，从而来保证此成员变量的安全性。  
        if (age>0)  
        {  
            this.age=age;  
        }  
        else   
        {  
            System.out.println("输入的age值是非法值");  
        }  
    }  
    //得到此私有变量的值  
    public int getAge()  
    {  
        return age;  
    }  
}  

五、构造函数

1.作用

给对象进行初始化，对象一建立就执行对应的构造函数。

2.特点
（1）函数名和类名相同；
（2）不用定义返回值类型；
（3）不可以写return语句；
（4）当一个类中没有定义构造方法时，系统会默认给该类加入一个空参数的构造函数。
  当一个类中定义了构造方法之后，默认的构造函数就没有了。
（5）当一个类中有多个构造方法时，此时这些构造方法有重载的特性。

3.构造函数与一般函数的不同

1> 写法不同

2> 构造函数只在对象建立的时候执行，给对象进行初始化。

   一般函数是在对象调用时执行，是对象的功能

3> 一个对象建立，构造函数只执行一次

  一般函数可以被对象多次调用

4.例子

class Person
{
	private int age;
	private String name;
	//以下两个构造函数即为重载
	Person()
	{
		System.out.println("age="+age+"name="+name);
	}
	Person(int age,String name)
	{
		this.age=age;
		this.name=name;
		System.out.println("age="+age+"name="+name);
	}
}

六、构造代码块
1.格式
{
执行语句;
}
2.作用

给此类的所有对象进行初始化，对象一建立就运行，而且优先于构造函数执行。
3.与构造函数的区别
构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象进行初始化。

4.示例

class ConstructorCode 
{
	 int age=10;
	 String name="lili";
	 //构造函数
	ConstructorCode()
	{
		System.out.println("age="+age+"---name="+name);	
	}
	ConstructorCode(int age,String name)
	{
		System.out.println("age="+age+"---name="+name);		
	}
	//构造代码块
	{
		System.out.println("hello 构造代码块");		
	}
}

class ConstructorCodeTest
{
     public static void main(String[] args) 
    {  
	ConstructorCode c1=new ConstructorCode();//结构为：hello 构造代码块
						  //age=10---name=lili					
	ConstructorCode c2=new ConstructorCode(20,"wangwu");//hello 构造代码块
							   //age=20---name=wangwu
    }
}

七、this关键字

this代表其所在函数所属对象的引用，即this代表本类对象的引用。

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

另外this还可以用来在构造函数中，调用本类的其他构造函数。

示例

class Student
{
	String name;
	int age;
	
	Student(String name)
	{
		this.name = name;
	}
	Student(String name, int age)
	{
		this(name);    //调用上面的构造函数
		this.age = age; 
	}
	//比较两个学生年龄的大小
	public boolean compareAge(Student student)
	{
		//this.age的this代表调用该函数的Student对象
		return (this.age > student.age)? true : false;
	}
}

八、static修饰符

1.作用
用于修饰成员（成员变量和成员函数）

2.被修饰的成员具有以下特点
（1）静态修饰的内容被对象所共享；
（2）当成员被静态所修饰之后，又多了一种调用方式，除了可以被对象调用之外，还可以被类名直接调用。
（3）它存放在方法区或者叫共享区中；
（4）随着类的加载而加载，随着类的消失而消失，它的生命周期最长；
（5）优先于对象存在。

3.实例变量和类变量的区别

静态变量又称为类变量，而成员变量（即未被static修饰的）又称为实例变量。

1> 存放位置：

类变量随着类的加载而存在于方法区中

实例变量随着对象的建立存在于堆内存中

2> 生命周期

类变量生命周期最长，随着类的消失而消失

实例变量生命周期随着对象的消失而消失

4.静态使用注意事项

1> 静态方法只能访问静态成员（方法和变量）

   非静态方法及尅访问静态成员也可以访问非静态成员

2>静态方法中不可以出现this、super关键字

   因为静态优先于对象存在

3>主函数main()是静态的 

5.静态的利弊

利：对对象的共享数据进行单独空间的存储，节省内存空间

       可以直接被类名调用

弊：生命周期过长

       访问出现局限性，静态方法只能访问静态成员

6.示例

class Person
{
     String name;  //成员变量又称为实例变量
     static String country = "CN";   //静态成员变量又称为类变量
     public static void show()
     {
//    	System.out.println(name);    //静态方法不可以访问实例变量
        System.out.println(country); //静态方法访问静态变量
     }
}
class Test
{
	public static void main(String[] args)
	{
		//静态成员可以直接被类名调用
		System.out.println(Person.country);
		System.out.println(Person.country);
	}
}

7.静态代码块

存在于类中，用于给类变量进行初始化

格式：

static

{

      静态代码块中的执行语句；

}

特点：

随着类的加载而执行，只执行一次，并优先本类的主函数执行。

注意：

静态代码块是给类进行初始化，构造代码块是给对象的共性数据进行初始化，构造函数是给对象的特性数据进行初始化。

九、静态代码块、构造代码快、构造函数的执行顺序

class CompCodeTest 
{
	public static void main(String[] args) 
	{
		new CompCode();
		new CompCode(3);
	}
}

class CompCode
{
	private int x;
	//定义此类的构造函数
	CompCode()
	{
		System.out.println("hello 无参的构造函数--");
	}
	//有参的构造函数
	CompCode(int x)
	{
		this.x=x;
		System.out.println("hello 有参的构造函数--------"+x);
	}
	//构造代码块
	{
		System.out.println("hello 构造代码块---");
	}
	//静态代码块
	static
	{
		System.out.println("hello 静态代码块");
	}
}
				
结果为：hello 静态代码块
	  hello 构造代码块---
	  hello 无参的构造函数--
	  hello 构造代码块---
	  hello 有参的构造函数--------3
	即表示静态代码块优先于构造代码块，构造代码块优先于构造函数。