面向对象上总结

1、什么叫面向对象？

面向对象(Object-Oriented，简称OO)就是一种常见的程序结构设计方法。面向对象思想的基础是将相关的数据和方法放在一起，组合成一种新的复合数据类型，然后使用新创建的复合数据类型作为项目的基础。

面向对象是一个很抽象的概念，它相对面向过程而言。过程与对象都是一种解决问题的思想。

面向过程：强调的是功能行为,一种过程,先干啥,再干啥;

面向对象：将功能封装到对象里，强调的是具备某功能的对象;

按照面向对象的思想，可以把任何的东西看做对象！

 

面向对象的三个特征：

封装(Encapsulation);

继承(Inheritance);

多态(Polymorphism)。

package com.laobi.day06;

public class DuiXiang {
	/**
	 * 面向对象：对于面向对象思想，强调的是对象（实体）
	 * C++、Java、C＃
	 * 
	 * 
	 * 面向过程：对于面向过程思想，强调的是过程（动作）
	 * 例子：大象装进冰箱
	 * C语言
	 * 
	 * 面向对象的特点：
	 * 1、面向对象就是一种常见的思想。符合人们的思考习惯
	 * 2、面向对象的出现，将复杂的问题简单化
	 * 3、面向对象的出现，让曾经在过程中的执行者，变成了对象的指挥者
	 * 
	 * 用java语言对现实生活中的事物进行描述
	 * 通过类的形式来体现的
	 * 
	 * 怎么描述呢？
	 * 对于事物描述通常只关注两方面
	 * 一个是属性，一个是行为
	 * 
	 * 只要明确该事物的属性和行为并定义在类中即可
	 * 对象：其实就是该类事物实实在在存在的个体。
	 * 
	 * 类与对象之间的关系？
	 * 类：事物的描述
	 * 对象：该类事物的实例。在java中通过new来创建的
	 * 
	 * 成员变量和局部变量的区别：
	 * 1、
	 * 成员变量定义在类中，整个类中都可以访问。
	 * 局部变量定义在函数，语句，局部代码块中，只在所属都区域有效
	 * 2、
	 * 成员变量存在于堆内存的对象中
	 * 局部变量存在于栈内存的方法中
	 * 3、
	 * 成员变量随着对象的创建而存在，随着对象的消失而消失
	 * 局部变量随着所属区域的执行而存在，随着所属区域的结束而释放
	 * 4、
	 * 成员变量都有默认初始化值
	 * 局部变量没有默认初始化值
	 * 
	 * 匿名对象：没有名字的对象
	 * new Car();//匿名对象。其实就是定义对象的简写格式
	 * Car c=new Car()
	 * c.run();
	 * new Car().run()
	 * 
	 * 1、当对象对方法仅进行一次调用对时候，就可以简化成匿名对象
	 * 2、匿名对象可以作为实际参数进行传递
	 * 
	 * 封装：是指隐藏对象属性和实现细节，仅对外提供公共访问方式
	 * 好处：
	 * 1、将变化隔离
	 * 2、便于使用
	 * 3、提高重用性
	 * 4、提高安全性
	 * 封装原则：
	 * 将不需要对外的内容隐藏起来
	 * 把属性都隐藏
	 * 
	 * private：私有，是一个权限修饰符。用于修饰成员
	 *         私有都内容只在本类中有效。
	 *         
	 *  注意：私有仅仅是封装的一种体现而已。
	 */
	/*  
	 * 描述小汽车
	 * 
	 * 分析：
	 * 1、属性
	 * 轮胎数
	 * 颜色
	 * 2、行为
	 * 运行
	 */
	public static void main(String[] args) {
		Car c = new Car();
//		c.color="red";
//		c.num=4;
//		c.run();
		show(c);
	}
	public static void show(Car c)
	{
		c.num = 3;
		c.color="black";
		System.out.println(c.num+"..."+c.color);
	}

}

class Car
{
	int num;
	String color;
	
	void run()
	{
		System.out.println(num+"..."+color);
	}
}

构造函数部分：

package com.laobi.day07;

