Java面向对象知识点（上）

1.面向对象

面向对象是把构成问题的事物按照一定规则划分为多个独立的对象，然后通过调用对象的方法解决问题，特点主要可以概括为封装性、继承性、多态性。

封装性：面向对象的核心思想，有两层含义：一指把对象的属性和行为看成一体，二指隐藏不想让外界知道的信息。

继承性：描述类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下扩展功能。

多态性：一个类中定义的属性和方法被其它类继承后，可以具有不同的数据类型或表现出不同的行为，使得同一属性和方法在不同类中具有不同的语义。

2.类与对象

2.1类的定义

类是Java中一个重要的引用数据类型，也是组成Java程序的基本要素。

类是对象的抽象，用于描述一组对象的共同特征和行为。类中可以定义成员变量（属性）和成员方法（方法），成员变量描述对象的特征，成员方法描述对象的行为。类的定义格式如下：

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

注意：成员方法中可以直接访问成员变量，但当某一方法中定义的局部变量与成员变量同名时，在方法中通过变量名访问到的是局部变量。

2.2对象的创建与使用

要想使用类就要有对象，Java中使用new关键字创建对象，创建对象分为声明对象和实例化对象两步，也可以一步完成，格式如下：

类名 对象名称 = new 类名();

使用new关键字创建的对象，对象名称保存在栈内存中，对象的属性信息在对应的堆内存中。

创建对象后可以使用对象，通过“.”运算符访问类中的某个属性或方法，格式如下：

对象名称.属性名
对象名称.方法名

2.3对象的引用传递

引用传递是指，将一个堆内存空间的使用权给多个栈内存空间使用，例如：

Student stu1 = new Student();
Student stu2 = new Student();
stu2 = stu1;
stu1.age = 10;
stu2.age = 20;

其中，stu2获得了stu1的堆空间使用权，最终stu1、stu2的age属性都为20。

注意：一个栈内存空间只能指向一个堆内存空间。

2.4访问控制

针对类、成员方法、属性，Java提供了4中访问控制权限，级别由小到大为：private-default-protected-public

public class Test{                    //aa可以被所有类访问
    public int aa;
    protected boolean bb;             //bb可以被所有子类以及本包的类访问
    void cc(){                        //cc是default权限，能在本包范围内使用
           System.out.println();
    }
    private class InnerClass{         //私有的内部类，只能在本类使用
    }
}

类名Test只能使用public修饰或者不写修饰符。

注意：局部成员没有访问权限控制，因为只在其所在的作用域内起作用，不可能被其他类访问到。

如果源文件中定义的所有类都没有使用public修饰，那么源文件名可以为一切合法的文件名；如果定义了一个public修饰的类，那么该源文件的文件名必须与其类名相同。

3.封装性

类的封装是指将对象的状态信息隐藏在对象内部，不允许外部成员直接访问，而是通过该类提供的方法实现。

使用private关键字修饰类的属性，将其私有化。通过setter和getter方法设置和获取属性值，如：

class Student{
    private int age;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
}
public class Test{
    public static void main(String[] args){
        Student stu = new Student();
        stu.setAge(18);
    }
}

4.构造方法

4.1定义构造方法

由上可知，实例化对象后为属性赋值通过直接访问对象的属性或调用setter方法。

如果需要在实例化对象时为对象的属性赋值，则通过构造方法实现。

构造方法（构造器）的是类的一个特殊成员方法，在类实例化对象时自动调用。

Java中的每个类都至少有一个构造方法，如果一个类中没有定义它，那么系统会自动创建一个默认无参的构造方法，方法体中也没有任何代码，如下写法效果一样：

class Student{
}

class Student{
    public Student(){
    }
}

定义的构造方法的名称必须与类名一致，当定义了构造方法后，系统不再提供默认的构造方法。

4.2构造方法的重载

构造方法可以重载。

class Student{
    private String name;
    private int age;
    public Student(){}
    public Student(String n){
            name = n;
    }
    public Student(String n,int a){
            name = n;
            age = a;
    }
}

一般如果定义了有参构造方法，最好再定义一个无参构造方法。

注意：构造方法通常用public修饰；构造方法不能有任何返回值。

5.代码块

代码块是用“{}”括起来的一段代码，根据位置及声明关键的不同，可以分为普通代码块、构造块、静态代码块、同步代码块。

普通代码块是直接在方法或语句中定义的代码块，如：

public class Test{
    public static void main(String[] args){
         System.out.println("这是普通代码块");
}

构造块（构造代码块）是直接在类中定义的代码块，定义在成员位置，与构造方法、成员属性同级。注意：构造块的执行顺序优先于构造方法。

class Student{
    String name;
    {
        System.out.println("这是构造代码块");
    }
}

6.this关键字

当成员变量与局部变量重名时，需要用this关键字分辨。

使用“this.”可以访问当前对象的成员属性、成员方法，如：

class Student{
    String name;
    int age;
    public Student(name,age){
    this.name=name;
    this.age=age;
    }
}

可以在一个构造方法中使用"this(参数1,参数2...)"调用其他的构造方法，该语句必须位于第一行，且只能出现一次,如：

class Student{
    String name;
    int age;
    public Student(){}
    public Student(String name,int age){
        this();
        this.name=name;
        this.age=age;
    }
}

不能在一个类的两个构造方法中使用this互相调用，如：

class Student{
    public Student(){
        this.("张三");
    }
    public Student(String name){
        this.();
    }
}

注意：this可以在实例方法、构造方法中使用、不能出现在静态方法（类方法）中。

7.static关键字

7.1静态属性

使用static关键词修饰的属性称为静态属性（全局属性），只会分配一块内存空间，被所有对象共享，可以直接使用类名称访问，如：

class Student{
    String name;
    static String school = "A大学";
    public Student(String name){
        this.name = name;
    }
}
public class Test{
    pulic staic void main(String[] args){
        Student stu1 = new Student("张三");
        Student stu2 = new Student("李四");
        stu1.school="B大学";
    }
}

最终stu1、stu2的school属性都为B大学。

注意：static关键字只能修饰成员变量，不能修饰局部变量，如：

7.2静态方法

使用static关键词修饰的属性称为静态方法，也可以直接通过类名称访问。

class Student{
    private static String school = "A大学";
    public String getSchool(){
        return school;
    }
    public void setSchool(String school){
        this.school = school;
    }
}
public class Test{
    pulic staic void main(String[] args){
        Student stu1 = new Student();
        Student stu2 = new Student();
        Student.setSchool="B大学";
    }
}

最终stu1、stu2的school属性都为B大学。

注意：静态方法只能访问静态成员，因为非静态成员需要先创建对象才能访问（才会被分配内存）。

7.3静态代码块

使用static关键词修饰的代码块称为静态代码块，在类第一次使用时被加载，由于类只加载一次，所以静态代码块只执行一次。通常使用静态代码块对类的成员变量初始化。

注意：代码块的执行顺序为静态代码块、构造代码块、构造方法。static修饰的成员随着class文件一同加载，优先级最高，如：

class Student{
    {
        System.out.println("这是构造代码块");
    }
    static{
        System.out.println("这是静态代码块");
    }
    public Student(){
        System.out.println("这是构造方法");
    }
}

结果为先输出静态代码块，再输出构造代码块，最后是构造方法。