面向对象阶段回顾

面向对象阶段回顾

面向过程和面向对象编程思想

面向过程

面向过程POP：是一种基本的编程思想，是将一件事按流程逐步实现。

这种思想强调事情完成的过程，分析步骤写出相应的代码。

C语言就是一门标志性的面向过程编程语言。

Java基础部分写的所有代码，都是面向过程的，都是一步步按流程执行。

面向对象

面向对象OOP：是当主流的编程思想，是创建解决问题的对象，赋予对象对应的行为和特征，让这些对象互相配合(调用对象的方法)完成。

这种思想致力于将计算机中的世界，描述的和现实中一致的思想。

类和对象

类Class

具有相同属性和行为的对象的集合，称为"一类"。可以理解为模板。

定义类

[修饰符] class 类名{

//属性(变量)

//行为(方法)

}

对象Object

对象是类的一个实例，是类的具体表现。

创建对象

类名 对象名 = new 构造方法([参数])；

创建的对象，通过"."操作符访问类中的非私有属性和方法。

类和对象的关系

对象是类的具体表现，类是对象的集合(模板)。

如包饺子的模具就是一个类，每次用这个模具包出来的饺子都是一个一个对象。

先定义类，才能通过该类创建对象

成员变量、局部变量、静态常量

• 成员变量：定义在类中的变量，即类的属性。它有默认值。通过对象访问。

• 局部变量：定义在方法中的变量。它没有默认值。只能在方法中赋值后才能使用。

• 静态常量：特殊的成员变量，用final static修饰。它有默认值。通过类名访问。

class Person{
//成员变量
    String name;
//静态常量
    final static String COUNTRY="中国";
//定义方法
    void info(){
//局部变量
    int age=20;
        System.out.println("我叫"+name+"，今年"+age+"岁，是一个"+COUNTRY+"人");
    }
}

构造方法

是一种特殊的方法。方法名和类名一致，没有返回值部分。

public class Test{
//这就是无参数的构造方法，默认就会存在，不过是隐藏的
     public Test(){
     }
}

• 没有返回值部分，方法名必须和类名一致。

• 在使用new关键字创建对象时，调用对应的构造方法。

• 每个类在定义后，都隐藏有一个无参的构造方法。

• 如果自定义了有参数的构造方法，无参数的构造方法就会失效。如果想要使用无参构造方法，就要再写出来。

• 构造方法通常用于限制创建对象时携带的参数，初始化成员变量。

• 构造方法之间都是重载关系，构造方法不能重写。

• 构造方法执行时，不一定会创建对象。如抽象类中有构造方法，但无法创建抽象类对象，只能在创建抽象类的子类对象时，自动调用抽象类的构造方法。

面向对象三大特性

封装

概念

使用private关键字对属性进行修饰。再对外提供一组公开的get/set方法用于对该属性读取或赋值。可以防止除自身类之外的地方对该属性就行访问。这样做可以保护关键属性，隐藏类内部的实现细节，

步骤

1.给类中的所有属性添加private访问修饰符

2.给每个属性添加getXXX()方法用于读取属性值

3.给每个属性添加setXXX()方法用于给属性赋值

继承

类A可以通过extends关键字继承类B。

语法：class 类A extends 类B{}

类A称为子类、派生类、衍生类、subClass

类B称为父类、根类、超类、superClass

继承后，子类可以访问父类中非私有(没有被private修饰的内容)的属性和方法。

不同的子类中如果有相同的代码，都可以把它们提出来保存到父类中，从而减少子类中的代码冗余。

继承的特点

• 如果多个类之中有相同或类似的代码，可以将这些代码提取出来定义在一个公共的类中，这个类就是父类。再让那些类就继承这个父类，那些类就是子类，这样就能减少子类中的重复代码。

• 子类对象可以直接访问父类中非私有(不用private修饰)的属性和方法

• 子类可以对父类中的方法进行扩展或覆盖，这称为方法重写。重写后，子类对象再调用该方法时，执行的是重写后的内容

• Java中是单继承。一个子类只能extends一个父类，一个父类可以有很多个子类

• Java中可以多重继承。类A可以继承类B，类B可以继承类C，这时类A既是类B的子类，也可以称为类C的子类，可以访问类B与类C中非私有的成员

• 任何类都是Object类的子类

• 在创建子类对象时，会先执行父类中相应的构造方法

重写Override

子类继承父类后，对父类中的非私有方法进行重写，达到拓展或重做的目的

• 必须满足方法名、返回值、参数列表都相同

• 访问权限不能比父类中的方法更严格

• 不能抛出比父类中的方法更大的异常

重载Overload

在一个类中，某个方法在不同的参数下，表现不同的行为。同名不同参。

• 方法名必须相同

• 参数列表必须不同(类型和数量)

• 与返回值无关

重载与重写相关面试题

• 说出重载与重写的异同

  • 相同点：方法名不变

  • 不同点：xxxx

• 构造方法能重载吗？能重写吗？

  • 构造方法可以重载，不能重写。

• 构造方法在执行时，一定创建对象吗？

  • 不一定。创建子类时会自动执行父类构造方法，但不会创建父类对象

this和super关键字

• 都可以当做对象或构造方法使用。

• 当做对象：this表示当前类的对象,super表示当前类的父类对象。this或super当做对象使用时，只能用在非静态方法中。

• 当做构造方法：this()表示当前类的无参数构造方法，如果带参数就表示对应参数的构造方法。

