面向对象(Object Oriented)

面向对象

面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

package com.xxxx.oop01;
/*
    自定义的类
    对象
    根据类构建对象,类就是模板|图纸
    图纸中定义什么,根据这个类构建的对象中就存在什么

   天使:
    属性: 翅膀个数   姓名     翅膀颜色      善良
    功能:
        拯救
        ..
 */
public class Angel01 {
    // 属性: 翅膀个数   姓名     翅膀颜色      善良
    public String name;
    public int num;
    public String color;
    public boolean kindness;

    //功能:     拯救
    public void save(){
        //打印语句 快捷键  sout->enter
        System.out.println(name+"正在拯救学习java的你们....");  //在成员方法中的成员变量指代调用当前成员方法的那个对象的成员变量值
    }
}

package com.xxxx.oop01;
/*
    天使类测试类
        1.导包  不需要  同包下的类
        2.构建天使类的对象
        3.通过对象使用内容

        注意:
            new关键字能够创建一个对象
            看到new就是一个对象的产生
            可以根据一个类,创建多个对象,根据业务需求
 */
public class AngelTest02 {
    //main方法的快捷键  main->enter   psvm->enter
    public static void main(String[] args) {
        //1.导包  不需要  同包下的类
        //2.构建天使类的对象
        //=右边先创建好一个对象,再赋值给=左边的对应类型的变量
        Angel01 angel = new Angel01();
        Angel01 angel2 = new Angel01();
        //3.通过对象使用内容
        angel.name = "胡歌";
        angel.color="白色";
        angel.num=8;
        angel.kindness = true;

        angel2.name = "彭于晏";
        angel2.color="黑色";
        angel2.num=6;
        angel2.kindness = false;

        angel.save();
        angel2.save();

        //匿名对象 : 只能在当前行使用一次
        //new Angel01().save();
        //new Angel01().name="zhangsan";
        //成员变量之声明不赋值存在默认值  引用数据类型->null  整数->0   小数0.0    boolean->false   char->' '
        System.out.println( new Angel01().name);;
        //又是一个匿名对象  和39行的匿名对象不是一个,因为存在2次new
        System.out.println( new Angel01().num);

        //局部变量的声明 : 只声明不赋值不存在默认值
        int a;
        Angel01 angel3 = null;

        //angel3 = new Angel01();
        System.out.println(angel3);
    }
}

（1）对象唯一性。

每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。

（2）抽象性。

抽象性是指将具有一致的数据结构（属性）和行为（操作）的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。

（3）继承性。

继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。

在类层次中，子类只继承一个父类的数据结构和方法，则称为单重继承。

在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。

多重继承，JAVA、VB、NET、Objective-C均仅支持单继承，注意在C++多重继承时，需小心二义性。

在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重用性。

采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。

（4）多态性（多形性）

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

多态性允许每个对象以适合自身的方式去响应共同的消息。

多态性增强了软件的灵活性和重用性。

构造器

构造器是Java和C#学习中很重要的一个概念，构造器可以提供许多特殊的方法，构造器作为一种方法，负责类中成员变量（域）的初始化。实例构造器分为缺省构造器和非缺省构造器。

构造器与普通方法的区别与联系

相同点：构造器也是Java类中的一种方法。

不同点：

构造器和方法在下面三个方面的区别：修饰符，返回值，命名。

(1)修饰符：和方法一样，构造器可以有任何访问的修饰符： public, protected, private或者没有修饰package（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： final,，static,，abstract，synchronized，native。

(2)返回类型：方法能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。

(3)两者的命名：构造器通常用首字母为大写的一个名词开始命名，并且使用和类相同的名字命名。而方法则不同，方法通常用小写字母英文动词开始，其后跟随首字母为大写的名称、形容词等等组成的驼峰命名方式，方法通常更接近动词，因为它说明一个操作。

package com.xxxx;
/*
    new作用的事情:
        1.在堆中为对象开辟空间,成员变量跟随对象进入到堆内存中,赋默认值
        2.调用构造器为对象初始化信息
        3.将对象的地址返回给引用

    构造器 | 构造函数 | 构造方法

        一个特殊的方法

        作用:
            用来为对象初始化信息(为对象的成员变量赋值)

        使用:
            跟随new关键字使用

        定义:
            修饰符 类名(参数列表){
                ...
            }
            不需要返回值类型不需要void
            可以使用return关键字,可以不使用

       注意:
        如果没有显示定义构造器,编译器会自动为提供一个空构造(没有参数)
        如果存在显示定义的构造器,编译器不会再提供任何构造器了

        构造器是特殊的方法,就可以构成方法的重载->构造器的重载

        构造器不是用来创建对象的,是用来为对象初始化信息的
        可以通过构造器使用创建对象的同时赋值,简化代码结构
        自定义的类型至少提供一个空构造,根据需求提供带参
 */
