JAVA 面向对象

主要分为三部分：封装，继承，多态（方法重写或方法重载）

1 封装

封装性是面向对象的一个重要特征。在java语言中，对象就是一组变量和方法的封装体。通过对象的封装，用户不必了解对象是如何实现的，只需要通过对象提供的接口方法与对象进行交互就可以。封装性实现了模块化和信息隐藏，有利于程序的可移植性和对象的管理。

对象的封装类是通过下面两种方式实现的。

（1）通过包装实现封装性。在定义时使用packge 语句指定类属于哪个包。包是java语言最大的封装单位，定义了程序对类的访问权限。

（2）通过类或类的成员访问权限实现封装类。

使用private进行封装

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

    被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

        提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

        提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
 

/*
    学生类
 */
class Student {
    //成员变量
    String name;
    private int age;
 
    //提供get/set方法
    public void setAge(int a) {
        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }
 
    public int getAge() {
        return age;
    }
 
    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
        //调用show方法
        s.show();
    }
}

经private修饰的成员变量，只能通过提供对应的set ， get方法对其进行访问，提高了其安全性。

This

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

• 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

• 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

  public class Student {
      private String name;
      private int age;
   
      public void setName(String name) {
          this.name = name;
      }
   
      public String getName() {
          return name;
      }
   
      public void setAge(int age) {
          this.age = age;
      }
   
      public int getAge() {
          return age;
      }
   
      public void show() {
          System.out.println(name + "," + age);
      }
  }

  2 继承

继承是面向对象最显著的一个特性。 继承是从已有的类中派生出新的类， 新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
        在JAVA中， 被继承的类叫父类(parent class)或超类(superclass)， 继承父类的类叫子类(subclass)或派生类(derivedclass)。 因此， 子类是父类的一个专门用途的版本， 它继承了父类中定义的所有实例变量和方法， 并且增加了独特的元素 。
extend

在Java中通过extends来进行继承

继承特性

    java中一个类最多只能有一个直接的父类，即单继承

    java中要实现多继承，通过接口来实现

    父类中所有属性和方法都能继承给子类；父类中的私有方法不能继承给子类。

    共性放到父类，特性放到子类

    继承好处

        提高了代码的复用性(多个类相同的成员可以放到同一个类中)

        提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

    继承弊端

        继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
 

public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();
 
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

在子类方法中访问一个变量，采用的是就近原则。

1. 子类局部范围找

2. 子类成员范围找

3. 父类成员范围找

4. 如果都没有就报错

   class Fu {
       int num = 10;
   }
   class Zi {
       int num = 20;
       public void show(){
           int num = 30;
           System.out.println(num);
       }
   }
   public class Demo1 {
       public static void main(String[] args) {
           Zi z = new Zi();
           z.show();	// 输出show方法中的局部变量30
       }
   }

   super 关键字

5.     this&super关键字：

           this：代表本类对象的引用

           super：代表父类存储空间的标识(可以理解为父类对象引用)

       this和super的使用分别

           成员变量：

               this.成员变量 - 访问本类成员变量

               super.成员变量 - 访问父类成员变量

           成员方法：

               this.成员方法 - 访问本类成员方法

               super.成员方法 - 访问父类成员方法

       构造方法：

           this(…) - 访问本类构造方法

           super(…) - 访问父类构造方法

           子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()
     final 关键字                                                                                                                   

6. “final”关键字用来修饰类、 方法和变量， 其含义“不可改变的、 最终的”。

   final修饰的类不能被继承，即不能有子类，final修饰的方法不可被重写，final修饰的变量值不可被更改，即为常量。                                                                                                

 方法重写

1.方法重写概念
        子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

2.方法重写的应用场景

        当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
3.Override注解
        用来检测当前的方法，是否是重写的方法，起到【校验】的作用

4.方法重写注意事项

        私有方法不能被重写(父类私有成员子类是不能继承的)，子类方法访问权限不能更低(public > 默认 > 私有)
 

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }
 
    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}
 
public class Zi extends Fu {
 
    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }
 
    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

3 多态

在面向对象语言中， 多态性是指一个方法可以有多种实现版本，即“一种定义， 多种实现”。 利用多态可以设计和实现可扩展的系统， 只要新类也在继承层次中。 新的类对程序的通用部分只需进行很少的修改， 或不做修改。 类的多态性表现为方法的多态性，方法的多态性主要有方法的重载和方法的覆盖。

多态的前提

    要有继承或实现关系

    要有方法的重写

    要有父类引用指向子类对象

        多态的利弊

    好处

    提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

    弊端

    不能使用子类的特有成员

        成员访问特点

    成员变量

    编译看父类，运行看父类

    成员方法

    编译看父类，运行看子类

运行时的多态

子类的对象放在父类的引用中，子类对象当父类对象来使用。

Animal a=new Cat( );

public class Animal {    //父类
    public int age = 40;
 
    public void eat() {
        System.out.println("动物吃东西");
    }
}
 
public class Cat extends Animal { //继承Animal类
    public int age = 20;
    public int weight = 10;
 
    @Override                    //重写父类方法
    public void eat() {
        System.out.println("猫吃鱼");
    }
 
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {           
        Animal a = new Cat();    //有父类引用指向子类对象
 
        System.out.println(a.age);
//        System.out.println(a.weight);
 
        a.eat();
//        a.playGame();
    }
}