_Java基础<四>_面向对象(上)

面向对象(上)

一、面向对象的概念

         在介绍面向对象的概念之前，先来了解一下面向过程的概念。因为面向对象是基于面向过程的。

         面向过程强调的是过程行为，也就是方法行为，一个行为调用另外的一个行为；例如前面的编程就是面向过程的，面向过程是一种设计的思想，C语言就是面向过程思想的。

         面向对象将功能封装到对象中，强调具备了功能的对象；当想要调用这个功能时，可以去找这个对象，然后用这个对象调用这个功能。

         面向对象思想的举例：当我们想要更远隔千里的同学聊天，就会想到使用QQ，因为QQ具备聊天功能，调用了QQ的聊天功能就可以实现聊天功能，而并非自己造一个方法实现聊天功能。这时，QQ就是对象，对象中封装了功能，这就是面向对象的思想。

         面向对象是一种符合现实生活的思想，它可以将复杂的事情简单化，让程序员从执行者变成了指挥者。但必须先找到具有所需功能的对象，然后调用该功能，当没有该对象时，就需要创造一个具有所需功能的对象。面向对象可以简化开发的步骤并且提高复用性。

         面向对象的三个特征：封装，继承，多态。

二、类与对象的关系

        类：在现实生活中，每一类事物都有自己的特征；在java中，可以通过类的形式来描述一类事物；类是具体事物的抽象。

         对象：即某类事物实实在在的个体。

         类与对象：对于同一类事物可以抽取它们的共性内容，定义在类中。例如：现实生活中的每一辆汽车都具有颜色和轮胎数，那么就可以把颜色和轮胎数抽取到汽车类中。

         类具有属性和行为，属性也称为成员变量，行为也称为成员函数。

         成员变量与局部变量的区别：

         (1)、成员变量的作用范围是它所属的整个类；局部变量的作用范围是它所属的{}中，比如：函数内，for语句内。

         (2)、成员变量在堆内存中；局部变量在栈内存中，会自动释放。

         (3)、成员变量有默认初始化值，局部变量没有初始化值，使用之前必须初始化。

         匿名对象：匿名对象是对象的简化形式，没有栈内存的引用指向它。

         特点：匿名对象的方法只能调用一次；匿名对象可以作为实参传递给形参。

package itheima.day05;
//类与对象的演示
public class CarDemo {

	public static void main(String[] args) {
//		创建一个实实在在的对象，凡是new的实体都在堆内存中
		Car c = new Car();
		c.run();

//		匿名对象只可以使用一次	
		new Car().run();
//		匿名对象作为实参传递
		show(new Car());
	}
	public static void show(Car c){
		c.num =3;
		c.color ="blue";
		c.run();
	}
}
//汽车类
class Car{
	String color = "red";//颜色
	int num = 4;//轮胎数
//	汽车类的方法，也叫类的行为
	void run(){
		System.out.println("car run...."+color+","+num);
	}
}

三、封装

         封装：封装就是隐藏对象的属性和实现的细节，仅仅对外界提供公有访问方式。

         封装的好处：将变化隔离，便于使用，提高重用性，提高安全性。

四、构造函数

        构造函数：构造函数是一种特殊的函数，用于给对象的初始化；为了体现唯一性，构造函数必须与类型相同，并且没有返回值类型，也没有return语句。

         注意：每一个类中都包含有构造函数，当没有手动写构造函数时，系统会提供一个默认的构造函数，默认的构造函数是无参的构造函数。一旦手动写了构造函数，那么系统就不再提供任何构造函数。如果需要，必须手动写上无参构造函数，否则编译通不过。多个构造函数以重载的形式存在。

       构造代码块：形式:{构造代码块语句;}，用于给全部对象进行初始化。对象一旦建立就运行代码块，并且优先于构造函数而运行。

         构造函数与构造代码块区别：构造函数是给对应的对象进行初始化，构造代码块是给所有的对象进行统一初始化。

五、this关键字

         this关键字：代表本对象的引用。

         应用：

                  (1)、用于区别类的成员变量和局部变量；

                  (2)、用于构造函数之间的相互调用；只能放在构造函数的第一行。

                  (3)、用于成员函数内部要用到该函数所属的对象。

下面是用人的类与对象代码分析：

package itheima.day05;
//演示人的对象
public class PersonDemo {
	public static void main(String[] args) {
//		调用无参构造函数：这是默认构造函数:name =null,age0
		Person p1 = new Person();
//		调用有参构造函数
		Person p2 = new Person("zhangsan",24);
		Person p3 = new Person("lisi",23);
//		调用成员方法，说出自己的情况
		p2.speak();
		p3.speak();
	}
}
class Person{
	private int age;
	private String name;
	
	Person(String name,int age){
//		this关键字：用于区别成员变量和局部变量
		this.name = name;
		this.age = age;
		System.out.println("name ="+this.name +",age="+this.age);
	}
	Person(){
		System.out.println("这是默认构造函数:"+"name ="+name+",age"+age);
	}
//	成员函数，说出自己的情况
	public void speak(){
		System.out.println("我是"+name+",我今年"+age+"岁。");
	}
}

六、static关键字

         Static关键字：用于修饰成员变量或者成员函数。

         调用方式：类名.静态成员

         静态成员的特点：(1)、随着类的加载而加载，生命周期最长；

                                              (2)、先于对象而被创建；

                                              (3)、可以直接被类名调用。

         注意：

                  (1)、静态的方法只能访问静态成员，因为静态方法优先于非静态成员存在；

                  (2)、静态方法中不能使用this，super等关键字。

         静态的应用：作为工具类使用，可以将所有的方法都定义成为静态方式，并且是私有化构造函数，这时不能创建对象，只能用类名调用，java中的API的制作就是这个原理。

         静态代码块：格式:static{执行语句;};

         特点：用于给类的初始化，只执行一次。

七、单例设计模式

        单例设计模式：一个类在内存中只有一个对象。

         作用：用于多个程序共同使用同一个对象，比如：配置文件

         设计单例的方式：

                  (1)、私有化构造函数；

                  (2)、在类中创建一个静态的本类对象；

                  (3)、向外提供一个能够获取本类对象的静态方法。

         单例有两种方式：懒汉式，由于涉及到多线程知识，暂时不分析；

                                           饿汉式：下面代码体现。

package itheima.day06;
//演示饿汉式的单例模式
public class SingleDemo {
//	单例模式就是为了保证内存中只有一个对象
	public static void main(String[] args){
		Single.getInstance();
		Single.getInstance();
	}
}
class Single{
//	1：私有化构造函数
	private Single(){
		System.out.println("单例模式111");
	}
//	2：在类中创建一个本类对象
	private static Single s =new Single();
//	3、向外界提供一个获取本类对象的方法
	public static Single getInstance(){
		return s;
	}
}