public class GouZaoHanShu {
	/**
	 * 构造函数
	 * 特点：
	 * 1、函数名与类名相同
	 * 2、不用定义返回值类型
	 * 3、没有具体的返回值
	 * 作用：给对象进行初始化
	 * 注意：
	 * 1、默认构造函数的特点
	 * 
	 * 
	 * 构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化
	 * 创建对象都必须要通过构造函数初始化
	 * 
	 * 一个类中如果没有定义过构造函数，那么该类中会有一个默认的无参构造函数
	 * 如果在类中定义类指定的构造函数，那么类中的默认构造函数就没有了
	 * 
	 * 一般函数和构造函数什么区别呢？
	 * 构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化
	 * 一般函数：对象创建后，需要函数功能时才调用
	 * 
	 * 构造函数：对象创建时，会调用只调用一次
	 * 一般函数：对象创建后，可以被调用多次。
	 * 
	 * 什么时候定义构造函数？
	 * 在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中
	 * 
	 * 构造函数可以有多个，用于对不同的对象进行针对性的初始化
	 * 多个构造函数在类中是以重载的形式来体现的
	 * 
	 * this关键字
	 * 特点：this代表其所在函数所属对象的引用，换言之就是，this在本类对象中的引用
	 * 
	 * 当成员变量和局部变量重名，可以使用this来区分
	 * 
	 * this：代表对象。
	 * this就是所在函数所属对象的引用
	 * 
	 * this也可以用于在构造函数中调用其他构造函数
	 * 注意：只能定义在构造函数的第一行，因为初始化要先执行
	 * 
	 */
	public static void main(String[] args) {
		Person p = new Person();
	}

}

class Person
{
	private String name;
	private int age;
	
	Person()
	{
		System.out.println("person run");
	}
	
	public void speak()
	{
		System.out.println(name+"..."+age);
	}
}

静态部分：

package com.laobi.day07;

public class JingTai {
	 /**
	  * 静态修饰符
	  * static ：用于修饰成员（成员变量和成员函数）
	  * 
	  * 被修饰后的成员具备一下特点
	  * 1、随着类的加载而加载
	  * 2、优先于对象存在
	  * 3、被所有对象所共享
	  * 4、可以直接被类名调用
	  * 
	  * 使用注意
	  * 1、静态方法只能访问静态成员
	  * 2、静态方法中不可以写this、super关键字
	  * 3、主函数是静态的
	  * 
	  * static特点
	  * 1、static是一个修饰符，用于修饰成员
	  * 2、static修饰的成员被所有的对象所共享
	  * 3、static优先于对象存在，因为static的成员随着类的加载就已经存在
	  * 4、static修饰的成员多了一种调用方式，就可以直接被类名所调用。
	  * 5、static修饰的数据是共享数据，对象中的存储的是特有数据
	  * 
	  * 成员变量和静态变量的区别
	  * 1、两个变量的生命周期不同。
	  *    成员变量随着对象的创建而存在，随着对象的被回收而释放。
	  *    静态变量随着类的加载而存在，随着类的消失而消失
	  * 2、调用方式不同
	  *    成员变量只能被对象调用
	  *    静态变量可以被对象调用，还可以被类名调用
	  * 3、别名不同
	  *    成员变量也称为实例变量
	  *    静态变量称为类变量
	  * 4、数据存储位置不同
	  *    成员变量数据存储在堆内存对对象中，所以也叫对象对特有数据
	  *    静态变量数据存储在方法区（的静态区），所以也叫对象的共享数据
	  *    
	  * 静态什么时候用？
	  * 1、静态变量
	  *    当分析对象中所具备的成员变量的值都是相同的，这时这个成员就可以被静态修饰
	  *    只要数据在对象中都是不同的，就是对象的特有数据必须存储在对象中，是非静态的
	  *    如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的
	  *    
	  * 2、静态函数
	  *    函数是否用静态修饰，就参考一点，就是该功能是否有访问到对象中到特有数据
	  *    简单点说，从源代码看，该功能是否需要访问非静态到成员变量，如果需要，该功能就是非静态的
	  *    如果不需要，就可以将该功能定义成静态的.当然也可以定义成非静态的，但是非静态需要被对象调用
	  *    而仅创建对象没有调用非静态的，没有访问特有数据的方法，该对象的创建是没有意义的
	  *    
	  * 静态代码块：
	  * 随着类的加载而执行，而且只执行一次
	  * 作用：
	  * 用于给类进行初始化
	  */
	public static void main(String[] args) {
		new Demo().speak();
	}
	

}
class Demo
{
	int age;
	static int num = 9;
	public  void speak()
	{
		System.out.println(num);
	}
}

继承部分：

package com.laobi.day08;

