菜鸟修行之路----java语言基础一：面向对象基础

对于面向对象，百度百科的定义：

一切事物皆对象，通过面向对象的方式，将现实世界的事物抽象成对象，现实世界中的关系抽象成类、继承，帮助人们实现对现实世界的抽象与数字建模。

面向对象三大特性：继承，封装，多态。

  • 封装主要是隐藏内部代码；
  • 继承主要是复用现有代码；
  • 多态主要是改写对象行为。

1.1 类

**类：**通过对于具有某一些共同特性的事物进行抽象得到的结果就是类。

**对象：**通过类来确定具体结果的过程就是实例化，而实例化的结果就是对象。

1.1.1类的基础概念

类的定义：

public class 类名{
    成员变量;
    成员方法;
}

类声明：

类的声明位于类的开头，由以下4部分组成：

  • 类修饰符:表明类的类别，可选值有：
    public：声明该类可以在其他类中实例化。
    abstract：声明该类是一个抽象类，不可被实例化。
    final：声明该类不可被继承，不会有子类。
  • 类关键字class
  • 声明父类： java只支持单继承，所有extends后只能跟一个父类名。
  • 实现接口 ：java可以通过接口实现多态，一个类可以实现多个接口，在implements关键字后跟着接口列表。

实例：

public class 类名 extends 父类名 implements 接口列表

1.1.2变量

变量按照不同的声明位置分类2类：

  • 成员变量：在类体中定义，整个类中都有效。
  • 局部变量：在方法中定义，只在本方法中定义。

实例：

public class exp_one{
    //成员变量
    public int a;
    public void test{
    //局部变量
    public int b;
    public int a;//局部变量与成员变量同名，则成员变量被屏蔽。
    this.a//可以通过this来调用成员变量。
    }
}

变量声明：【可访问修饰符】【static】【final】【volatile】

【可访问修饰符】：表明该变量的可访问属性，权限（方法与变量相同）。

访问权限

同一类

同一个包

不同包子类

不同包非子类

public

Y

Y

Y

Y

protected

Y

Y

Y

N

缺省

Y

Y

N

N

private

Y

N

N

N

【static】:声明为静态变量

【final】：声明为常量

1.1.3方法

**方法：**类与对象的属性操作，成员方法在类的内部声明并加以是实现。由以下2部分组成：

  • 方法声明：在声明中确定方法访问权限，方法返回值类型，方法名,参数列表。
  • 方法体：包括局部变量声明，方法的功能实现，方法返回值。

实例：

public class exp_two{
    
    public void a(int a){
        //。。。
        //。。。
        return(返回值);
    }
}

参数传递：包括2类，参数传递，引用传递。

特殊的方法：构造方法

主要用于初始化新建的对象。方法名与类名相同，无返回值。并且只能通过new()调用。

实例：

public class exp_two{
    private int a;
    //构造方法
    exp_two(int a){
        this.a=a;
    }
    
    public void a(int a){
        //。。。
        //。。。
        return(返回值);
    }
}

1.1.4特殊的类：抽象类与接口

接口：

接口是一种特殊的抽象类，只包含常量和方法的定义，没有变量和方法的具体实现。规范和具体实现的分离。

  • 接口中的方法默认时public abstract
  • 接口不能实例化对象 可以用来声明引用变量的类型
  • 一个类实现一个接口，那么必须实现这个接口中定义的所有方法，并且只能是public

声明：

[访问修饰符号] interface 接口name [extends 父接口1，父接口2] {
	常量定义：
	方法定义：
}

抽象类：

只要由abstract修饰的类就是抽象类，抽象类里可以包含普通方法以及抽象方法，不可被实例化。

接口和抽象类的区别

接口

抽象类

接口中是没有实现代码的实现

抽象类中可以有普通成员方法 ，并且可以定义变量

接口中的方法修饰符号 只能是public

抽象类中的抽象方法可以有public,protected,default

接口中没有构造方法

有构造方法

1.2封装

将对象的数据以及数据操作结合成一个独立的单位，尽可能的隐藏对象的内容和细节，只向外界提供最简单的编程接口,增强程序的安全性。

对象就是对一组变量和相关方法的封装。

通过对于类中的变量以及方法的修饰（4种修饰符，具体参见上文 ）实现访问权限的控制。

1.3继承

继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继
承信息的类被称为子类（派生类）。

java不支持多重继承，所以extends关键字后只能跟一个父类名。

子类定义

class 子类名 extends 父类名

重要总结：

  • 子类可以重写父类的方法以及成员变量（隐藏），可以通过super关键字调用重名的父类的成员变量。
  • 子类会继承父类的构造方法，并且java虚拟机会优先执行父类的构造方法。

实例：

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

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;
    
    //父类成员变量的隐藏
    private int id;

    public int getScore() {...}
    public void setScore(int score) {...}
    
    public void (){
        super.id;//调用父类的成员变量
    }
}

1.4 多态

多态性：允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。

多态性分为:

  • 编译时的多态性:方法重载（overload,多个方法重名，但是参数不同（参数类型或者参数个数））实现的是编译时的多态性（也称为前绑定）
  • 运行时的多态性:方法重写（override）实现的是运行时的多态性（也称为后绑定）

运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：

  1. 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
  2. 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

重载与重写的区别：

区别点

重载

重写（覆写）

定义

方法名称相同，参数的类型或个数不同；对权限没有要求

方法名称，参数类型，返回值类型全部相同

范围

发生在一个类中

发生在继承类中

方法重载实例：

public void area(int a){
    return a*a;
}
public void area(int a,int b){
    return a/b;
}

方法重写实例：

class Animal {
    public void sound {...}
}
class Cat {
    @Override
    public void sound {
        System.out.println("meow")
    }
}

后记：修行之路艰辛，与君共勉。

—2020年春：成都