05 Java面向对象

面向对象编程

Java的核心思想就是oop（面向对象编程）

初时面向对象
方法回顾和加深
对象的创建分析
- 类与对象的关系
- 构造器
面向对象的三大特性
- 封装
- 继承
  - object类
  - super
  - 方法重写
- 多态
  - 类型转换
  - static关键字
    - 静态变量/非静态变量
    - 静态方法/非静态方法
    - 静态代码块/匿名代码块
  - final关键字
抽象类和接口
内部类及OOP实战

面向过程&面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二部做什么。。。
- 面向过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面对过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然选用面向过程的思路去处理

1、什么是面向对象

面向对象编程（Object-Oriented Programming, OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的形式组织（封装）数据
抽象
三大特性：
- 封装
- 继承
- 多态
从认识角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是否先有类后有对象。类是对象的模板。

3、对象的创建分析

（1）类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 例如：Person类泛指人这一大类，Pet类泛指宠物这一大类
对象是抽象概念的具体实例
- 张三就是人的一个具体的实例
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

（2）创建与初始化对象

使用new关键字创建对象

//new关键字创建对象实例

//Student.java
public class Student {
    String name;
    int age;
    public void out(){
        System.out.println("hello");
    }
}
//Application.java
public class Application {
    public static void main(String[] args) {
        Student xiaoming = new Student(); //使用new关键字 创建对象
        Student xiaohong = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 18;

        xiaohong.name = "小红";
        xiaohong.age = 22;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaohong.out();
    }
}

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

构造器

构造器，又称为构造方法。构造器用于构造该类的实例，也就是对象。

构造方法是一种特殊的方法，与一般的方法区别：

1.构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。　　

2.构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。　

3.不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承。

构造方法可以被重载。没有参数的构造方法称为默认构造方法，与一般的方法一样，构造方法可以进行任何活动，但是经常将他设计为进行各种初始化活动，比如初始化对象的属性。　

在Java中,任何变量在被使用前都必须先设置初值.Java提供了为类的成员变量赋初值的专门功能

构造方法(constructor)它的特殊性反映在如下几个方面: 　
(1)构造方法名与类名相同.

(2)构造方法不返回任何值,也没有返回类型. 　　

(3)每个类可以有零个或多个构造方法. 　　

(4)构造方法在创建对象时自动执行,一般不能显式地直接调用.

此处转自：https://www.cnblogs.com/weibanggang/p/10072642.html

（一）无参构造

//Student.java
public class Student {
    public Student(){ 
        //1.构造函数，java中即使不手动创建无参构造函数，也会默认创建无参构造函数，使得可以new Student类
        //2.构造函数的特点！！ 名字与类名相同，且不返回任何值
    }
}
//Application.java
public class Appliaction {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

无参构造可以初始化信息

代码演示：

//Student.java
public class Student {
    String name;
    public Student(){
        this.name = "李华"; //定义了name属性的值为 李华
    }
}

//Application.java
public class Appliaction {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.name);
    }
}

（二）有参构造

定义了有参构造之后如果想要使用无参构造，需要再显示的定义一个无参构造

//Student.java
public class Student {
    String name;
    public Student(){ //此处为无参构造
        this.name = "李华";
    }
    public Student(String n){//此处为有参构造
        this.name = n;
    }
}

4、面向对象的三大特性

（一）封装

该露的露，该藏的藏
- 我们设计程序设计要追求“高内聚，低耦合”。高内聚就是类内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应精致直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有，get/set

封装的意义

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护增加了

实例：

public class demo01 {
    private String name;	//private关键字，使得属性外部无法直接访问
    private int age;
    private String behavior;

    public String getName() { //get方法获取属性值
        return name;
    }

    public void setName(String name) {//set设置属性值
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<120 || age>0){ //get和set方法可以增加规则，保护数据
            this.age = age;
        }else {
            System.out.println("年龄格式有误");
        }
    }

    public String getBehavior() {
        return behavior;
    }

    public void setBehavior(String behavior) {
        this.behavior = behavior;
    }
}