• super()表示当前类的父类的无参数构造方法，如果带参数就表示对应参数的构造方法。

• this()或super()只能用在另一个构造方法的首行。

  在继承关系中，如果父类和子类都没有写出来任何构造方法时，子类有一个隐藏的无参数构造方法，会自动调用父类中无参数的构造方法。

class Father{

}
class Son extends Father{
/*
这个构造方法是隐藏的    
*/
    public Son(){
        super();
    }
}

如果父类中有带参数的构造方法，没有无参数的构造方法时，子类必须要调用父类中的构造方法。

class Father{
    String name;
    public Father(String name){
        this.name=name;
    }
}
class Son extends Father{
    public Son(){
        super("xxx");
    }
}

Object类

是所有类的父类。任何类都间接地继承了该类，但没有明确地使用extends体现出来。所有类都可以访问Object类中的方法，或对其进行重写。

toString()就是Object类中的一个方法，在输出对象时自动调用。默认输出的是"类名@十六进制哈希码"，通常在自定义类中，重写toString()，从而输出该类中的属性。

equals()也是Object类中的一个方法，用于比较两个对象是否相同。默认使用==比较，即比较内存地址，通常需要重写该方法，自定义判断两个对象是否相同时所需的参数。

向上转型

子类对象可以直接使用父类变量保存，即多态。

Person p = new Person();
Object obj = p;

向下转型

Animal an = new Aniaml();
//Animal必须是Cat的父类
Cat c =(Cat) an;

多态

多态就是子类的对象指向父类的引用(子类对象使用父类变量接收，即向上转型)。

父类 变量 = new 子类();

在继承关系中，子类的对象可以保存到父类的变量中。

多态通常应用于定义方法时，形参为一个父类或接口类型变量，实参可以是子类对象。

无法通过父类变量调用子类独有的方法，如果调用重写了父类的方法时，执行重写后的内容

父类/父接口 对象 = new 子类();
public class Father{
    public void smoke(){
        System.out.println("father smoking");
    }
}
public class Son extends Father{
    public void play(){
        System.out.println("son playing");
    }
    @Override
    public void smoke(){
        System.out.println("son smoking");
    }
}
public class Main(){
    public static void main(String[] args){
    Father f = new Father();
    f.smoke();//父类中的方法
    Son son = new Son();
    son.play();
    son.smoke();//调用的是重写后的方法
    //多态
    Father father = new Son();
    //father.play();无法调用
    father.smoke();//调用的是重写后的方法
    }
}

访问修饰符

final

用于修饰属性、方法和类

修饰属性：变量变为常量，不能改变其中的值。

修饰方法：方法成为最终方法，不能重写。

修饰类：类成为最终类，不能被继承。

abstract

用于修饰类和方法，表示抽象的。

修饰方法，方法成为抽象方法，没有方法体，同时该方法的所在类也一定要用abstract修饰，让其成为抽象类。

• 抽象方法只能出现在抽象类中，不能出现在普通类中。

• 抽象类中可以没有抽象方法。

• 抽象类中有构造方法，但该构造方法只会在new抽象类的子类对象时会自动调用，抽象类不能创建自身对象。

• 抽象类通常需要被继承，一旦有子类继承了抽象类，就必须要重写抽象类中的所有抽象方法。

interface

用于定义接口的关键字。代替class。

如果某个抽象类中全都是抽象方法时，可以将这个类改为接口。

• 接口是一个完全抽象类，其中的方法都是public abstract修饰的抽象方法，没有方法体，其中的属性都是public final static修饰的静态常量。

• 接口中没有构造方法，不能创建对象。

• 接口通过implements实现，实现它的类称为该接口的实现类。

• 一个类可以同时实现多个接口。

• 一个类实现了接口后，必须重写其中的抽象方法。

• JDK1.8后，可以在接口中定义default方法和static方法，该方法不用重写

static

可以修饰方法、属性或代码块。被修饰的内容称为静态成员。

静态成员在类加载时就会保存到内存中，所以访问静态成员时，无需对象，直接通过类名即可访问。

当某个属性或方法被高度重用时，可以将其定义为静态的，之后通过类名调用。

还可以在类中定义静态代码块static{}，在类加载时自动执行的代码块。

• 静态方法中无法使用非静态成员

• 普通方法中可以使用静态成员

总结

该阶段着重于将思想致力于将计算机中的世界，描述的和现实中一致。概念性的东西很多，不过只要理解了，感觉就很简单了。学习完该阶段，才发现在自己在以前已经将面向对象的思想用于了平时的作业中。路还很长，慢慢来吧，离目标还很远。加油！
fault方法和static方法，该方法不用重写

static

可以修饰方法、属性或代码块。被修饰的内容称为静态成员。

静态成员在类加载时就会保存到内存中，所以访问静态成员时，无需对象，直接通过类名即可访问。

当某个属性或方法被高度重用时，可以将其定义为静态的，之后通过类名调用。

还可以在类中定义静态代码块static{}，在类加载时自动执行的代码块。

• 静态方法中无法使用非静态成员

• 普通方法中可以使用静态成员

总结

该阶段着重于将思想致力于将计算机中的世界，描述的和现实中一致。概念性的东西很多，不过只要理解了，感觉就很简单了。学习完该阶段，才发现在自己在以前已经将面向对象的思想用于了平时的作业中。路还很长，慢慢来吧，离目标还很远。加油！