黑暗程序员--javaSE--java面向对象

java中的面向对象是一个比较烫手的问题，说他难吗，理解起来也就那么回事，说他不难吗，真正在实际中应用时却
也能让人摸不着头脑，Thinking in java 中说万事万物皆对象，但对于这句话的真正理解我想我还是不够的，不过还好张老师在
讲解7k交通系统的面试题时，对面向对象的思想又做了一次加深，并给出了几个例子，在这篇博客的开始，我想先谈一下我对这两道题的
分析和代码实现，算是对java面向对象的一个加深吧。

面向对象设计把握一个重要的经验：谁拥有数据，谁就对外提供操作这些数据的方法。
两个面向对象的面试题，用面向对象的方式设计如下情景。
题目一：“两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材做成椅子”。
题目二：“球从一根绳子的一段移动到了另一端”。

对于题目一：
分析：题目中包含的对象有两个，一个是绳子Rope，一个是小球Ball；
小球所在的位置需要有一个坐标来记录，所以在定一个点类Point；
点属于绳子，另外小球的移动就是点的移动，所以绳子拥有一个方法即
nextPoint()（可以通过定时器设置这个方法），而小球需要知道的就是自己当前所处的位置，
即要拥有一个当前坐标的引用currentPoint；
小球依赖于绳子，所以在小球的成员变量中要有一个绳子对象，并通过构造方法说明小球依赖于哪根绳子和在绳子上的
当前位置；
绳子是有长度的，长度用两点来记录，一个是起始点 Point start，一个是结束点 Point end，并通过构造方法指定。
最后根据上述分析，给出此道题目的面向对象的设计代码：

class Rope
{
	private Point start;
	private Point end;
	public Rope(Point start,Point end){
		this.start = start;
		this.end = end;
	}

	public Point nextPoint(Point currentPoint){
		/*
		通过两点一线的数学公式可以计算出当前点的下一个点，
		如果当前点是终止点，则返回null，如果当前点不是线上的点，
		则抛出异常
		*/
	}
}

class Ball
{
	private Rope rope;
	private Point currentPoint;
	public Ball(Rope rope,startPoint){
		this.rope = rope;
		this.currentPoint = startPoint;
	}

	public void move(){
		currentPoint = rope.nextPoint(currentPoint);
		System.out.println("小球移动到了"+currentPoint);
	}
}

class Point 
{
	private double x;
	private double y;
	public Point(int x,int y){
		this.x = x;
		this.y = y;
	}

	public double getX(){
		return this.x;
	}
	public void setX(double x){
		this.x = x;
	}
	
	public double getY(){
		return this.x;
	}
	public void setY(double x){
		this.x = x;
	}
}

对于题目二：
分析：这道题目中所涉及的类有，石头：Stone，石刀：StoneKinife,树：Tree，木材：Wood,椅子：chair,
石头磨成石刀，这个方法不能在石头中，因为石头变成了石刀，本身即不存在了。需要再创建一个石刀的工厂类，
KnifeFactory,类中有将石头变成石刀的方法 public static StoneKnife createKnife(Stone first,Stone second)（因为是两个石头加工成一个石刀）。
石刀把树变成木柴，所以这个类中有一个 public Wood cut(Tree tree)的方法；
同理木柴被加工成椅子，这里也是用一个工厂类ChairFactory，类中有将木柴变成椅子的方法 public static Chair createChair(Wood wood);
具体的代码实现：

//定义石头类
class Stone{
	
}
//石刀类
class StoneKnife{
	//砍树的方法
	public Wood cut(Tree tree){
	
	}
}
//石刀工厂类
class KnifeFactory{
	//将石头加工成石刀
	public static StoneKnife createKnife(Stone first,Stone second){
	
	}
}
//树类
class Tree{

}
//木柴类
class Wood{

}
//椅子类
class Chair{

}

//椅子加工场类
class ChairFactory
{
	//将木柴加工成椅子
	public static Chair createChair(Wood wood){
	}
}

个人感觉这两道题非常重要，也请读者重点注意一下。好了，说完了面试题，下面就开始具体谈谈，java中的面向对象吧，
因为java面向对象这个模块的只是很繁杂，所以我是以知识点介绍的，想到哪说到哪。

面向对象和面向过程一样都是一种编程思想，面向过程强调的是功能行为，典型的编程语言就是c语言，而面向对象是
基于面向过程的，他是将功能封装进对象，强调具备了功能的对象，典型的编程语言有c++，java等。
面向对象的特点：
1、是一种符合人们思考习惯的思想
2、可以将复杂的事情简单化
3、将程序员从执行者转变成了指挥者
4、完成需求时：先要去找具有所需的功能的对象来用。如果该对象不存在，那么就创建一个具有所需功能的对象，这样简化开发并提高复用。

面向对象开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
面向对象设计的过程：其实就是在管理和维护对象之间的关系。
面向对象的三大特征：封装（encapsulation）,继承（inheritance）,多态（polymorphism）

