面向对象

面向对象＝数据＋方法
进一步理解为
程序＝对象＋消息传递＝(数据＋方法)＋消息传递

面向对象
————————————————————————
类

1，将具有相同属性及行为的一组对象称为类。
2， 广义上讲，具有共同性质的事物的集合就称为类。在面向对象程序设计中，类是一个独立的单位，它有一个类名，其内容包括成员变量，用于描述对象属性;还包括类的成员方法，用于描述对象的行为。在Java程序设计中，类被认为是一种抽象的数据类型，这种数据类型不但包括数据，还包括方法，这大大扩充了数据类型的概念。
3，类是一个抽象的概念，要利用类来解决问题，必须用类来创建一个实例化的对象，然后通过对象去访问类的成员变量，去调用类的成员方法来实现程序的功能。
4， 一个类可以创建多个对象，它们具有相同的属性模式，但可以具有不同的属性值。Java程序为每一个对象都开辟了内存空间，以保存各自的属性值。

————————————————————————
对象
1， 对象是类实例化后的产物。
2，对象分为静态特征和动态特征两种。静态特征指对象的外观，性质，属性等。动态特征指对象具有的功能，行为等。
3，人们将对象的对象的静态特征抽象为属性，用数据来描述，在Java中称之为变量；将对象的动态特征抽象为行为，用一组代码来表示，完成对数据的操作，在Java中称之为方法。
4，一个对象由一组属性和一系列对属性进行操作的方法构成。

面向对象
面向对象

————————————————————————
类的声明
使用类之前，必须先声明它，才可以声明变量，并创建对象语法例
[标识符] class 类名称
{
//类的成员变量
//类的方法
}
标识符可以是public private protected或者省略这个修饰符。类的标识符可以是访问控制符。Java提供了一系列的访问控制符来设置基于类，变量，方法及构造方法等不同等级的权限，

访问权限	作用
默认模式default	在默认模式下，不需为某个类，方法等不加任何修饰符。这类声明的方法和类，只允许在同一个包内是可以访问的
private私有	这是Java语言中对访问最严格的修饰符。如果一个方法，变量和构造方法被声明为"私有"访问，那么它仅能在当前声明它的类内部访问。类和接口的访问方式是不能被声明为私有的。
public公有	这是Java语言访问权限最宽松的修饰符。如果一个类，方法和构造方法和接口等被声明为"公有"访问，那么它不仅可以跨类访问，而且允许跨包访问。如果需要访问其他包里的公有成员，则需要事先导入那个包所含所需公有类，变量和方法等的那个包
protected保护	介于public和private之间的一种访问修饰符。如果一个变量，方法和构造方法在父类中声明为"保护"访问类型，只能被类本身的方法及子类访问，即使子类在不同包中也可以访问。类和接口的访问方式是不能声明为保护类型的。

类的标识符除了public，protected，private和default这四个访问控制符，还可以是final。关键字"final"有"无法改变的"或者"终态的"含义。一个类一旦被声明为final，那么这个final类不能被继承，因此final类的成员方法没有机会被覆盖，默认情况下类都是default的。在设计类的时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不在被拓展，那么就设计为final类。

————————————————————————
类的组成使用
1 class Person
2 {
3 String name;
4 int age;
5 void talk()
6 {
7 System.out.println("我是："+name+"，今年："+age+"岁。");
8 }
9 }
程序首先用class声明了一个名为Person的类，在这里Person是类的名称。
三四行声明了两个属性(即描述数据的变量)name和age，name为String(字符串)型;age为int(整型)。
5到8行声明了一个talk()方法——操作数据(如name和age)的方法，此方法向屏幕打印信息。
————————————————————————
静态属性（方法），也就是用static修饰的，还是实例属性（方法）
举例，有个类C,有静态属性a,静态方法a()，还有实例属性b和实例方法b()
静态属性的调用：C.a
静态方法的调用：C.a()
实例属性的调用
C c = new C();
c.b
实例方法的调用：
C c = new C();
c.b();
————————————————————————
属性的使用