public class ConstructorDemo {
    public static void main(String[] args) {
        //先创建对象
        Dog dog = new Dog();
        //为成员变量赋值
        dog.name = "旺财";
        dog.type = "二哈";
        dog.color = "黑白";
        System.out.println(dog.name);
        System.out.println(dog.type);
        System.out.println(dog.color);
        dog.bark();

        //创建对象类型后面的()->匹配构造器的参数列表
        Dog dog2 = new Dog("小花");
        dog2.bark();

        //通过带参构造可以实现,在创建对象的时候为对象某些成员变量赋值
        Dog dog3 = new Dog("来福","萨摩");

        dog3.name = "张二狗";
        dog3.bark();
    }

}

class Dog{
    public String name;
    public String type;
    public String color;

    //空构造
    public Dog(){
        System.out.println("空构造");
    }

    //带参构造
    public Dog(String dogName){
        name = dogName;
        System.out.println("一个参数构造");
    }

    public Dog(String dogName,String dogType){
        name = dogName;
        type = dogType;

        System.out.println("2个参数构造");
    }

    //叫
    public void bark(){
        System.out.println(name+"正在叫!!!");
    }
}

this用法

使用关键字this在构造器和方法中有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实例，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器

public class InstanceObject {
String name;
InstanceObject(String input) {
name = input;
}
InstanceObject() {
this("Java language");
}
public static void main(String args[]) {
InstanceObject IO1 = new InstanceObject();
InstanceObject IO2= new InstanceObject();
}
}

在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值 “Java language”.

在构造器中，如果要使用关键字this,那么，必须放在第一行， 否则将导致一个编译错误。

package com.xxxx;
/*
      在方法中 :
                存在方法的局部变量与成员变量的同名的时候,依旧是通过this.指代成员
                在成员方法中this指代调用成员方法的对象
                当没有同名问题时候,指代成员时候,默认省略this.

       注意:
        不要在构造器之间相互调用,可能造成死循环的效果
        成员是属于对象的,需要跟随对象才能使用(成员变量,成员方法)->因为成员变量存在与对象的堆内存中

 */
public class ThisDemo {
    //重载构造器
    public ThisDemo(){
        //调用本类中的其他构造器
        this(false);
        System.out.println("空构造");
    }

    public ThisDemo(int i){
        System.out.println("一个int类型参数构造器"+i);
    }

    public ThisDemo(boolean flag){
        //this();
        System.out.println("一个boolean类型参数构造器"+flag);
    }

    public static void main(String[] args) {
        //创建对象
        ThisDemo demo = new ThisDemo();

        //创建一个小猫对象
        Cat cat = new Cat("张二狗","加菲猫");
        System.out.println("cat指代对象的地址为:"+cat);

        cat.catchMouse();

        System.out.println(cat.name);

        Cat cat2 = new Cat("二愣子");
        cat2.catchMouse();
    }
}


class Cat{
    public String name;
    public String type;
    public String color;

    //构造器
    public Cat(){}

    //构造器中的参数与成员同名问题
    //就近原则
    public Cat(String name){
        this.name = name;
    }

    public Cat(String name,String type){
        this.name = name;
        this.type = type;
        System.out.println(this);
    }

    public Cat(String name,String type,String color){
        //调用奔雷中的其他构造器为name,与type成员变量赋值,因为已经有其他构造器实现了赋值需求,直接调用即可
        this(name,type);
        this.color = color;


    }

    //抓老鼠
    public void catchMouse(){
        String name = "zhangsan";
        //在成员方法中,this指代调用当前成员方法的对象
        System.out.println(this.name+type+"正在捉老鼠");
    }
}

this 关键字
this指代当前对象(new的对象)
使用:
1.构造器的首行,通过this(实参)调用本类中的其他构造器
this(实参)
2.区分同名变量问题 ->局部与成员之间同名问题
默认就近原则的
在构造器中 :
局部变量->方法的形参,方法内部自定义的局部变量
成员变量同名时候: this.变量名->成员变量
this指代当前new的对象,在new某一个对象的时候,才会调用执行的构造器进行初始化信息,this就指代哪一个对象