下面就这三个特征介绍相关的知识点。

封装：
先了解一下类与对象：java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
对象即是该类事物实实在在存在的个体。
封装：封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：将变化隔离，便于使用，提高重用性，提高安全性。
封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

继承：
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。class SubDemo extends Demo{}
继承的出现提高了代码的复用性。继承的出现让类与类之间产生了关系，提供了多态的前提。
继承的特点:Java只支持单继承，不支持多继承。Java支持多层继承(继承体系)
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
a.实现继承是指使用基类的属性和方法而无需额外编码的能力；
b.接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
c.可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，
因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

多态：
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，
父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的引用赋值给父类类型的引用。
实现多态，有二种方式，覆盖，重载。
覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，
然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：void func(int num),void func(String str)。
那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。
也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，
父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。
因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。
而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
（说明，上面对于多态的解释是在我上摘抄的，因为我感觉这段文字对于多态的分析给很透彻，所以笔者就不再卖弄自己的那点油墨了-。。-）
多态的特点：
成员函数：
编译时：要查看引用变量所属的类中是否有所调用的成员。
在运行时：要查看对象所属的类中是否有所调用的成员。
成员变量：
只看引用变量所属的类。

接着在说一下关于java面向对象的一些具体的知识点;

抽象类:抽象就是从多个事物中将共性的，本质的内容抽取出来。Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
抽象类的特点:抽象类和抽象方法必须用abstract关键字来修饰。
抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符 abstract 返回值类型   函数名(参数列表) ;
抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：
抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
而且抽象类即使创建了对象，调用抽象方法也没有意义。
抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类.

接口：类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。接口与接口之间可以有继承关系。
格式：interface {}
接口的特点：接口是对外暴露的规则。接口是程序的功能扩展。接口的出现降低耦合性。接口可以用来多实现。

内部类：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
内部类的位置：
内部类定义在成员位置上
可以被private static成员修饰符修饰。
被static修饰的内部类只能访问外部类中的静态成员。
内部类定义在局部位置上
也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。

对于内部类，在这里我说一下我在做黑马的java基础测试时遇到的一个题目（当时没做出来，后来靠度娘搞定）
在打印语句中如何打印这3个x变量？
 
class A {
    int x = 1;
 
    class B {
        int x = 2;
 
        void func() {
            int x = 3;
            System.out.println( ? );
        }
    }
}
难点是对于外部类A中成员变量的访问
答案有两个：new A().x或者是A.this.x

匿名内部类：
就是内部类的简化写法。
前提：内部类可以继承或实现一个外部类或者接口。
格式为：new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。

员变量和局部变量的区别：
成员变量：
成员变量定义在类中，在整个类中都可以被访问。
成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
成员变量有默认初始化值。
局部变量：
局部变量只定义在局部范围内，如：函数内，语句内等。
局部变量存在于栈内存中。
作用的范围结束，变量空间会自动释放。
局部变量没有默认初始化值。

函数覆盖：
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。
覆盖注意事项：
覆盖时，子类方法权限一定要大于等于父类方法权限
静态只能覆盖静态。
覆盖的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

关于java面向对象的几个重要的关键字：

this：
特点：this代表其所在函数所属对象的引用。换言之：this代本类对象的引用
当在函数内需要用到调用该函数的对象时，就用this。

super:
super和this的用法相像,this代表本类对象的引用,super代表父类的内存空间的标识。
当子父类出现同名成员时，可以用super进行区分,子类要调用父类构造函数时，可以使用super语句。

final:
nal可以修饰类，方法，变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量

static(静态):
static关键字：
用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：
a.随着类的加载而加载
b.优先于对象存在
c.被所有对象所共享
d.可以直接被类名调用
使用注意:静态方法只能访问静态成员,静态方法中不可以写this，super关键字,主函数是静态的

利用静态，在这里我想简单的说一个java常用的设计模式，单例设计模式。

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

如果保证类在内存中只有一个对象呢？
(1)控制类的创建，不让外部类来创建类的对象。private
(2)在本类中定义一个本来的对象。Student s;
(3)提供公共的访问方式。  public static Student getInstance(){return s}

代码实现：

单例写法两种：
(1)饿汉式 开发用这种方式。
class Student
{
	private Student(){}
	private static Student s = new Student();
	public static Student getInstance()
	{
		return s;
	}
}
(2)懒汉式 面试写这种方式。
class Student
{
	private Student(){}
	private static Student t;
	public static Student getInstance()
	{
		if(t==null)
		{
			t = new Student();
		}
		return t;
	}
}

但是方式一也就是恶汉式是在对象没有使用前就将对象加载到了类中，造成资源的浪费，
方式二虽然优化了这个缺点，但却存在线程安全的问题，需要对public static Student getInstance()加锁，
也就是将恶汉式改写为：

class Student
{
	private Student(){}
	private static Student t;
	public synchronized  static Student getInstance()
	{
		if(t==null)
		{
			t = new Student();
		}
		return t;
	}
}