Java从入门到入土|day06-面向对象

一、什么是面向对象

面向对象是一种编程思想，与面向过程相对。面向过程注重某一件事的步骤及顺序，而面向对象更注重处理某件事的模块和对象。比如，人看书这件事，面向过程的处理过程为：找到书->打开书->阅读；而面向对象的处理过程为：把这件事拆分成人和书这俩对象，在分析每个对象所需要做的事情：人：找书、打开书、阅读；书：提供信息。

面向对象的三大支柱：封装、继承和多态

二、方法的调用

对方法的调用分为静态调用和非静态调用。

静态调用：即所写的方法前加了一个static属性,调用格式：类名.方法名

例如：在Add类中定义了一个add方法来实现两数相加，在Test类中进行调用

①静态调用

public class Add {
    public static int add(int a,int b){   //用static定义
        return a+b;
    }
}

调用：

public class Test {
    public static void main(String[] args) {
        int sum=Add.add(2,6);
         System.out.println(sum);
    }
}

②非静态调用：

public class Add {
    public int add(int a,int b){  //注意此时没有static属性
        return a+b;
    }
}

调用：

public class Test {
    public static void main(String[] args) {
        Add add=new Add();
    // 将Add中的方法实例化，可理解为将Add方法赋给此处的add
        int sum=add.add(2,6);
         System.out.println(sum);
    }
}

三、类和对象的创建

类直接创建，不做过多解释。创建对象用new来实例化一个对象。

 在左边的pet类中定义了一个宠物的所有属性，在Test的主方法中进行调用。先通过new来实例化出来一个pet方法，然后通过“.”方法进行调用。

四、封装

程序的封装就是内部数据的操作过程由开发者完成，不允许外部干涉；仅暴露少量的方法给外部使用。简单来说就是属性私有，保证数据的安全性。

设置私有属性：private XXX,与public想对应。

得到、设置私有属性的值：通过get和set语句来获得和设置。

eg:封装一个Pet类，并在main方法中对其进行操作

public class Pet {
    private String name;
    private int id;  //设定私有属性，此项只能通过特定的方法访问
    private char sex;
    private String address;
    public void say(){System.out.println(this.name + "说话了！");
    }

    public String getName() {  //获取private属性下的name值，下同
        return name;
    }

    public void setName(String name) {  //设置private属性下name值，下同
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

}

操作：

public static void main(String[] args) {
        Pet dog=new Pet();
        dog.setName("俊豪");
        dog.setId(221401209);
        dog.setSex('女');
        dog.setAddress("sut");
        System.out.println(dog.getName());
        System.out.println(dog.getId());
        System.out.println(dog.getAddress());
        System.out.println(dog.getSex());
        dog.say();

    }

结果： 

快捷键：alt+insert快速定义set和get方法

五、继承

继承，顾名思义就是继承父类的一些属性和方法。

关键字：extends

eg:写三个类：Person、Teacher、Students。让Teacher、Students继承Person类。

 public static void main(String[] args) {
        students xh=new students();
        Teacher jj=new Teacher();
        xh.name="小红";
        xh.id=221401208;
        xh.sex='男';
        xh.address="sut";
        xh.age=10;
        jj.name="华子";
        jj.id=221401209;
        jj.sex='男';
        jj.address="sut";
        jj.age=10;

        System.out.println(xh.name);
        System.out.println(xh.id);
        System.out.println(xh.sex);
        System.out.println(xh.address);
        System.out.println(xh.age);

        System.out.println(jj.name);
        System.out.println(jj.id);
        System.out.println(jj.sex);
        System.out.println(jj.address);
        System.out.println(jj.age);
    }

六、方法的重写和多态

1、方法的重写

方法的重写是在有继承关系下的类中实现的，即子类重写父类的方法。

重写的条件：

①方法名必须相同，方法体不同。

②参数列表必须相同。

③修饰符的范围可以缩小但不能扩大：public>Protected>Default>private
 

重写的意义：父类的功能子类可能不需要或不满足，重写会更好的满足程序设计的要求 。

子类重写方法后，执行的是子类的方法。
2、多态

所谓多态即为一中放法根据发送对象不同而采取不同的行为方式。一个对象的实际类型是确定的，但可指向对象的引用类型有很多。

多态存在的条件：
①有继承关系。
②子类重写父类的方法。
③父亲引用指向子类对象。

eg:

 public static void main(String[] args){
        Students s1=new Students();
        s1.say();
        Teacher s2=new Students();
        s2.say();
        ((Students)s1).eat();
    }

**注意事项：

①多态是方法的多态，属性没有多态。
②不能重写的类型或属性：
               static类型
               final类型
               private属性

七、抽象类和接口

抽象类：abstract (了解，作用不大）
抽象实际上是一种用来约束的类，在编写大型程序时我们可以定义一个抽象类来让别人协助我们，我们通过抽象类来约束别人编写程序的方法。这样可提高我们编写代码的效率。
语法：public abstract 返回值类型 方法名（）{}；

*注意事项：
①抽象类不能被new出来，只能靠子类来实现；
②抽象类中可以写普通的方法；
③抽象的方法必须在抽象类中。

接口：声明关键字 interface
接口相对于抽象类来说是一种专业的约束，接口里只有规范，没有方法。接口的本质时契约，由架构师制定好后大家统一遵守。

接口的实现：implements
*可以通过接口来实现多继承