class usingAttribule
{
    static String a="String  a";
    static String b;

    String c="String  c";
    String d;
    //static语句块用于初始化static成员变量，是最先运行的块
    static
    {
        //printStatic()调用相应的方法
        printStatic("静态属性初始值");
        b="String  b";
        printStatic("静态属性修改后的值");
    }
    //输出静态成员变量
    public static void printStatic(String title)
    {
        System.out.println("----"+title+"----");  //title是将自身变成printStatic内内容
        System.out.println("a=\""+a+"\"");
        System.out.println("b=\""+b+"\"");
    }
    public usingAttribule()    //这里是构造方法
    {
        println("所有属性改变前");
        d="string  d";
        println("所有属性改变后");
    }
    //打印所有属性，包括静态成员
    public void println(String title)  //定义公有方法println()用于打印所有属性值，包括静态成员值
    {
        System.out.println("----"+title+"----");
        System.out.println("a=\""+a+"\"");
        System.out.println("b=\""+b+"\"");
        System.out.println("c=\""+c+"\"");
        System.out.println("d=\""+d+"\"");
    }
    public static void main(String args[])
    {
        System.out.println();
        System.out.println("----创建usingAttribute对象----");
        System.out.println();
        new usingAttribule();  //使用new关键词和构造方法usingAttribute()来创建一个匿名对象
    }
}

————————————————————————
对象的声明

类名 对象名 ＝ new 类名（）;
例子

Person p;            //先声明一个Person类的对象p。
p = new Person();    //用new实例化Person的对象p。

简便写法例
Person p = new Person;

对象的使用

对象名称.属性名 //访问属性
对象名称.方法名() //访问方法

例 假如访问Person类中name和age属性
p.name; //访问Person类中的name属性
p.age; //访问Person类中的age属性

若想将Person类的对象p中的属性name和age赋值，例

p.name = "张三";
p.age = "20"

如果想调用Person中的talk方法，例
p.talk(); //调用Person类中的talk()方法

class Can
{
    public static void main(String args[])
    {
        Person p=new Person();
        p.name="张三";
        p.age=20;
        p.talk();
    }
}
class Person
{
    String name;
    int age;
    void talk()
    {
        System.out.println("姓名，"+name+"。年龄，"+age);
    }
}

---

创建匿名对象

class Can
{
public void talk()
{
System.out.println("面朝大海，穿暖花开");
}
public static void main(String args[])
{
//这是匿名对象，没有被其他对象所引用
new Can().talk();
}
}

“new Can()”是创建匿名对象的意思，所以就用“new Can()”整体
来作为新构造匿名对象的引用，它访问类中的方法，
就如普通对象一样使用符号点“ . ”:Can().talk();

匿名对象的特点
1，匿名对象是没有被其他对象所引用，即没有栈内存指向。
2，由于匿名对象没有栈内存指向，所以只能使用一次，之后变成无法寻回的垃圾对象，故此会被垃圾回收器收回。

---

对象的比较
对象比较有两种方法1种利用==运算符，==运算符比较的是对象内存地址是否相同；2种是用equals()方法，equals()
方法比较的是对象内容是否相同。

class Dui
{
    public static void main(String args[])
    {
        String a=new String("java");
        String b=new String("java");
        String c=b;
        if(a==b)
        {
            System.out.println("a==b");
        }
        else
        {
            System.out.println("a!=b");
        }
        if(b==c)
        {
            System.out.println("b==c");
        }
        else
        {
            System.out.println("b!=c");
        }
        }
}

//由于  ==  运算符比较的是内存地址所以a！=b