public class JiCheng {
	/**
	 * 继承的好处：
	 * 1、提高了代码的复用性
	 * 2、让类与类之间产生关系，给第三个特征多态提供了前提  
	 * 
	 * 在java中支持单继承，不直接支持多继承
	 * 单继承：一个子类只能继承一个父类
	 * 多继承：一个子类可以支持多个父类（java中不允许）
	 * java支持多层（多重）继承
	 * 也就出现了继承体系
	 * 当要使用一个继承体系：
	 * 1、查看该体系的顶层类，了解该体系的基本功能
	 * 2、创建体系中最子类的对象，完成功能的使用
	 * 什么时候定义继承？
	 * 当类与类之间存在所属关系的时候，就定义继承
	 * 
	 * 成员变量
	 * 当本类的成员和局部变量同名用this区分
	 * 当子父类中的成员变量同名用super区分
	 * this：代表本类对象的引用
	 * super：代表一个父类空间
	 * 
	 * 成员函数
	 * 当子父类中出现成员函数一摸一样的时候，会运行子类的函数。
	 * 这种现象称为覆盖操作。这是函数在子父类中的特性
	 * 
	 * 函数的两个特征：
	 * 1、重载：同一个类中
	 * 2、覆盖：在子类中
	 * 
	 * 覆盖注意事项：
	 * 1、子类覆盖父类方法时，子类权限必须要大于等于父类的权限。
	 * 2、静态只能覆盖，或者被静态覆盖
	 * 
	 * 什么时候使用覆盖操作？
	 * 当一个类进行子类的扩展时，子类需要保留父类的功能声明，
	 * 但是要定义子类中该功能特有内容时，就使用覆盖操作完成。
	 * 
	 * 子父类中构造函数的特点：
	 * 在子类构造对象时，发现访问子类构造函数时，父类也运行了
	 * 为什么呢？
	 * 原因是：在子类的构造函数中，第一行有一个默认的隐式构造函数 super（）
	 * 
	 * 在子类实例化过程当中：子类所有的构造函数默认都会访问空参数的构造函数
	 * 
	 * 为什么子类实例化的时候要访问父类中的构造函数？
	 * 因为子类继承了父类，获取到父类中到内容（属性），所以在使用父类内容之前
	 * 要看父类是如何对自己对内容进行初始化的。
	 * 所以子类在构造对象时，必须访问父类中的构造函数
	 * 为了完成必须这个动作，就在子类构造函数中加入了super语句
	 * 
	 * 如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确
	 * 要调用父类中哪个构造函数
	 * 
	 * 注意：super语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成
	 * 
	 * 
	 * 一个对象的实例化过程
	 * Person p ＝ new Person()
	 * 1、jvm会读取指定路径下的Person.class文件并加载仅内存，
	 *   并会先加载Person的父类（如果有直接的父类的情况下）
	 * 2、在堆内存中开辟空间，并分配地址值
	 * 3、并在对象空间中，对对象中的属性进行默认初始化
	 * 4、调用对应的构造函数进行初始化
	 * 5、在构造函数当中，第一行会先调用父类中构造函数进行初始化
	 * 6、父类初始化完毕后，在对子类的属性进行显示初始化
	 * 7、在进行子类构造函数的特定显示初始化
	 * 8、初始化完毕后，将地址值赋值给引用变量
	 * @param args
	 */
	public static void main(String[] args) {
		Student s = new Student();
		s.age=18;
		s.name="旺财";
		s.study();
	}

}

class Person
{
	String name;
	int age;
}
class Student extends Person
{
	public void study()
	{
		System.out.println(name+"...student study..."+age);
	}
}
class Worker extends Person
{
	public void work()
	{
		System.out.println(name+"...worker work..."+age);
	}
}

package com.laobi.day08;

public class DabLiMoShi {
	/**
	 * 设计模式：对问题行之有效的解决方法，其实它是一种思想
	 * 
	 * 单例设计模式
	 *    解决的问题：就是可以保证一个类在内存中的对象唯一性
	 *   
	 *必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性
	 *
	 *如何保证对象唯一性？
	 *1、不允许其他程序用new创建该类对象
	 *2、在该类创建一个本类实例
	 *3、对外提供一个方法让其他程序可以获取对象
	 *
	 *步骤：
	 *1、私有化该类构造函数
	 *2、通过new在本类中创建一个本类对象
	 *3、定义一个公有的方法，将创建的对象返回
	 * @param
	 */
	public static void main(String[] args) {
		System.out.println("Hello,World!");
		Single ss = Single.getInstance();
		System.out.println(ss);
	}

}
class Single
{
	//保证对象的唯一性
	private static Single s = new Single();//类一加载，对象就已经存在
	private Single(){}
	public static Single getInstance()
	{
		return s;
	}
} 
class Single2
{
	 //类加载进来没有对象，只有调用了getInstance方法时，才会创建对象
	private static Single2 s = null;
	private Single2(){}
	public static Single2 getInstance()
	{
		if(s==null)
			s = new Single2();
		return s;
			
	}
}