2019-12-04JavaSE13 分钟读完 (大约 2023 个字) 0次访问

类和对象、this、static、final关键字

【摘要】类和对象、this、static、final关键字~

前言

hi~
先简单聊聊我个人的理解，我理解的面向对象是思想层面的。Oriented Object，简称OO。与面向对象相对于的编程思想是面向过程。
面向过程比较注重的是功能的实现，像C语言那样，以函数为载体，也是基本单位。所有的代码都是由函数来组织的。
面向对象比较注重的是对象的构建，以类为单位，而把功能[方法]封装在类中，以对象为载体，代码都是以类来组织的。
面向对象三大基本特征分别是封装、集成、多态。由面向对象才引申出类和对象的概念。

类和对象

定义

类是对象的抽象化，它是一个抽象的概念。
对象是类的具体化，它是一个具体的概念。

如何知道要定义某个类呢？
以面向对象的思想去描述客观事物的能力，决定你编写代码的思想。
所以，OO的步骤为：
A. 得到一个需求
B. 根据这个需求去找出所涉及到的所有”对象”
C. 利用抽象的能力，把找出的这些“对象”进行“归类”[抽象化的过程]
D. 利用java的语法把它描述成 xxx.java 类型，从而得到这个类。
如何定义一个类？
根据对象拥有的属性和能力来定义一个类型，也可以说，一个类由如下部份组成：
A. 这个类拥有什么？也就是属性。
B. 这个类能干什么？也就是方法。

属性[field]

修饰符数据类型属性名[ = 初始值];
从语法上可以看出，属性的定义与变量基本一样，所以，属性也叫实例变量。
如：

public class A {
    //属性
    private int i;
    private String name;
    //
}

那么一个类，到底应该定义哪些属性呢？要根据所在对象的上下文来定义。
注：同一个类从不同的视角分析同一个对象，所得到的这个对象属性和功能是不一样的。
如：

public class Student {
    //属性：拥有什么？ 它是数据[数据结构]的载体
    private String stuNo; //学号
    private String stuName; //姓名
    private char gender; //性别
    private String major; //专业
    //...
    //方法：能干什么？ 它是算法的载体
    //学习
    public void study() {
        //...
    }
    //考试
    public void exam() {
        //...
    }
    //...
}

注：在Java中，只有三种量：
A. 局部变量[Local variable]
B. 实例变量[instance variable]
C. 类变量,也叫静态属性[class variable]
它们的生命周期大大的不同。
局部变量的生命周期只存在于定义它的那一对大括号中。
实例变量随对象而存在。
类变量随类而存在，只要类加载进JVM,则它就在。

构造方法[constructor]

构造方法是一个特殊的方法，用于类的初始化。当类中没有定义任何的构造方法时，则JVM会自动提供一个默认构造[空参构造]。它有以下特点：
A. 没有返回类型。
B. 方法名必须与类名同名。
C. 支持重载。

注：构造方法的作用：A. 用来给属性赋值的。B. 满足创建对象的语法要求。
注：对象创建的过程：
1).申请堆空间 [对象就创建好了]
2).给属性赋初始值
3).调用构造方法[给属性赋值]
如：

1 2	Student s1 = new Student(); int i;

对象[object]和引用[references]

对象是存放在堆空间中的”数据”。
引用是指向堆空间中对象的地址。

我们必需通过引用去操作对象，而不能直接操作对象。
没有引用，对象是不会单独存在的。

注：一个没有初始化的对象是不能使用的，否则会出现NullPointerException【空指针异常】。
如：

1 2	Student s1 = null; s1.study();// 会出现异常

注：
一个对象可以有多个引用指向它。
一个引用在某一时间最多指向一个对象。

this关键字

1.表示当前对象[current object]。本质就是”创建好的对象的地址”!
由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代“当前对象”。
2.用来同类的调用其它的构造方法。

注：this不能用于static方法中。

static关键字

static是Java中表示修饰符的关键字，根据他所修饰的目标不同进行分析。

修饰方法

被修饰的方法就是静态方法，它将来是通过ClassName来访问的。如：

public class A {
	//
	public static int add(int a, int b) { 
		return a + b;
	}
	//
	public static void main(String args[]){
		int sum = A.add(1,2);
		System.out.println(sum);//3
	}
}

静态方法不能被重写。

修饰属性

被修饰的属性就是静态属性，也叫类变量。
类变量的生命周期和类相同，在整个应用程序执行期间都有效。它是属于“类的”，而不是属于“对象的”。

public class B {
	private int i; //实例变量
	private static int j; //类变量,所有此类的实例共享

	//...
	public void setI(int i) { this.i = i;}
	public int getI() { return this.i; }
	//
	public static void setJ(int j1) { j=j1;}
	public static int getJ(){ return j; }
	//
	public static void main(String args[]){
		B b1 = new B();
		b1.setI(100);
		B b2 = new B();
		b2.setI(200);
		b2.setJ(500);

		System.out.println(B.getJ()); //500
		System.out.println(B.getJ()); //500
	}
}

静态方法不能直接访问非静态成员。
非静态方法可以直接访问静态成员。
静态方法中不能使用this。
因为静态成员和非静态成员在初始化的时机上是不一样的。
有了静态成员后，创建对象的过程如下：
在类加载[classload]时：
- 首先。给静态属性申请空间[永久区]
- 其次，给静态属性赋初始值。
- 最后调用静态代码块[如果有的话]
在创建类的实例时，总是按如下4步递归地创建父类对象：
- 为类的非静态属性申请堆空间
- 给非静态属性赋初始值
- 调用普通代码块[如果有的话]
- 调用构造方法

注：类加载只会发生1次。

修饰代码块

静态代码块只有类加载时被执行1次。
所以，它适合用来执行：
A. 加载一些大的、固定的资源，如文件
B. 建立连接池
…
注：静态代码块不能直接访问非静态属性。

修饰内部类

被修饰的类称为静态内部类。
如：

public class Outer {
	//属性
	....
	//
	static class Inner {
		//属性

		//方法
		...
	}
	//方法
}

final关键字

final和static都是表示修饰符的关键字，所以我们也根据他所修饰的目标不同进行分析。

修饰局部变量，就称为常量。

如：

1	final int I = 9; //局部常量

修饰属性，就成了常量属性。

如：

public class A {
	//public final int I = 9; //属性
	public static final int I = 9; //属性
	//...
}

注：常量属性往往都是再加static修饰。

修饰方法，就成了最终方法。

如：

public class A {
	//...
	public final void f() {
		//....
	}	
}

注：final方法是不能被子类重写的。

修饰类，就成了最终类。

如：

public final class B {
	//..
}


public class C extends B { //报错
	//..
}

注：final类是不能被继承的。

问：abstract和final能共同修饰一个类吗？
答：不能。

问：abstract和private、static能共同修饰一个方法吗？
答：不能。

结束语

bye~

#JavaSE