（二）继承

继承本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键extends来表示
子类和父类之间，从意义上讲应该具有“is a”的关系

//父类
public class Person {
}
//子类继承父类
public class Student extends Person{
}

//父类可以有多个子类，一个子类只能继承一个父类

object类

在Java中，所有的类，都默认直接或者间接继承object

Super

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中！
super和this不能同时调用构造方法！
父类中的private属性无法获取

//父类 Person.java
public class Person {
    public String name;
    private int age; //private属性,子类无法获取
    public String sex;

    public Person(){ //无参构造函数
        System.out.println("person无参构造函数");
    }
    public Person(String sex){ //有参构造函数
        this.sex = sex;
    }
    public void shout(){ //shout方法
        System.out.println("Hello");
        System.out.println("my name is"+this.name+",age is"+this.age);
    }
}
//子类 Student.java
public class Student extends Person{
    public Student(){
        //此除隐藏了代码：调用了父类的无参构造函数 super();
        super("男");
        System.out.println("无参构造");
    }
    public Student(String name){
        super.name = name;
        System.out.println("student有参构造");
    }
}
//主函数 Application.java
public class Application {
    public static void main(String[] args) {
        Student student = new Student("小明");//步骤1
        Person person = new Person();//步骤2

        student.shout();//步骤3
        person.shout();//步骤4
    }
}
/*运行结果：
person无参构造函数
有参构造
person无参构造函数
Hello
my name is小明,age is0
Hello
my name isnull,age is0  
*/
/*解析Application运行顺序
步骤1:
new创建出student对象->Student类的有参构造函数->默认执行了super(),调用了父类的无参构造
步骤2：
new创建出person对象->默认执行了无参构造函数
步骤3：
执行了父类继承过来的shout
步骤4：
执行了shout方法
*/

super和 this对比：

代表的对象不同：

this：本身调用者这个对象

super：代表父类对象的应用

前提：

this：没有继承也可以使用

super：只能在继承条件才可以使用

构造方法：

this()；本类的构造

super；父类的构造

方法重写

重写都是方法的重写，与属性无关。

为什么需要重写：父类的功能，子类不一定需要，或者不一定满足

重写：需要有继承关系，子类重写父类的方法！

重写的方法必须要和父类一模一样(包括返回值类型,方法名,参数列表)
重写的方法可以使用@Override注解来标识
修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
抛出异常：范围，可以缩小，但不能扩大：ClassNotException -->Exception(大)
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够再次声明。

（三）多态

多态注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系，类型转换异常！ClassCastException!
存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();

方法未重写时：

执行结果：

push
push
push

执行结果：

I’m pushing!
push
I’m pushing!

Person stu3 = new Student();
stu3.push();

如果子类没有修改父类方法的话，则默认执行父类的方法

如果子类重写了父类的方法的话，则执行重写后的方法

且如果子类中有父类没有的方法，父类型stu3无法调用。它不能调用子类独有的方法。

类型转换

父类（高） ----> 子类（低）

父类引用指向子类的对象 Father name = new Student();
把子类转换为父类，向上转型；
把父类转换为子类，向下转型；强制转换
- 只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象.
方便方法的调用，减少重复的代码。直接上升或下降类

static关键字

静态变量/非静态变量
静态方法/非静态方法
静态代码块

在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。

静态变量与非静态变量的区别：

静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static代码块

　static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

public class Person{
    {
        //代码块（匿名代码块）
    }
    
    static{
        //静态代码块
    }
    
    public Person(){
        //构造方法
    }
}

先后执行顺序：静态代码块 > 匿名代码块 > 构造方法

public class test {
    {
        System.out.println("匿名代码块");
    }

    static{
        System.out.println("静态代码块");
    }

    public test(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        test t1 = new test();
    }
}

输出结果：
    
静态代码块
匿名代码块
构造方法