Java面向对象

面向对象

java是一门面向对象的语言，面向对象最重要的三个特性封装，继承和多态。

java的封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

• 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
• 要访问封装的代码和数据，必须通过严格的接口控制。
• 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
• 适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

优点

• 通过良好的封装可以减少耦合。
• 类的内部结构可以自由修改，而不用修改那些调用我们代码的程序片段。
• 对成员变量更加精确的控制。
• 隐藏信息和实现细节。

Java实现封装的步骤

1. java中方法就是一封装。
2. 通过使用访问控制符private来修改属性的可见性，限制外部对属性的访问。
   一个简单实例：

//使用private关键字隐藏了属性
public class Person {
    private String name;
    private int age;
}

//实例对象直接访问会报错
public class demoMain {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "java";//报错
        person.age = 15;//报错
    }
}

public class Person {
    private String name;
    private int age;
    //为私有属性添加Getter和Setter方法，进行访问控制
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {//Setter方法可以用于对传入的数据进行合法性判断
        if(age>0&&age<100){
            this.age = age;
        }else {
            System.out.println("数据异常！");
        }
    }
}

public class demoMain {
    public static void main(String[] args) {
        Person person = new Person();
//        person.name = "java";
//        person.age = 15;
        //通过类的成员方法访问private 修饰的成员变量
        person.setName("java");
        person.setAge(15);
        System.out.println(person.getName()+":"+person.getAge());//java:15
    }
}

Java的继承

继承是java面向对象编程技术的一块基石，继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
继承就是父类对子类的共性抽取。父类更通用，子类更具体。

继承格式：class 子类名 extends 父类名{}
一个简单的继承实例：

public class Animal {
    private String name;

    public Animal() {
    }

    public Animal(String name) {
        this.name = name;
    }

    public void eat(){
        System.out.println("父类的eat方法");
    }
    public void work(){
        System.out.println("父类的work方法");
    }
}

public class Cat extends Animal{
    //子类没有重写父类的eat()

    @Override
    public void work() {//子类可以重写父类的方法
        System.out.println("猫抓老鼠");
    }
}

public class demoMain {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("猫");//子类无法继承父类中private修饰的私有属性
        System.out.println(cat.getName());
        cat.eat();//子类没有重写父类的eat()方法，则向上找父类
        cat.work();
    }
}

猫
父类的吃方法
猫抓老

继承的类型

需要注意的是 Java 不支持多继承，但支持多重继承。

继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）

接口

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口内容补充

从Java 8开始，接口里允许定义默认方法。格式:

    public default void methodDefault() {//接口中的默认方法
        System.out.println("新增加的默认方法");
    }

1. 接口的默认方法，可以通过接口实现类对象，直接调用。
2. 接口的默认方法,也可以被接口实现类进行覆盖重写。
3. 接口当中的默认方法，可以解决接口升级的问题。
   `

从Java 8开始，接口当中允许定义静态方法。格式:

    static void methodStatic() {//接口中的静态方法
        System.out.println("接口的静态方法");
    }

注意事项:不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法:通过接口名称，直接调用其中的静态方法。
格式:
接口名称.静态方法名(参数);

问题描述:
我们需要抽取一个共有方法，用来解诀接口中两个默认方法或静态方法 之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。
解决方案:
从Java 9开始，接口当中允许定义私有方法。
1．普通私有方法，解决多个默认方法之间重复代码问题格式:

    private void methodCommon() {//解决默认方法重复代码
        System.out.println("方法体");
    }

2．静态私有方法，解决多个静态方法之间重复代码问题格式:

    private static void methodCommon1() {
        System.out.println("方法体");
    }

public interface MyInterface {
    
    public static final int NUM_OF_INTERFACE = 10;//接口中的常量使用public static final修饰，大写下划线连接，并赋值

    void method1();    //接口中的抽象方法

    void method2();    //接口中的抽象方法


    default void methodDefault() {//接口中的默认方法
        System.out.println("新增加的默认方法");
    }

    private static void methodStatic() {//接口中的静态方法
        System.out.println("接口的静态方法");
    }

    default void methodDefaultA() {
        System.out.println("默认方法A");
        methodCommon();
    }

    default void methodDefaultB() {
        System.out.println("默认方法B");
        methodCommon1();

    }

    private void methodCommon() {//解决默认方法重复代码
        System.out.println("aaa");
        System.out.println("bbb");
    }

    private static void methodCommon1() {
        System.out.println("aaa");
        System.out.println("bbb");
    }

}

抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

继承关键字

多态

对象的多种形态，继承是多态的实现基础。
1.引用多态

• 父类的引用可以指向本类的对象，Animal obj1=new Animal();
• 父类的引用可以指向子类的对象，Animal obj2=new Dog();

2.方法多态

• 创建本类对象，调用的方法为本类方法；
• 创建子类对象，调用的方法为子类重写的方法或者继承的方法。
• 如果子类有独有的方法（子类新建的方法，不与继承方法同名，非重写，父类的引用指向子类的对象时（多态情况下），不能调用该方法）注意不能使用子类的引用指向父类对象。
• 在父类的引用可以指向子类的对象（多态）时使用子类特有的方法需要向下转型。

3.引用类型转换

这里说的对象类型转换，是指存在继承关系的对象，不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时，java 运行时将抛出 java.lang.ClassCastException 异常。

1.向上类型转换（隐式/自动类型转换），是从小类型到大类型的转换
2.向下类型转换（强制类型转换），是从大类型到小类型，这种转换有风险，可能会溢出。
3.instanceof运算符，解决引用对象的类型，避免类型转换的安全问题

在继承链中，我们将子类向父类转换称为“向上转型”，将父类向子类转换称为“向下转型”。很多时候，我们会将变量定义为父类的类型，却引用子类的对象，这个过程就是向上转型。程序运行时通过动态绑定来实现对子类方法的调用，也就是多态性。然而有些时候为了完成某些父类没有的功能，我们需要将向上转型后的子类对象再转成子类，调用子类的方法，这就是向下转型。注意：不能直接将父类的对象强制转换为子类类型，只能将向上转型后的子类对象再次转换为子类类型。也就是说，子类对象必须向上转型后，才能再向下转型。
instanceof 可以判断一个引用是否是某个类型或者是某个类型的子类型，它会返回一个布尔值。if(animal instanceof Cat) 如果你这个对象里含有cat元素，就可以转换由于animal先被转换成了Dog类型，指向了dog的内存空间，类型不匹配。