JAVA面向对象部分知识点总结

问题导入：面向对象是什么？

        面向对象程序设计的思维方式是一种更符合人们思考习惯的方式。面向对象将构成问题的事物分解成各个对象，这些对象是为了描述某个事物在整个问题解决步骤中的行为。面向对象以对象为核心，强调事件的角色、主体，在宏观上使用面向对象进行把控，而微观上依然是面向过程。如果说面向过程的思想是执行者，那么面向对象的思想就是指挥者。
下图为关于面向对象部分知识点的简要梳理：

 1、类与对象

1.1 类

1.1.1 类的介绍

     将现实生活中一类事物抽象化，提取出这一类事物共有的属性和行为，是共同特征的描述。所以，可以认为 Java 类是定义变量和对象的方法的模型。定义物体属性和方法的阶级特征和行为。一个类是定义的，它可以用来创建该类的实例（对象）。

1.1.2 类的定义

        类主要有变量（字段）和方法组成。

 变量的定义：

 修饰符  变量类型  变量名  =  [默认值];

方法的定义： 

修饰符  返回值类型  方法名（形参列表）{} 

1.1.3 注意事项

        类名首字母建议大写，需要见名知意，驼峰模式，不能用关键字。

        一个Java文件中可以定义多个class类，但最多只能有一个public修饰的类。而且public修饰的类名必须成为代码文件名。

1.2 对象 

1.2.1 对象的介绍

        对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。 

1.2.2 对象的创建

 类名称  对象名称  =  new  类名称（）；

1.2.3 如何使用对象 

访问属性：对象名.成员变量

访问行为：对象名.方法名（…） 

2、三大特征 

 

2.1 封装

2.1.1 什么是封装 

        封装指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。封装能够在一定程度上提高代码的安全性和复用性，使使用时只需要了解使用方式，不需要知道内部细节。原则： 对象代表什么，就得封装对应的数据，并提供数据对应的行为。

 2.1.2 get()/set()方法

      封装对类中的域变量进行封闭操作，即用private来修饰他们，如此一来其他类则不能对该变量访问。这样我们就将这些变量封闭在了类内部，无法直接使用和操作。需要通过set方法和get方法进行对变量的赋值和获取值。get()方法用于获取值，set()方法用于赋值。
  

 public class People {
private String name;
private int age;
public People(String  name,int age){

        this.name=name;

        this.age=age;

}

public String getName(）{

        return name;

}

public void setName(String  name){

        this.name=name;

}

public int getAge(){

        return age;

}

public  void setAge(int age){

        this.age=age;

}
}

2.2 继承

2.2.1 什么是继承 

        对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原有类的特性，新类称为原有类的子类，原有类称为新类的父类。子类可以从它的父类中继承方法和实例变量。其实质是代码的复用。

特性：

1. 单一继承：Java中每个类只能继承一个父类，即一个子类只能有一个直接父类。

2. 多层继承：一个类可以有多个子类，子类可以再次作为其他类的父类，形成多层继承关系。

3. 子类继承父类的属性和方法：子类会继承父类的非私有属性和方法，可以直接使用父类中的属性和方法。

4. Java中的所有类最终都继承自Object类，可以通过重写Object类的方法对所有类的行为进行统一定制。

2.2.2 继承的使用 

         JAVA中使用extends关键字表示继承。

class  父类类名{

……

} 

class  子类类名  extends  父类类名{

… 

}

 2.2.3 super关键字

        super 可以理解为直接父类对象的引用，或者说super 指向子类对象的父类对象存储空间。可以通过super 访问父类中被子类覆盖的方法或属性。除private 修饰的属性和方法外，子类可以通过super 关键字调用父类中的属性和方法，它的作用是解决子类和父类中属性、方法重名问题。使用方式如下：

super.属性-------------访问超类的成员变量

super.方法（）---------------调用超类的方法

super（参数列表）-----------------调用超类的构造方法

查找范围：直接查找父类。调用构造方法时，调用父类构造方法，放在第一条语句。 需要注意的是，super关键字只能在子类中使用，用于指代当前子类对象所属的父类对象。

2.3 多态 

2.3.1什么是多态

        多态是指同一类型的对象在不同情况下表现出不同的行为。多态性通过方法的重写和重载来实现。多态的前提是必须存在继承，并且子类重写了父类的方法，最重要的一点是父类引用要指向子类对象。

2.3.2重写和重载

 重写：根据对象的不同来表现多态。子类可以继承父类的方法，并在子类中重新定义该方法的实现。当子类对象调用这个方法时，将执行子类的方法实现，而不是父类的方法实现。

重载：根据参数的不同来表现多态。Java中的多态性还可以通过方法的重载和重写来实现。重载是指在同一个类中定义多个方法，它们有相同的名字但参数不同。

2.3.3引用类型数据转换 

向上转型：父类引用指向子类对象，属于自动类型转换。格式：

父类类型 变量名  =  子类对象；

向下转型：子类引用指向父类对象，属于强制类型转换。格式：

子类类型 变量名  =（子类类型）父类对象；

3、方法 

3.1 构造方法 

 3.1.1什么是构造方法

        构造方法也称作构造器（constructor），用于给对象进行初始化操作，即为对象成员变量赋初始值。它与类同名且没有返回值类型。构造方法分为有参构造和无参构造两类。构造方法的调用必须通过 new 关键字调用，语法格式如下所示。

修饰符  类名(形参列表)  {   }

3.1.2构造方法的特性      

1. 给成员变量赋初值。
2. 构造方法的名称与类名相同，没有返回值类型。
3. 构造方法可以有参数，也可以没有参数。
4. 构造方法可以重载，但不能被重写。
5. 如果没有在类中显式定义构造方法，编译器会为类生成一个默认的无参构造方法。
6. 如果在类中显式定义了构造方法，编译器不会生成默认的无参构造方法。

3.1.3注意事项 

1.构造方法可以重载，但是不能重写，因为构造方法不能被继承。
2.如果在子类的构造方法中，没有显式的使用关键字super调用父类的某个构造方法，那么会默认隐式的使用super调用父类无参构造方法。
3.如果类里定义一个或多个构造方法，那么java不提供默认的构造方法（不带参数的构造方法)。因此，当在父类中定义多个构造方法时，应当补充一个不带参数的构造方法，以防子类省略super时出现错误。

