一、面向对象编程思想

面向对象就是一种解决问题的思维方式，它与面向过程的对比如下：

面向过程就是分析出解决问题的所有步骤，然后用函数把这些步骤依次实现，使用的时候依次调用就可以了。面向对象是把构成问题的事物抽象成各个对象，创建对象的目的不是为了完成一个步骤，而是为了描叙某个事物在解决问题过程中的行为。

例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用分别的函数来实现，问题就解决了。

而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为 1、黑白双方玩家，这两方的行为是一模一样的，2、棋盘，负责绘制画面，3、规则，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则对象）来对棋局进行判定。

可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了总多步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。

功能上的统一保证了面向对象设计的可扩展性和可维护性。

比如我要加入悔棋的功能，如果要改动面向过程的设计，那么从输入到判断到显示这一连串的步骤都要改动，甚至步骤之间的循序都要进行大规模调整。如果是面向对象的话，只用改动棋盘对象就行了，棋盘系统保存了黑白双方的棋谱，简单回溯就可以了，而显示和规则判断则不用顾及，同时整个对对象功能的调用顺序都没有变化，改动只是局部的。

再比如我要把这个五子棋游戏改为围棋游戏，如果是面向过程设计，那么五子棋的规则就分布在了你的程序的每一个角落，要改动还不如重写。但是如果你当初就是面向对象的设计，那么你只用改动规则对象就可以了，五子棋和围棋的区别不就是规则吗？（当然棋盘大小好像也不一样，但是你会觉得这是一个难题吗？直接在棋盘对象中进行一番小改动就可以了。）而下棋的大致步骤从面向对象的角度来看没有任何变化。

二、类与对象

简单来说，类就是对现实生活中事物的抽象，主要描述的是事物的属性和行为；对象则是现实生活中具体事物。

类是对象的模板，将对象的属性和行为进行了封装，也就是类中的成员变量和方法。实际开发中要以类为模板创建对象，也就是创建了一个真实存在的个体（实体），然后使用对象的功能解决实际问题（调用对象的方法）。而想要得到对象的属性或使用对象的功能，就要有一个对象的“ 遥控器 ”，也就是引用。严格来说引用和对象是有区别的，但可以将这种区别忽略。

定义对象的完整过程：

创建对象：new 类();
声明引用：类引用
将对象赋给引用：类引用=new 类();
得到对象属性：引用.属性;
使用对象方法：引用.方法();

上述过程中需要注意的是：引用的类型在声明时就已经确定，只有该类型或该类型的子类/实现类才能给引用赋值。

三、封装

封装是面向对象的核心思想之一。刚才说了类将对象的属性和行为进行封装，解决问题时只需要调用对象的方法即可，不需要知道它是如何实现的。隐藏对象的属性和行为的实现细节，这就是封装的思想。

为了保证数据安全，封装的基本原则就是：将实例变量标记为私有（ private）的，并提供公有（public）的getter与setter来控制存取动作。注意属性通常标记为private，方法可以是private、public、包访问权限、protected中任何一种。

示例程序：

public class Test23 {

	private int a;
	private String name;


	public int getA() {
		return a;
	}


	public void setA(int a) {
		this.a = a;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}

	public static void main(String[] args){
		Test23 t=new Test23();
		t.setA(1);
		System.out.println(t.getA());//1
		t.setName("k");
		System.out.println(t.getName());//k
	}
}

四、权限修饰符

权限修饰符根据访问权限的等级，从最大权限到最小权限依次为：public、protected、包访问权限（没有关键词）和private，关于权限修饰符的知识点如下：

类与接口的访问权限只能是包访问权限或public
public类和public接口必须与Java文件同名
变量和方法的访问权限可以是public、protected、包访问权限和private，不过变量通常是private
public类和public接口可以在任何地方访问
包访问权限类与接口只能在同包访问
private变量和方法只能在本类访问
包访问权限变量和方法只能在同包访问
protected变量和方法可以在同包访问，也可以在不同包的子类访问
public变量可以在任何地方访问

示例程序：

package com.grc.a;

public class A {

	private int i1;
	int i2;
	protected static int i3;
	public int i4;

	@SuppressWarnings("unused")
	private void a(){}
	void b(){}
	protected static void c(){}
	public void d(){}
	public int getI1() {
		return i1;
	}
	public void setI1(int i1) {
		this.i1 = i1;
	}
}

class AA{}

package com.grc.a;public class B {	private static A a;//public类可以在任何地方访问	@SuppressWarnings("unused")	private AA aa;//包访问权限的类只能在同包访问		public static void main(String[] args){		a=new A();		//!System.out.println(a.i1); private变量只能在本类访问		System.out.println(a.i2); //包访问权限变量只能在同包访问		System.out.println(A.i3); //protected变量可以在同包访问		System.out.println(a.i4);//public变量可以在任何地方访问		//!a.a(); private方法只能在本类访问		a.b();//包访问权限方法只能在同包访问		A.c();//protected方法可以在同包访问		a.d();//public方法可以在任何地方访问	}}

package com.grc.b;//import的作用：简化类名书写//注意：import导入的是类，不是包import com.grc.a.A;public class C extends A{	private static A a;//public类可以在任何地方访问	//!private AA aa; 包访问权限的类无法在不同包访问		public static void main(String[] args){		a=new A();		//!System.out.println(a.i1); private变量只能在本类访问		//!System.out.println(a.i2); 包访问权限变量只能在同包访问		System.out.println(i3); //protected变量可以在不同包的子类访问		System.out.println(a.i4);//public变量可以在任何地方访问		//!a.a(); private方法只能在本类访问		//!a.b(); 包访问权限方法只能在同包访问		c();//protected方法可以在不同包的子类访问		a.d();//public方法可以在任何地方访问	}}

package com.grc.b;import com.grc.a.A;public class D {	private static A a;//public类可以在任何地方访问	//!private AA aa; 包访问权限的类无法在不同包访问		public static void main(String[] args){		a=new A();		//!System.out.println(a.i1); private变量只能在本类访问		//!System.out.println(a.i2); 包访问权限变量只能在同包访问		//!System.out.println(i3); protected变量无法在不同包的非子类访问		System.out.println(a.i4);//public变量可以在任何地方访问		//!a.a(); private方法只能在本类访问		//!a.b(); 包访问权限方法只能在同包访问		//!c(); protected方法无法在不同包的非子类访问		a.d();//public方法可以在任何地方访问	}}

面试题：

1.面向对象和面向过程的区别？

答：它们都是解决具体问题的思维方式。面向过程就是分析出解决问题的所有步骤，然后用函数把这些步骤依次实现，使用的时候依次调用就可以了。面向对象是把构成问题的事物抽象成各个对象，创建对象的目的不是为了完成一个步骤，而是为了描叙某个事物在解决问题过程中的行为。

2.面向对象的特征？

答：抽象：抽象是将一类事物的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

封装：我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对属性和行为的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口

继承：继承是在原有的类的基础上建立一个新类，新类不仅包含原类的所有内容，也加入了一些新的特性。

多态：多态性简单的说就是用同样的引用调用同样的方法但是做了不同的事情。多态分为编译时多态和运行时多态，方法重载实现了编译时多态，方法覆盖实现了运行时多态（通过动态绑定实现）。要实现运行时多态的两个必要条件：方法覆盖和向上转型。

3.权限修饰符区别？

答：public可以被所有包访问，默认权限可以被同包访问，protected权限可以被同包及不同包子类访问，private只能被本类访问。

秒客网

学习笔记之JavaSE（10）--面向对象编程1

二、类与对象

三、封装

四、权限修饰符

相关文章