面对对象思想

一。面对对象定义：
1。面向对象的三个特征：
a：继续
b：多态
C：封闭
2。相关的说明
引用: 
概述面向对象设计（Java） 
(如今的程序领域，大家都在说，面向对象OOP,但是真正能理解面向对象的含义的程序员却很少，究竟什么是对象，怎样面向对象)
一．面向对象：
1.何谓对象：在面向对象程序设计中，我们将问题空间中的元素以及他们在方案空间中的的表示物称作对象（object）
Alan Kay总结了smalltalk中对象的5大基本特征：
所有的东西都是对象。
程序是一大堆对象的集合，他们通过消息传递，各个对象之间知道要做些什么。
每个对象都分配有自己的存储空间，可容纳其他对象。
每个对象都有一个类型。
同一类的所有对象能接收相同的消息。
-----而所有的编程语言的最终目的是提供一种抽象方法----
2．对象的接口：我们向对象发出请求是通过它的接口定义的，对象的类型决定了它的接口形式。
3．OOP中唯一关心的： 就是接口是什么，就像汽车的发动机一样，我们不必要知道它的结构是什么，只要它能工作就行了。所有的程序是由一定的属性（数据）和行为（方法）组成的，不同的对象访问通过函数调用来完成，对象间的所有交流都是通过方法调用，通过对封装数据对象，很大程度上提高复用率。
4．对象的3个主要特征：
behavior—说明这个对象能做什么。
State—当对象施加方法时对象的反映。
Identity---与其他相似行为对象的区分标志，每一个对象有唯一的indentity, 而这3者是相互影响的。
5．面向对象中最重要的思想 就是类，类是模板是蓝图，从类中构造一个对象，即创建了一个类的实例。（类好比一个建材市场，其中有许多子类--各种各样的装饰材料，而我们装修自己的房子就要选择我们需要的材料，（为了建立我们自己的程序，我们必须选 择我们需要的类）这个比喻可以很形象的解释类是什么。
6．类之间的关系：
依赖关系：use-a A类中的一个方法操作了另一个类中的对象。
聚合关系：has-a A类中的对象包含B类的对象。
继承关系：is-a A继承了B类，此时A类不仅有了B类的方法，还加入了自己的方法。以便我们创建我们自己需要的对象。
Java中定义的每一个类都必须继承另一个类，使用关键字extends，如果一个类在定义中不现实使用关键字extends,这个类就会隐式继承Object类。Object类又叫根超类，或基类。，我们从根超类继承来的叫子类。Java中每个类都是根超类的子类。
8．接口（interface）规定了可对特定的对象发出哪些请求。
9．继承=重新使用接口：创建出一个数据类型后，当需要新建立一个数据类型去实现相同的功能，是很没有意义的一件事，此时对其克隆后，再根据情况改进实现自己的目的就是继承。
10．封装：就是把数据和行为结合在一起在一个包中，并对对象使用者隐藏数据的实现过程。Java用3个关键字来设置边界，从而进行对数据的隐藏。Public(共有)的定义任何人都可使用.private（私有）意味着除你自己，类型创建者及那个类型的内部函数成员可以访问外其他任何人使用都会产生错误。Friendly（友好）
意味在包(package)中是可以访问的。（以上过程也可叫方案隐藏）
11．引用（Handle）操控对象：
当创建一个引用时必须要对其进行初始化
例: String s=”happy”（未建立连接）
String s=new string(“happy”)与一个新的对象连接使用new 。此句建立了一个引用，并且连接引用并初始化对象 赋值字符串“happy”.
12.对象的创建及存在时间：数据存放的地点
1：寄存器-速度快，数量少，在cpu内部，我们对寄存器没有控制权。
2：堆栈：驻留长规内存中，堆栈指针下移建立新的内存，上移释放内存。
3：堆：常用内存池，保存对象，有极大的灵活性，java的数据就存放在此，但是要以时间及效率为代价。Java的对象建立是在程序运行时才决定。而c++是在设计时建立对象。
对象的生存时间（lifetime）java提出的垃圾收集器可以很好的发现无须再用的对象，使用GC（grabage collector）垃圾收集器。清除对象，释放内存。
为此我们就要付出一定的运行期的开销。
13.在此我们就会有这样一个印象,一个程序只是一系列对象的集合,他们的方法将其他对象作为自己的变量使用.
14.主要类型: java的主要类型有:boolean,char,byte,short,int,long,float,double,void.这些主类型的大小都不随机器的结构变化而变化,提供了java很好的可移植性.
15.字段方法:字段又叫数据成员,成员函数又叫方法,java的全部工作就是定义类,制作累得对象及发送消息.
16.一个程序只是一系列对象的集合,他们的方法将其他的对象作为自己的变量使用,而且将消息发给那些对象.
17.名字的可见性:为了使名字不重复,作者可以定义自己的库,一般用自己域名的倒写形式 如: COM.:Leeak.utility.foidles
18.static关键字:即使没有创建对象,也需要一愕能调用的方法,此时可以使用static
19.java.lang默认自动的导入每个java程序中
20.OOP中对象使对属性和方法的封装,对象具有信息的隐蔽的性质,对细节的隐藏,对象只需要知道去这样做,而不知道如何做的细节,类的方法应谨慎控制对java数据的访问,可以用get读取方法,用set修改方法.
21:pakage:Java API中每个类和接口属于一个特定的包,包实际上市对类和接口进行组织的目录结构,提供了一种软件复用机制.
22.创建可复用的类得步骤:1.定义一个public类
2.选择一个包名,并把pakage语句加到可复用的类的源码中.
3.编译这个类.
4.把可复用的类导入其他程序中即可.
23.java中提出在类定义的括号外的仅有2个语句,pakage和import.
24.软件的复用性,软件的复用性就是利用紫的已有的,定义良好的的经过仔细测试的文档清晰的可移植的易于获得的软件构件开发新的软件.
2。类和对象
（1）。类（class）是抽象的，概念上的定义，而对象才是实在存在的，也称为类的实例（Instance）；举一个不是很恰当的例子，类相当于模具，而对象才是由于模具生产出来的产品。
（2）。类包括变量和函数，变量定义类的属性，函数定义类的行为。
引用: 
class Person
{
    int age;//类成员定义类的属性
    void shout()//类方法定义类的行为
    {
        System.out.println("Person class");
    }
}
3。类对象的产生和作用
（1）对象生成 
引用: 
Person p1 = new Person();
p1是Person 关的一个引用！产生对象后，成员变量自动赋值：
byte short int 全部为“0”，long为“0.0.L”， float为“0.0F”，char为"/u0000"表示为空，boolean为false。
看一个例子：
引用: 
class Person
{
    int age;
    void shout()
    {
        System.out.println(age);
    }
}
class TestPerson
{
    public static void main(String [] args)
    {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.age=30;
        p1.shout();
        p2.shout();//默认赋值为0
    }
}
（2）对象成为垃圾的几种情况
a：代码执行完后，离开作用域外后，成为垃圾
引用: 
Person p1 = new Person();
.
.
.
b：p1.null即p1为空成为垃圾
引用: 
Person p1 = new Person();
p1.null
.
.
.
c：这情况不成为垃圾
引用: 
Person p1 = new Person();
Person p2 = p1;
p1.null;
.
.
.
（3）对象的比较即“==”和“equals”的区别
a：“==”比较内存地址是否为同一地址，而“equals”只是引用的具体内容或者是值。
看例子：
引用: 
class Compare
{
     public static void main(String[] args)
     {
            String str1 = new String("abc");
            String str2 = new String("abc");
            String str3 = str1;
            if(str1==str2)
                System.out.println("str1==str2");
            else
                System.out.println("str1!=str2");    
            if(str1==str3)
                System.out.println("str1==str3");
            else
                System.out.println("str1!=str3");    
    }
}
//str1 == str3
//str1 != str2
//“abc”只是引用变量指向内存地址的值！
引用: 
class Compare
{
     public static void main(String[] args)
     {
            String str1 = new String("abc");
            String str2 = new String("abc");
            String str3 = str1;
            if(str1.equals(str2))
                System.out.println("str1 equal str2");
            else
                System.out.println("str1 not equal str2");    
            if(str1.equals(str3))
                System.out.println("str1 equal str2");
            else
                System.out.println("str1 not equal str3");    
    }
}
//str1 equal str2
//str1 equal str2
//判断引用变量指向存储在内存当中的具体值，而非判断引用变量是否指向为同一内存地址
（4）匿名对象
引用: 
Person p1= new Person()
p1.shout()
修改成：
引用: 
new Person().shout()
使用匿名对象一般有两种：
a：只调用一次
b：将匿名对象做一个实参传递给函数
4。类的封装
类的封装是指在一个类中将成员变量声明为private，然后通过公用方法来修改和输出这个成员变量，外部类能过这两个函数来操作该成员变量，这就是类的封装。
注：private只是被本类中访问无法被外部类访问
引用: 
class Person
{
    private int age;//静态成员变量
    public void setAge(int i)//公用输入函数
    {
        if(i130)
            return;
        age = i; 
    }
    public int getAge()//公用输出函数
    { 
        return age;
    }
}
public class TestPerson//外部类
{
    public static void main(String args[])
    {
        Person p1 = new Person();
        p1.setAge(3);
        p1.setAge(-6);
        System.out.println(p1.getAge());
    }
}
封闭的作用：
a：隐藏类的细节
b：数据检查
c：便于修改，增加代码可维护性
d：限制对发生不合理的访问
二。构造方法
1。定义
引用: 
class Person
{
public Person()//构造方法
{
        System.out.println("the constructor 1 is calling!");
    }
    private int age = 10;
    public void shout()
    {
        System.out.println("age is "+age); 
    }
}
class TestPerson
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        p1.shout();
        Person p2=new Person();
        p2.shout();
        Person p3=new Person();
        p3.shout();
    }
}
构造方法的特征：
a：与类名相同的函数并以public修饰
b：不含返回值，不能使用return
2。重载
引用: 
class Person
{
    private String name="unknown";
    private int age = -1;
    public Person()
    {
        System.out.println("constructor1 is calling");
    }
public Person(String n)
    {
name = n;
System.out.println("constructor2 is calling");
        System.out.println("name is "+name);
}
    public Person(String n,int a)
    {
name = n;
age = a;
System.out.println("constructor3 is calling");
        System.out.println("name and age is "+name+";"+age);
}
public void shout()
     {
         System.out.println("listen to me!!"); 
        }
}
class TestPerson
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        P1.shout();
        Person p2=new Person("Jack");
        P2.shout();
        Person p3=new Person("Tom",18);
        P3.shout();
    }
}
注：
定义多个构造方法不要忘记把类默认的构造方法增加上，因为你定义了一个非默认的构造方法，那么java就会忽略掉默认的构造方法，所以要补上
三。this用法
最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：
引用: 
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
setAge(age);
this.print();
} 
public void setName(String name){
this.name=name;//此处必须指明你要引用成员变量
}
public void setAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" Age="+age);//在此行中并不需要用this，因为没有会导致混淆的东西
}
public static void main(String[] args){
DemoThis dt=new DemoThis("Kevin","22");
}
}
又热又累呀，剩下的周末再说吧！
继续：
四：函数参数传递
来看一个例子：
引用: 
class Passvalue
{
    public static void main(String [] args)
    {
        int x = 5;
        change(x);
        System.out.println(x);
    }
    public static void change(int x)
    {
        x = 3;
    }
}
注：结果为5，基本类型的变量做为实参传递时，并不改变这个变量的值
来看一个例子：
引用: 
class PassRef
{
    int x ;
    public static void main(String [] args)
    {
        PassRef obj = new PassRef();
        obj.x = 5;
        change(obj);
        System.out.println(obj.x);
    }
    public static void change(PassRef obj)
    {
        obj.x=3;
    }
}
再看这个例子：
引用: 
class PassRef
{
    int x;
    public static void main(String [] args)
    {
        PassRef obj = new PassRef();
        obj.x = 5;
        change(obj);//这里的调用并不会改变其自身的值
        System.out.println(obj.x);        
    }
    public static void change(PassRef obj)
    {
        obj = new PassRef();//与上一个例子这里不同，创建了一个新的引用.
        obj.x=3;
    }
}
五。static说明
1。static的变量 
我们定义了一个类，在定义了属性和行为，此时并没有什么对象的产品，需要new出来的，在变量上加上static不需要new就可直接使用。
看例子：
引用: 
class Chinese
{
    static String country="中国";
    String name;
    int age;
    void singOurCountry()
    {
        System.out.println("啊！，亲爱的" + country);
        //类中的成员方法也可以直接访问静态成员变量
    }
}
class TestChinese
{
    public Static void main(String [] args)
    {
        System.out.println("Chinese country is " + Chinese.country);
        //上面的程序代码直接使用了"类名.成员"的格式
        Chinese ch1 = new Chinese();
        System.out.println("Chines country is " + ch1.country);
        //上面的程序代码直接使用了"对象名.成员"的格式
        ch1.singOurCountry();
    }
}
注：方法中不可以使用static
2。static静态方法
引用: 
class Chinese
{
    static void Sing()
    {
        System.out.println("啊!");
    }
    void SingourCountry()
    {
        Sing();//直接访问方法名
    }
    
}
class TestChinese
{
    public static void main(String [] args)
    {
        Chinese.Sing();
        //类名加方法名
        Chinese ch1 = new Chinese();
        ch1.Sing();
        //对象名加方法名        
    }
}
注：
a：在静态方法中只能调同类中静态变量
b：静态方法不能以任何方式引用this和super关键字
3。static静态代码
看代码：
引用: 
class StaticCode
{
    static String country;
    static
    {
        country = "china";
        System.out.println("StaticCode is loading");
    }
}
class TestStaticCode
{
    static
    {
        System.out.println("TestStaticCode is loading");
    }
    public static void main(String [] args)
    {
        System.out.println("begin executing main method");
        new StaticCode();
        new StaticCode();
    }
}
注：
静态代码只被执行一次
六。单态设计模式
单态设计模式就是在通过一些方法，保证一个类中只产生一个一个对象
代码如下：
引用: 
class TestSingle
{
    private static final TestSingle onlyone = new TestSingle();
    public static TestSingle getTestSingle()
    {
        return onlyone;
    }
    private TestSingle()
    {
        
    }
}
六：内部类
1：类中定义内部类
代码：
引用: 
class Outer
{
    int outer_i = 100;
    void test()
    {
        Inner in = new Inner();
        in.display();
    }
    class Inner
    {
        void display()
        {
        System.out.println("display: outer_i = " + outer_i);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.test();
    }
}
注：
a：
存在A类与B类
A->使用B类的实例对象
B->A类使用B类的成员变量
b：
B类可以访问到A类的成员，反之不成
c：
内部类只需要以public修饰将会被外部类所调用
d：
方法中定义内部类只能访问方法中final，final定义的局部变量相当于定义了一个常量