3.2 方法的重载

        在JAVA中，无论是普通方法，还是构造方法，都可以进行重载。我们在调用重载的方法时，会根据传递的参数不同，来执行不同的方法。通过方法的重载，我们就可以把一系列功能相似，但参数不同的方法，用同一个方法名进行定义。
 要求：

1、同名不同参（参数类型、个数、顺序不相同）

2、方法重载和返回参数类型无关

3、方法重载和访问修饰符无关

构造方法重载，构造方法没有返回值。 

3.3 方法的重写

         子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。

重写方法被调用时，看对象的类型

私有方法不能被重写(父类私有成员子类是不能继承的)
重写时子类方法访问权限不能低于父类
父类中的静态方法不能被重写，如果子类也有相同的方法，并不是重写的父类的方法，而是将父类同名的方法隐藏了起来

子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

重写与重载的区别：1、重载发生在本类，重写发生在父类与子类之间；2、重载的方法名必须相同，重写的方法名相同且返回值类型必须相同；3、重载的参数列表不同，重写的参数列表必须相同。

3.4 this关键字

        this关键字在成员方法或者构造方法中使用，用来调用当前对象的成员变量、成员方法或构造方法，它代表当前对象。

 this.成员变量名------------------访问成员变量

this.方法名()-----------------------调用方法

this(参数列表)--------------------------调用构造方法

调用构造方法：调用本类构造方法，放在第一条语句。

查找范围： 先从本类找，若找不到，则查找父类。

4、修饰词

4.1 访问修饰符

JAVA中访问修饰符有四个，分别是private、protected、public、默认（无修饰符）

public（公开的）：被其修饰的方法、变量任何类都可以进行访问。

private（私有的）：被其修饰的方法、变量仅同一个类可以进行访问。

protected（受保护的）：被其修饰的方法、变量可以被本类、同一个包和子类进行访问。

默认的：不写访问修饰符，表示默认的，被其修饰的方法、变量可以被本类、同一个包进行访问。

优先级：public > protected > default （本类、同一包）> private

4.2 其他修饰符

4.2.1 static

         在类中，将与成员变量同级的用static修饰的变量称为静态变量或类变量。Static关键字也可以修饰方法，用static修饰的方法称为静态方法或类方法。静态变量和静态方法可以直接通过类名调用，任何的实例也都可以调用。静态成员在整个程序执行过程中只有一份拷贝，因此可以用于共享数据。

注意：静态方法中不能用this和super关键字。

static变量的生命周期取决于类的生命周期。

类初始化顺序：

 静态变量、静态代码块初始化
 构造函数
自定义构造函数

4.2.2 final关键字

        final是一个修饰符，它可用来修饰类、类中的属性和方法以及局部变量，但是不能修饰构造方法。final的特性主要有下面4种。

• final 修饰的类不可以被继承，但是可以继承其他类。
•final  修饰的方法不可以被重写。
•final  修饰的变量是常量，只能被赋值一次。
•final 修饰的引用类型变量不能改变它的引用地址，但是可以改变对象内部属性的值。 

4.2.3 abstract

        Java中，抽象的关键字是abstract，不管是抽象类还是抽象方法，都用abstract字修饰，用法如下：

权限修饰符  abstract  class  类名 {  } 

权限修饰符  abstract   返回值类型  方法名（参数列表）；

抽象类注意点：不能创建对象，必须有子类继承抽象类。 

4.3 包

4.3.1 package

         JAVA通过package关键字声明一个包。包名的命名要求遵循标识符规则。

1)作用：避免类名的冲突
2)包名可以有层次结构，类的全称：包名.类名
3)建议：包名所有字母都小写
4）同包中的类不能同名

4.3.2 import

         同包中的类可以直接访问，不同包中的类不能直接访问，当要使用一个类时，这个类与当前程序不在一个包中，必须导入包。只能如下两种访问方式：

1.先import声明类再使用类----------建议

2.类的全称-----(java.lang.object )……----------太繁琐、不建议

使用import关键字导入Java中的包，语法格式如下:

 import  包名.类名；

 5、接口

        接口：接口是一种特殊的抽象类，当抽象类中的方法都是抽象方法的时候，该抽象类可以用另一种形式定义和表示，那就是接口interface。接口的特性如下 ：

1)是一种数据类型（引用类型）。
2)由interface定义。

interface  接口名[ extends 父接口1，父接口2，…]{

        //常量定义

        //方法定义

}

3)只能包含常量和抽象方法。
4)不能被实例化。
5)接口是需要被实现/继承的，实现类/派生类:必须重写接口中的所有抽象方法。
6)一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现。
7)接口可以继承接口。