class Dui
{
    public static void main(String args[])
    {
        String a=new String("java");
        String b=new String("java");
        String c=b;
        if(a.equals(b))
        {
            System.out.println("a==b");
        }
        else
        {
            System.out.println("a!=b");
        }
        if(b.equals(c))
        {
            System.out.println("b==c");
        }
        else
        {
            System.out.println("b!=c");
        }
        }
}

//由于equals()比较的是内容，所a==b

---

对象数组的使用

我们可以吧类理解为用户自定义的数据类型，他和基本数据类型(如int，float等)具有相同的地位。对象数组存放。声明以类为数据类型的数组变量，并用new分配内存空间给数组。用new产生新的对象，并分配内存空间给它。例

p = new Person[3]   用new分配内存空间
创建数组以后便可吧数组元素指向由Person类所定义的对象
p[0]=new Person();
p[1]=new Person();
p[2]=new Person();```


简便方式
```Person p[]=new Person[3]```

**动态初始化数组**
```for(inti=0;i<p.length;i++)
p[i]=new Person();```

**静态初始化数组**
```Person p[]={new Person(),
new Person(),new Person()};```

----------------------------------------------------------------------
**用静态方法初始化数组**

class Person
{
String name;
int age;
public Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String talk()
{
return "姓名："+name+"。年龄："+age;
}
}
class Can
{
public static void main(String args[])
{
Person p[]={
new Person("张三",20),
new Person("李四",23),
new Person("王五",25)
};
for(int i=0;i<p.length;++i)
{
System.out.println(p[i].talk());
}
}
}

**this关键词**  当创建一个对象后，Java虚拟机就会给这个对象分配一个自身的引用，由于this是和对象本身关联的，所以this只能在类中非静态方法中使用。静态属性和静态方法属于类，他们与具体的对象无关，所以静态属性及方法没有this，同一个类下定义的不同对象，每个对象都有自己的this，虽然豆角this，但指向对象不同

------------------------------------------------------------------
**方法重载**
重载注意事项
1，方法名称相同。
2，方法的列表参数不同(参数个数,参数类型,参数顺序,至少有一项不同)
3，方法的返回值和修饰符不做要求哦，可以相同也可以不同。

class Method
{
public int can(int a,int b)
{
return a+b;
}
public float can(float a,float b)
{
return a+b;
}
public int can(int a,int b,int c)
{
return a+b+c;
}
public static void main(String args[])
{
int i;
float f;
Method m=new Method();
i=m.can(1,2);
System.out.println(i);
f=m.can(1.2f,2.3f);
System.out.println(f);
i=m.can(1,2,3);
System.out.println(i);
}
}

import java.lang.String;
class Method
{
public static void main(String args[])
{
byte a=12;
short b=34;
int c=56;
float d=7.8f;

    System.out.println(String.valueOf(a));
    System.out.println(String.valueOf(b));
    System.out.println(String.valueOf(c));
    System.out.println(String.valueOf(d));
}

}

----------------------------------------------------------------------
**构造方法**
构造方法   就是在每一个类中定义的，并且是在使用关键词new实例化一个新对象的时候默认调用的方法。构造方法主要是对新创建对象的数据成员赋初值。

class 类名称
{
访问权限 类名称(类型1 参数1,类型2 参数2,……) //构造方法
{
程序语句;
…… //构造方法没有返回值
}
}

**构造方法注意**
1，构造方法名称和其所属的类名必须一致。
2，构造方法没有返回值，也不可以用void。
3，构造方法也可以像普通方法一样被重载。
4，构造方法不能被static和final修饰。
5，构造方法不能被继承，子类使用父类的构造方法需要使用super关键字。
构造方法创建对象时就自动“隐式”执行。因此构造方法无需在程序中直接调用，而是对象产生时自动执行一次。通常用它来对对象的数据成员进行初始化。

class Test
{
public static void main(String args[])
{
Person p=new Person(12);
p.show("java构造方法的使用演示");
}
}
class Person
{
public Person(int x)
{
a=x;
System.out.println("构造方法被调用");
System.out.println("a="+a);
}
public void show(String msg)
{
//调用这个方法并给msg赋值。打印方法内容
System.out.println(msg);
}
private int a;
}

----------------------------------------------------------------------
**构造方法的重载**

class Person
{
private String name;
private int age;
public Person(int age) //含有一个整型的构造方法
{
this.age=age;
name="张三"; //只提供一个参数，用"张三"初始化name
}
//含有一个字符串的参数和一个整型参数的构造方法
public Person(String name,int age)
{
this.name=name;
this.age=age;
}
public void talk()
{
System.out.println("姓名，"+name+"。年龄，"+age);
}
}
class Can
{
public static void main(String args[])
{
Person p1=new Person(20);
Person p2=new Person("李四",28);
p1.talk();
p2.talk();
}
}

**无参构造方法使用**

class Can
{
public static void main(String args[])
{
Person p=new Person();
p.talk();
}
}
class Person
{
private String name;
private int age;
public Person()
{
name="张三";
age=20;
}
public Person(int age)
{
name="张三";
this.age=age;
}
public Person(String name,int age)
{
this.name=name;
this.age=age;
}
public void talk()
{
System.out.println("我叫，"+name+"。我今年，"+age);
}
}
//Person类是没有参数，所以必须先用无参构造方法，之后在在构造方法添加参数。

------------------————————----------------------------
**构造方法的私有使用范例**

class Can
{
public static void main(String args[])
{
//声明一个Person类的对象
Person p;
//虽私有化Person类的构造方法，但可以通过Person类公有接口获得Person实例化对象
p=Person.getPerson();
System.out.println("姓名，"+p.name);
}
}
class Person
{
String name;
//在本类声明Person对象PERSON。注意对象用final标记，表示对象不可更改
private static final Person PERSON=new Person();
private Person()
{
name="张三";
}
public static Person getPerson()
{
return PERSON;
}
}

由于Person类构造方法是private，所以如**Person p=new Person()**已经不在行了，只能通过**p=Person.getPerson();**来获取实例，而由于这个实例PERSON是static的，所以全局共享一个，所以无论在Person类外部声明多少个对象，使用多少个**p=Person.getPerson();**。最终得到的实例都是同一个。也就是说，此类只能产生一个实例对象。这种做饭饭叫做**单态模式**，

构造方法私有化演示2
class can
{
public static void main(String args[])
{
Person p;
p=Person.talk();
System.out.println(p.name);
}
}
class Person
{
String name;
private static final Person can=new Person();
public Person()
{
name="张三";
}
public static Person talk()
{
return can;
}
}

——           -----------------------------------------------------
**方法内部调用方法**

class Person
{
private String name;
private int age;
private void talk()
{
System.out.println("woshi"+name+"我今年"+age);
}
public void say()
{
talk();
}
public String getAbc()
{
return name;
}
public void setAbc(String name)
{
this.name=name;
}
public int getDef()
{
return age;
}
public void setDef(int age)
{
this.age=age;
}
}
class can
{
public static void main(String args[])
{
Person p=new Person();
p.setAbc("张三");
p.setDef(20);
p.say();
}
}

---------------------------------------------------------------------
**方法的递归调用**

class Person
{
//非递归方式实现计算1+2+3……+n
public int a(int n)
{
int b=0;
for(int i=1;i<=n;++i)
{
b+=i;
}
return b;
}
//递归方式实现计算1+2+3+……n
public int c(int n)
{
//递归出口，当n小于1时函数就会逐层返回
if(n<=1)
return n;
return n+c(n-1);
}
public static void main(String args[])
{
Person p=new Person();
//调用非递归计算
int b=p.a(10);
System.out.println("非递归计算1+2+3+……+10结果，"+b);
//调用递归方法计算
b=p.c(10);
System.out.println("递归计算1+2+3+……+10结果，"+b);
}
}