Java中的面向对象思想

一、什么是对象：

      所有具象化的个体都是对象，也就是常说的万物皆对象，当然这是作为一个初学者的一个笼统介绍。我们可以将一个宇宙，一个星球，一个国家，一个人，一辆车，一只猫，一直蚂蚁，一个细胞都看做一个对象。而对象存在属性与方法，对于一个人来说，一个手是你的属性，而你可以通过这个手做什么事，就是你的方法。简而言之，属性就是你的年龄，面貌，姓名这些值，而你的方法就是指你可以做到的行为（比如编程）。

二、Java中的类与对象：

      对于java来讲，类是对一种具备同样特点（即同样属性与方法）的集合体，类不是一个具体的对象，只是一描述。对象则是类的具象化（实例化），具备类的属性与方法。比如说人类是一个类，指定的一个人就是对象。猫是一个类，确定的一只猫则是一个对象。而对象具备这个类所有方法与属性。就像所有猫都有眼睛，都有鼻子，都会向前扑。

三、Java面向对象的三大特性：

      1.封装：Java的类中，对于程序来讲，属性与方法都是隐藏不可见的，程序调用类中属性与方法，都是使用实例化的对象或者类本身来调用。封装相对于面向过程编程具备更强的安全性。

      2.继承：Java中类与类可以存在的一种关系。继承指，一个类会继承另一个对象的除 private的属性与方法和构造方法以外的所有属性与方法。继承的实现对类的多态产生了巨大的帮助。 

      3.多态：继承，重写（override）与父类指向子类对象  实现了Java的多态，多态的产生使我们能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

      4.多态的使用，大幅度的减少了重复代码的编写；虽然提高了一定的耦合，但是使代码的逻辑性以及可读性大大增强。

四、继承：

      1.一个类只可以继承一个类，即一个类只能拥有一个父类，可以拥有多个子类，但是可以有多个接口。

      2.子类继承父类的非private属性与方法，但是不会继承父类的构造函数。

      3.当子类构造函数被调用时，会默认调用父类的构造函数（无参），若父类没有无参构造函数或者需要调用其他构造函数时，请自行使用super（）调用父类的构造函数，且必须写在子类的构造函数的第一行（因为子类需要继承父类的属性与方法，所以需要在创建子类时，初始化父类）

public class ClassTest {

    public static void main(String[]args){
        B b = new B();
//        int a =b.a;
//        b.run();
//        b.go();
    }

}


class A{
     int a=1;
     void run(){
         System.out.println("run");
     }
     A(){

     }
    {
        System.out.println("A类的构造函数被调用");
    }
}

class B extends A{
//    public int a=1;
    B(){
//        System.out.println();
        super();
    }
    {
        System.out.println("B类的构造函数被调用");
    }
    @Override
    void run() {
        System.out.println("runing");
    }
    void go(){
        System.out.println("no");
    }
}

四、抽象类与方法

        1.抽象使用 abstract关键字标记，不可与final关键字一起使用

        2.抽象类，无法被实例化；抽象方法无法被重写，且不可以有方法体。

        3.一个类中存在抽象方法，则该类是抽象类，且必须使用abstract标记。

        4.抽象类存在的唯一意义是被继承，抽象方法存在的意义是被重写。

        5.抽象类实例方法可以有方法体，可以有赋值的属性（基本类型与对象），但是抽象方法不可以有方法体（指｛｝）

        6.子类继承抽象方法时，要么重写所有抽象方法，要么将自身也标记为一个抽象类

　　

public class ClassTest {

    public static void main(String[]args){
        B b = new B();
//        int a =b.a;
//        b.run();
//        b.go();
    }

}


abstract class A{
     int a=1;
     String b = new String("ni");
     void run(){
         System.out.println("run");
     }
     abstract void so();
     A(){

     }
    {
        System.out.println("A类的构造函数被调用");
    }
}

class B extends A{
    B(){

        super();
    }
    @Override
    void so() {
        System.out.println("继承抽象类时，要么需要重写所有抽象方法，要么自身也被定义为抽象类");
    }

    @Override
    void run() {
        System.out.println("runing");
    }
    void go(){
        System.out.println("no");
    }
}

五、接口

       1.接口是一些列只有声明没有实现的方法的集合，用于补充只能继承一个类的继承缺憾。接口只能有方法的特征，不可以有方法的实现。

       2.接口中虽然允许定义对象与基本类型，但是使用接口的类以及接口本身实例化都无法使用这些被定义的属性，所以不建议这么使用

       3.接口默认所有的方法都是抽象方法，所以不可以有方法的实现；且所有使用接口的类都需要重写该接口下所有方法（比如Lock）

       4.接口可以实例化但是也需要实现接口内的所有方法。

class InterfaceTest{
   public static void main(String[]args){

        Myinterface my =new Myinterface() {
            @Override
            public void method1() {
              System.out.println("1");
            }
        };
        my.method1();
    }

}
interface Myinterface{
    public static int a =10;
    String str =new String("nihao");
      void method1();
      //不可有方法体，否则会报错
//      void method2(){};
}

class C implements Myinterface{
    @Override
    public void method1() {

    }
}

六、重写（override）

          1.当子类需要修改父类的方法体时，可以重写父类方法。

          2.重写是可以修改访问权限，可以定义final，但是不可以使用static修饰，不可以修改返回值，不可以修改参数。

          3.@override：没有任何编码含义，唯一的作用是用于标记下面方法是重写的，当触犯重写原则时，该标记会提示出错。

七、重载（overload）

          1.在类中可以定义方法名字相同但是参数不同的方法

          2.可以是参数的顺序，数目，类型不同；但不可以是变量名不同。

          3.访问修饰符和返回值可以不同，但是不可以只是访问修饰符与返回值不同（即必须在参数得顺序，数目，以及类型上存在差异（因为方法调用时，只会有方法名与参数））