java中面向对象

1、java面向对象

java是一门面向对象的语言，在面向对象的世界中，把事务看成对象，面向对象的做法确实是把属性和功能封装起来，但是其核心是归类和抽象。

把相关的属性和功能集中起来，把可以分离的部分隔绝开来，从而把复杂的业务逻辑切割成互相之间可以相对独立的部分，降低开发的难度。

主要从下面几个方面理解：
1、理解类，接口，方法，构造器
2、理解修符:public,protected,private
3、理解封装，继承，多态。面向对象的三个特征不是分割的，是一个整体。

2、封装

封装是将对象的一些信息隐藏起来，不对外暴漏细节。只提供对外使用或者调用的方法。为什么不对外暴漏？封装有什么好处？

1. 隐藏类的实现细节，使用的时候方便，不需要知道内部具体什么方法，如何实现，哪些限定，只需要调用一下即可。
2. 安全。通过设置一定的方法，对外提供。外面没有办法直接访问或者修改对象的一些属性（比如说，你兜里有钱，别人是不是直接可以从你兜里拿？当然不可以，但你又提供一个机制取出你兜里的钱，比如说是你，或者你家人才可以拿）
3. 数据校验。比如定义一个Person类的时候，它有姓名和年龄，在设置年龄的时候是不是要校验，假如写200，300，就是不合法。
4. 便于修改，提高可维护性。

---

也就是类的信息，该隐藏的隐藏，又要提供对外暴漏的方法。

理解下面四个访问权限：
private:当前类权限
default:包访问权限
protected子类访问权限
public公共访问权限

举个例子：

package com.example.demo;

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    //对用户年龄进行校验
    public void setAge(int age) {

        if(age>150  || age<0){
            System.out.println("设置年龄不合法");
            return;
        }
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }


}

测试代码

public class PersonTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
          Person p=new Person();
          p.setName("abc");
          p.setAge(200);
          System.out.println(p);
          System.out.println(p.getAge());
    }
}

输出结果：

3、继承

1、继承能够实现代码复用，简化代码，容易拓展维护。
2、子类继承父类，能够使用父类的方法属性，也可以覆盖，使用自己特有的方法和属性。
3、抽象类是为继承做准备的，抽象类是指抽取出子类共同点，子类只一定要有这样的方法。因此子类一定要实现抽象类中的抽象方法。
（下面探讨抽象与接口的区别）
4、abstract 不能与private、static、final并列修饰同一个方法。
原因：
abstract不能与private使用，因为子类一定要重写这个方法，如果用private就访问不到父类的这个方法

abstract与final：final修改的类，不能被继承。但是abstract中可以用final修饰的方法。final修改的方法，不能被重写，因为父类已经感觉完美实现了，只能让子类调用。

abstract不能与static一块使用，abstrac修饰的就是要等到子类时具体的实现，一定是动态的，和static静态矛盾
从代码中仔细的理解

package com.example.demo;

public class AppleClass extends FruiteClass {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AppleClass apple = new AppleClass();
        // 子类重写父类方法；
        apple.getName();
        // 使用子类自己的名子；
        apple.getAppleName();
        // 获取父类的名子；
        apple.getFruiteName();
        apple.getAbsName();
        apple.getFinalName();

    }

    public void getAppleName() {
        String name = "apple name";
        System.out.println(name);
    }

    public void getFruiteName() {
        System.out.println(super.name);
    }

    // 子类重写父类方法：
    @Override
    public void getName() {
        // TODO Auto-generated method stub
        super.getName();
        // 在这super.getName()的作用
        // 如果需要用父类的方法，直接调用super.getName
        // 如果父类的方法不能满足，或者没用，去掉就可以，
    }

    @Override
    public void getAbsName() {
        // TODO Auto-generated method stub
        System.out.println("abstract name");
    }

}

abstract class FruiteClass {
    // protected子类可以访问
    protected String name = "fruite name";
    // private修改的，子类不能访问
    private String color = "fruite";

    public void getName() {
        System.out.println("fruite getName()");
    }
    //abstract方法，具体到子类中才实现。
    public abstract void getAbsName();
    //fianl修饰的方法，只能给子类调用，不用重写（父类的一些方法已经完美，不让子类重写，只能调用）
    public final void getFinalName(){
        System.out.println("fruite getFinalName()");
    }
}

4、多态

多态的作用是消除类型间的耦合关系，比如说，将接口和实现分离开，不但能够改善代码的组织结构，还容易拓展。

1、java中的引用变量分两种类型，一种是编译时期类型，一种是运行时期类型。如果编译时类型和运行时类型不一样，这就产生多态。
静态多态就是在编译时期确定调用的方法,最典型的的就是重载了。动态多态是在运行时确定的,最典型的的父类和子类之间的重写。所以重写和重载都是多态的表现。

2、多态的场景

1. 存在继承关系
2. 子类重写父类的方法
3. 父类引用指向子类对象。

3、多态在java中具体实现

1. 类继承（重写父类方法）
2. 接口实现
3. 方法重载

package com.example.demo;

public class SubClass  extends BaseClass{

    public static void main(String[] args) {
        //在编译时期是BaseClass,在运行时是SubClass
        //最终调用的是子类的getBaseName()；
        BaseClass sub=new SubClass();
        sub.getBaseName();
    }
    @Override
    public void getBaseName() {
        System.out.println("getSubName()");
    }

}
class BaseClass{

    String baseName="baseName";
    public void getBaseName(){
        System.out.println("getBaseName()");

    }
}

5、Final关键字

在编程中，我们常遇到一些变量或者对象，我们要求它不可改变。
1、一个不可改变的编译时常量。
2、一个在运行时期被初始化的值，而不希望它的值改变。

对于基本数据类型，final使数值不可改变。
对于对象引用，使引用恒定不变，一旦引用被引用初始化指向一个对象，就无法让他再指向另一个对象。

6、抽象与接口的区别

抽象类是从多个具体类中抽象出来的父类，它具有很高的抽象层次。多个类以这个抽象类为模板，避免子类设计的随意性，要求子类必须实现一些特点的功能。

抽象类体现的就是一种模板的设计思想，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展，改造。

---

接口：如果多个类中，每一个类中所有的功能都相似，只是具体实现不同。那么这个类，在抽象类的基本上再提炼。这就是接口。
可以说接口是比抽象更加进一步的提取。

接口里面的成员变量只能是静态常量，接口里默认的方法只能是抽象方法。
也就是接口里面的变量默认为public static fainl修饰
接口里的方法默认为abstract修饰，因此如果要实现接口，就必须实现接口里面的所有方法。

相同点：

1. 都不能被实例化，因为他们是模板，是抽取，具体实现让子类开实现的。
2. 都包含抽象方法（接口是全部抽象方法）要继承或者实现，子类就必须实现所有的抽象方法。

不同点：

1. 接口比抽象更加“抽象”，它只包含抽象方法，成为规范，标准。
2. 抽象类能够有构造方法，并不是用来实例化的，而是让子类调用，完成属于抽象类的初始化操作。
3. 抽象用于继承，子父类之间，接口用于实现。

7、java是不是一门纯粹面向对象的语言

参考博客
http://www.codeceo.com/article/why-java-purely-object-oriented-language.html