（类的加载过程 创建过程 ）
一、OOP概述
Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程(Object-Oriented Programming, OOP)。
1)抽象(abstract)
忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用关注细节。
例如:要设计一个学生成绩管理系统，那么对于学生，只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息
2)封装(Encapsulation)
封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过指定的方式。
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。
封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。
3)继承(inheritance)
继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。
新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。
派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增加新的方法使之更适合特殊的需要
继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。
4)多态(polymorphism)
多态性是指允许不同类的对象对同一消息作出响应。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
相同类域的不同对象,调用相同方法,表现出不同的结果
例如:
public class Person{
public void say(){}
}
public class Student extends Person{
public void say(){
System.out.println("I am a student");
}
}
public class Teacher extends Person{
public void say(){
System.out.println("I am a teacher");
}
}
main:
Person s = new Student();
Person t = new Teacher();
s.say();
t.say();
二、类与对象和对象与引用的关系
2.1、类与对象的关系
类是一种抽象的数据类型,它是对一类事物整体描某述/定义,但是并不能代表某一个具体的事物.
例如:我们生活中所说的词语:动物、植物、手机、电脑等等
这些也都是抽象的概念,而不是指的某一个具体的东西。
例如: Person类、Room类、Car类等
这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
例如:
张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念.
例如:
Student s = new Student(1L,"tom",20);
s.study();
Car c = new Car(1,"BWM",500000);
c.run();
对象s就是Student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。类只是给对象的创建提供了一个参考的模板而已.
但是在java中,没有类就没有对象,然而类又是根据具体的功能需求,进行实际的分析,最终抽象出来的.
2.2、对象和引用的关系
引用"指向"对象
使用类类型、数组类型、接口类型声明出的变量,都可以指向对象,这种变量就是引用类型变量,简称引用。
在程序中,创建出对象后,直接使用并不方便,所以一般会用一个引用类型的变量去接收这个对象,这个就是所说的引用指向对象.
总结:对象和引用的关系,就如电视机和遥控器,风筝和线的关系一样。
三、方法的定义和调用
方法一定是定义在类中的,属于类的成员。
3.1、方法的定义
格式： 修饰符 返回类型 方法名(参数列表)异常抛出类型{...}
1)修饰符:
public static abstract final等等都是修饰符,一个方法可以有多个修饰符.例如程序入口main方法,就使用了public static这个俩个修饰符
注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的
2)返回类型:
方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必须写void.
只有构造方法(构造器)不写任何返回类型也不写void
例如:
public String sayHello(){
return "hello";
}
public int max(int a,int b){
return a>b?a:b;
}
public void print(String msg){
System.out.println(msg);
}
思考:声明返回类型的方法中一定要出现return语句,那么没有返回类型(void)的方法中,能不能出现return语句?
注:break和return的区别
3)方法名:
遵守java中标示符的命名规则即可.
4)参数列表
根据需求定义,方法可以是无参的,也可以有一个参数,也可以有多个参数
5)异常抛出类型
如果方法中的代码在执行过程中,可能会出现一些异常情况,那么就可以在方法上把这些异常声明并抛出,也可以同时声明抛出多个异常,使用逗号隔开即可。
例如:
public void readFile(String file)throws IOException{
}
public void readFile(String file)throws IOException,ClassNotFoundException{
}
3.2、方法调用
在类中定义了方法,这个方法中的代码并不会执行,当这个方法被调用的时候,方法中的代码才会被一行一行顺序执行。
1)非静态方法
没有使用static修饰符修饰的方法,就是非静态方法.
调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)
例如:
public class Student{
public void say(){}
}
main:
Student s = new Student();
s.say();
2)静态方法
使用static修饰符修饰的方法,就是静态方法.
调用这种方法的时候,"可以"使用对象调用,也"可以"使用类来调用,但是推荐使用类进行调用,因为静态方法是属于类的。(静态属性也是一样的)
例如:
public class Student{
public static void say(){}
}
main:
Student.say();
3)类中方法之间的调用
假设同一个类中有俩个方法,a方法和b方法
a和b都是非静态方法,相互之间可以直接调用.
public void a(){
b();
}
public void b(){
}
a和b都是静态方法,相互之间可以直接调用.
public static void a(){
b();
}
public static void b(){
}
a静态方法,b是非静态方法
a方法中不能直接调用b方法,但是b方法中可以直接调用a方法.
public static void a(){
//b();报错
}
public void b(){
a();
}
另外:在同一个类中,静态方法内不能直接访问到类中的非静态属性.
总结：类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法是静态，一个方法是非静态的时候，非静态方法可以调用静态方法，反之不能。
四、调用方法时的传参
1)形参和实参
例如:
// a = x;
public void test(int a){
//..
}
main:
int x = 1;
t.test(x);
参数列表中的a是方法test的形参(形式上的参数)
调用方法时的x是方法test的实参(实际上的参数)
注意:形参的名字和实参的名字都只是一个变量的名字,是可以随便写的,我们并不关心这个名字,而是关心变量的类型以及变量接收的值。
2)值传递和引用传递
调用方法进行传参时,分为值传递和引用传递两种。
如果参数的类型是基本数据类型,那么就是值传递。
如果参数的类型是引用数据类型,那么就是引用传递。
值传递是实参把自己变量本身存的简单数值赋值给形参.
引用传递是实参把自己变量本身存的对象内存地址值赋值给形参.
所以值传递和引用传递本质上是一回事,只不过传递的东西的意义不同而已.
3)值传递的示例
public class Test{
public static void changeNum(int a){
a = 10;
}
public static void main(String[] args){
int a = 1;
System.out.println("before: a = "+a);//1
changeNum(a);
System.out.println("after: a = "+a);//1
}
}4)引用传递的示例
public class Test{
public static void changeName(Student s){
s.name = "tom";
}
public static void main(String[] args){
Student s = new Student();
System.out.println("before: name = "+s.name);//null
changeName(s);
System.out.println("after: name = "+s.name);//“tom”
}
}五、this关键字
在类中,可以使用this关键字表示一些特殊的作用。
5.1、this在类中的作用
1)区别成员变量和局部变量
public class Student{
private String name;
public void setName(String name){
//this.name表示类中的属性name
this.name = name;
}
}2)调用类中的其他方法
public class Student{
private String name;
public void setName(String name){
this.name = name;
}
public void print(){
//表示调用当前类中的setName方法
this.setName("tom");
}
}注:默认情况下,setName("tom")和this.setName("tom")的效果是一样的.
3)调用类中的其他构造器
public class Student{
private String name;
public Student(){
//调用一个参数的构造器,并且参数的类型是String
this("tom");//直接调用下面的参数构造器
}
public Student(String name){
this.name = name;
}
}注:this的这种用法,只能在构造器中使用.普通的方法是不能用的.并且这里调用的代码只能出现在构造器中的第一句.
例如:
public class Student{
private String name;
//编译报错,因为this("tom")不是构造器中的第一句代码.
public Student(){
System.out.println("hello");
this("tom");
}
public Student(String name){
this.name = name;
}
}5.2、this关键字在类中的意义
this在类中建表示当前类将来创出的对象.
例如:
public class Student{
private String name;
public Student(){
System.out.println("this = "+this);
}
public static void main(String[] args){
Student s = new Student();
System.out.println("s = "+s);
}
}运行后看结果可知,this和s打印的结果是一样的,那么其实也就是变量s是从对象的外部执行对象,而this是在对象的内部执行对象本身.
这样也就能理解为什么this.name代表的是成员变量,this.setName("tom")代表的是调用成员方法,因为这俩句代码从本质上讲,和在对象外部使用变量s来调用是一样的,s.name和s.setName("tom")。
this和s打印出来的内存地址是一样的,使用==比较的结果为true。
例如:
public class Student{
public Student getStudent(){
return this;
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = s1.getStudent();
System.out.println(s1 == s2);//true
}
}例如: 类中的this是和s1相等还是和s2相等呢?
public class Student{
private String name;
public void test(){
System.out.println(this);
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
s1.test();
s2.test();
}
}注:这句话是要这么来描述的,s1对象中的this和s1相等,s2对象中的this和s2相等,因为类是模板,模板中写的this并不是只有一个,每个对象中都有一个属于自己的this,就是每个对象中都一个属于自己的name属性一样.
六、创建与初始化对象
使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用
那么对main方法中的以下代码:
Student s = new Student();
1)为对象分配内存空间,将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋值)
2)如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象)
例如:显式赋值
private String name = "tom";
3)调用构造器
4)把对象内存地址值赋值给变量。(=号赋值操作)
七、构造器
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
1)必须和类的名字相同
2)必须没有返回类型,也不能写void
构造器的作用:
1)使用new创建对象的时候必须使用类的构造器
2)构造器中的代码执行后,可以给对象中的属性初始化赋值
例如:
public class Student{
private String name;
public Student(){
name = "tom";
}
}构造器重载:
除了无参构造器之外,很多时候我们还会使用有参构造器,在创建对象时候可以给属性赋值.
例如:
public class Student{
private String name;
public Student(String name){
this.name = name;
}
}构造器之间的调用:
使用this关键字,在一个构造器中可以调用另一个构造器的代码。
注意:this的这种用法不会产生新的对象,只是调用了构造器中的代码而已.一般情况下只有使用new关键字才会创建新对象。
例如:
public class Student{
private String name;
public Student(){
this();
}
public Student(String name){
this.name = name;
}
}默认构造器:
在java中,即使我们在编写类的时候没有写构造器,那么在编译之后也会自动的添加一个无参构造器,这个无参构造器也被称为默认的构造器。
例如:
public class Student{
}
main:
//编译通过,因为有无参构造器
Student s = new Student();
但是,如果我们手动的编写了一个有参构造器,那么编译后就不会添加任何构造器了，可以把默认的午无参构造器写出来
例如:
public class Student{
private String name;
public Student(String name){
this.name = name;
}
}
main:
//编译报错,因为没有无参构造器
Student s = new Student();//调用无参构造器 但是没有八、类的加载顺序
public class Test1 {
public static void main(String[] args) {
SingleTon1 singleTon1 = SingleTon1.getInstance();
System.out.println("count1=" + singleTon1.count1);
System.out.println("count2=" + singleTon1.count2);
// public static int value=123;//在准备阶段value初始值为0 。在初始化阶段才会变123
System.out.println(SubClass.value);// 被动应用1 直接访问类的商量，如果需要引用 父类，则父类初始化，子类不会初始化
SubClass[] sca = new SubClass[10];// 被动引用2
}
}
class SuperClass {
static {
System.out.println("superclass init");
}
public static int value = 123;
}
class SubClass extends SuperClass {
static {
System.out.println("subclass init");
}
}
public class SingleTon1 {
private static SingleTon1 singleTon1 = new SingleTon1();//调用空构造器
public static int count1;
public static int count2 = 0;
SingleTon1() {
count1++;
count2++;
}
public static SingleTon1 getInstance() {
return singleTon1;
}
}结果分析：
1:SingleTon singleTon = SingleTon.getInstance();调用了类的SingleTon调用了类的静态方法，触发类的初始化
2:类加载的时候在准备过程中为类的静态变量分配内存并初始化默认值 singleton=null count1=0,count2=0
3:类初始化化，为类的静态变量赋值和执行静态代码快。singleton赋值为new SingleTon()调用类的构造方法
4:调用类的构造方法后count=1;count2=1
5:继续为count1与count2赋值,此时count1没有赋值操作,所有count1为1,但是count2执行赋值操作就变为0
关系到类的加载顺序：
类加载的机制：
类从被加载到虚拟机内存中开始，直到卸载出内存为止，它的整个生命周期包括了：加载->验证->准备->解析->初始化->使用->卸载这7个阶段 ，其中，验证、准备和解析这三个部分统称为连接（linking）。
加载->（验证->准备->解析）-> 初始化-> 使用->卸载 （括号内表示链接阶段）
加载、验证、准备 初始化 卸载这五个阶段的顺序是确定的，
原因：类初始化，为类的静态变量赋值和执行静态代码快
类的初始化 时机：
1 创建类的实例 会使得类初始化
2 访问类的静态变量(除常量【被final修辞的静态变量】原因:常量是一种特殊的变量，因为编译器把他们当作值(value)而不是域(field)来对待。
如果你的代码中用到了常变量(constant variable)，编译器并不会生成字节码来从对象中载入域的值，而是直接把这个值插入到字节码中。
这是一种很有用的优化，但是如果你需要改变final域的值那么每一块用到那个域的代码都需要重新编译。
3 访问类的静态方法
4 反射如(Class.forName("my.xyz.Test")) (反射使用的时候)
5 当初始化一个类时，发现其父类还未初始化，则先触发父类的初始化 ，其子类则不会初始化。 除非有其它几种情况产生
6 虚拟机启动时，定义了main()方法的那个类最先初始化
总结：以上情况称为对一个类进行“主动引用”，除此种情况之外，均不会触发类的初始化，称为“被动引用 “接口的加载过程与类的加载过程稍有不同。接口中不能使用static{}块。当一个接口在初始化时，并不要求其父接口全部都完成了初始化， 只有真正在使用到父接口时（例如引用接口中定义的常量）才会初始化。