包、封装、多态、静态变量和方法

包

*@包的三大作用：

1.区分相同名字的类(一个包里类名不能重名)

2.当类很多时，可以很好的管理类（仿照Java API文档）

3.控制访问范围

***包的基本语法：

package com.wyedu;

1.package 关键字:表示打包。

2.com.wyedu :表示包名。

***包的本质分析：

实际上就是创建不同的文件夹/目录来存放类文件 。

***包的命名：

-命名规则：

只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字。

-命名规范：

一般是，小写字母+小圆点 比如： com.公司名.项目名.业务模块名

ect：com.sina.crm.user//用户模块

com.sina.crm.order//订单模块

com.sina.crm.utils//工具类

*@常用的包：

一个包下，包含很多的类，常用的有：

-----java.lang.* //lang包是基本包，默认引入，不需要再引入

-----java.util.* //util包，系统提供的工具包，工具类，使用Scanner

-----java.net.* //网络包，网络开发

-----java.awt.* //是做java的界面开发，GUL

***如何引入包？

文件：package exercise.Import01.java

语法：import包;

我们引入一个包的主要目的是要使用该包下的类。

比如：import java.util.Scanner;就只是引入一个类Scanner。

import java.util.*;表示将java.util包所有类都引入。

-建议：需要哪个类就导入哪个类。不建议使用*导入。

*@注意：

1.package的作用是生命当前类所在的包，需要放在class的最上面，一个类中最多只有一个package。

2.import指令位置放在package的下面，在类定义的前面，可以有多句且没有顺序前后。

访问修饰符

***基本介绍：

java提供四种访问修饰符号控制方法和属性（成员变量）的访问权限（范围）。

-公开级别：public，对外公开。

-受保护级别：protected，对子类和同一个包中的类公开。

-默认级别：没有修饰符号，对包中的类公开，但不对子类公开。

-私有级别：private，只有类本身可以访问，不对外公开。

*@注意：

1.修饰符可以用来修饰类中的属性、成员方法以及类

2.只有默认的和public才能修饰类，并且遵循上述访问权限的特点。

3.成员方法的访问规则和属性完全一样。

*@命名规范：

　　1：包(package)：将公司域名反转作为包名。比如www.sohu.com

对于包名：每个字母都需要小写。***@但是可以大写

比如：com.sohu.test;该包下的Test类的全名是：com.sohu.Test.java 。 　

　

如果定义类的时候没有使用package,那么java就认为我们所定义的类位于默认包里面(default package)。

　　2：类：首字母大写，如果一个类由多个单词构成，那么每个单词的首字母都大写，而且中间不使用任何的连接符。尽量使用英文。如ConnectionFactory

　　3：方法：首单词全部小写，如果一个方法由多个单词构成，那么从第二个单词开始首字母大写，不使用连接符。addPerson

　　4：属性：与方法相同。如ageOfPerson

　　5：常量：所有单词的字母都是大写，如果有多个单词，那么使用下划线连接即可。

***面向对象编程三大特征：

面向对象编程有三大特征：封装、继承和多态。

封装

***封装：（encapsulation）

就是把抽象的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，

程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作。

***优点：

1.隐藏实现细节： 方法（连接数据库）<--调用（传入参数..）

2.可以对数据进行验证，保证安全合理。

***实现：

1.将属性进行私有化private【让外部不能直接修改属性】

2.提供一个公共的set方法，用于对属性判断并赋值。

public void setXxx(类型 参数名){//Xxx表示某个属性

//加入数据验证的业务逻辑

属性 = 参数名;

}

3.提供一个公共的get方法，用于获取属性的值。

public 数据类型 getXxx(){//权限判断

return xx;

}

***将构造器和setXxx方法相结合。

*@equals方法：

*@equals和==的区别：

equals ：

是Object类中的一个方法，只能判断引用类型。

##默认判断的是地址是否相同，子类中往往重写该方法，用于判断内容是否相等。常见使用Integer，String。

-基本类型Java自动重写equals方法，只比较内容。

-String类型的equals方法也重写了，也只比较字符串的内容。

== ：

是一个比较运算符，不是一个方法。

（1） == ： 既可以判断基本类型，又可以判断引用类型。

（2） == ： 如果判断基本类型，判断的是值是否相等。

（3） == ： 如果判断的是引用类型，判断的是地址是否相等，即判断是否是同一个对象。

***@hashCode方法：

1.提高具有哈希结构的容器的效率。

2.两个引用，如果指向同一个对象，则哈希值肯定是一样的。

3.两个引用，如果指向的是不同对象，则哈希值是不一样的。

4.哈希值主要根据地址来的，但是不能完全将阿悉知等同于地址。

5.后面在学习集合时，其中吐过需要的话，也会重写hashCode。

***@finalize:

(1)当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作。

(2)什么时候被回收：当某个对象没有任何引用时，中的JVM就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁对象。

在销毁该对象前，会先调用finalize方法。

(3)垃圾回收机制的调用是由系统来决定的(即有自己的GC算法)，也可以通过System.gc()主动的触发垃圾回收机制。

多态

***基本介绍：多态（多种状态）

方法或对象具有多种形态，是面向对象的第三大特征，多态是建立在封装和继承的基础上的。

***多态的具体体现：

1.方法的多态:

*@重写和重载就体现多态。

2.对象的多态:

*@重点：

1.一个对象的编译类型和运行类型可以不一致，也可以一致。

2.编译类型在定义对象时就确定了，不能改变。

3.运行类型是可以变化的。

4.编译类型看定义：= 的左边；

运行类型看： = 的右边。

***特别注意：

-多态的@前提：

两个对象（类）存在继承关系。（多态是建立在封装和继承之上的）

向上转型和向下转型

-多态的@向上转型：

1.本质：父类的引用指向了子类的对象。

2.语法：

父类类型 引用名 = new 子类类型();

3.特点：①编译类型看左边，运行类型看右边。

②可以调用父类中的所有成员（须遵守访问权限）。

③不能调用子类中的特有成员。【调用是通过编译器来调用的，父类中没有子类的特定成员，所以无法调用。】

④最终运行效果看子类的具体实现。

【在编译阶段能调用的成员，是由编译类型来决定的】

-多态的@向下转型：

1.语法：

子类类型 引用名 = (子类类型)父类引用;

2.只能强转父类的引用，不能强转父类的对象。

3.要求父类的引用必须指向的是当前目标类型的对象。

4.可以调用子类类型中的所有成员。

***细节：

1.@属性没有重写之说，属性的值看编译类型。

2.instanceof比较操作符，用于判断对象的 *@运行类型 是否为XX类型或其子类型。

***@@@动态绑定机制：(dynamicbinding)

(1)当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。

(2)当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

***@多态的应用——————多态数组和多态参数：

多态数组：

（1）数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。

多态参数：

（2）方法定义的参数类型为父类类型，实参类型允许为子类类型。

静态变量/方法

***类变量

又叫做静态变量，是被某一个类的所有对象共享的。

***无论静态变量的地址是在堆中还是在方法区中，都不影响使用。

【在jdk1.7.0以上的版本前是放在方法区中的，在之后是放在定义类型的Class对象中。Class对象如同堆中的其他对象一样，存在于GC堆中】

*** 静态变量是在类加载的时候生成的。

【总的来说：static变量是保存在class实例的尾部，Class对象确实在堆中】

***

-什么是类变量？

类变量也叫静态变量/静态属性，是该类的所有对象共享的一个变量，任何一个该类的对象去访问它时，取到的都是相同的值，

同样任何一个该类的对象去修改它时，修改的也是同一个变量。

-如何定义类变量？

定义语法：

访问修饰符 static 数据类型 变量名;[推荐这种用法]

static 访问修饰符 数据类型 变量名;

-如何访问类变量？

类名.类变量名;[推荐使用]

或者

对象名.类变量名;【静态变量的访问修饰符的访问权限和范围 和普通属性是一样的】

-什么时候需要使用类变量？

当问们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）

比如：定义学生类，统计所有学生共交多少钱时。

-类变量与实例变量（普通属性）的区别？

类变量是该类的所有对象共享时，而实例变量是每个对象独享的。

-加上static成为类变量或静态变量，否则则称为实例变量/普通变量/非静态变量。

-类变量可以通过 类名.类比那两名 或者 对象名.类变量名 来访问，但是Java设计者推荐我们使用第一种方式进行访问。

【前提是符合访问修饰符的范围】

-实例变量不能通过 类名.类变量名 方式访问。

-类变量是在类加载时就开始初始化了，也就是说，即使没有创建对象，只要类加载了，就可以使用类变量了。

-类变量的生命周期是随类的加载开始，随着类的消亡而销毁。

***@类方法：

-基本介绍：

* 类方法也叫做静态方法。

-形式：

* 访问修饰符 static 数据返回类型 方法名(){} [推荐]

或者

* static 访问修饰符 数据返回类型 方法名(){}

-类方法的调用：

* 使用方式：

* 类名.类方法名 或者 对象名.类方法名

【前提仍然是要满足访问修饰符的访问权限和范围】

***@注意：

1.类方法和欧统方法都是随着类的加载而加载，将结构信息储存在方法区。

-类方法中无this参数。（即类方法中不能使用this）

-普通方法中隐含着this的参数。

2.类方法可以通过类名调用，也可以通过对象名调用。

3.普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。

4.类方法中不允许使用和对象有关的关键字，比如this和super。

普通成员（成员方法）可以。

5.类方法/静态方法中，只能访问静态变量或静态方法。

6.普通成员方法，及可以访问普通变量/方法，也可以访问静态变量/方法。

总结：静态方法只能访问静态成员；非静态的方法可以访问静态成员和非静态成员【遵守访问权限】

***深入理解main方法：

-解释main()方法的形式： public static void main(String[] args){}

1.main方法是Java虚拟机调用的。

2.Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public。

3.Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static。

4.该方法接收String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。

5.Java执行的程序 参数1 参数2 参数3

*@注意：

（1）在main()方法中，我们可以直接调用mian方法所在类的静态方法或静态属性。

（2）但是，不能直接访问该类中的非静态方法，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态方法。

（3）如果我们要想在main方法中访问非静态成员/方法，就需要先创建对象，再调用即可。【创建一个主方法所在类的对象】

***@代码块：

-基本介绍：

代码块又称为初始化块，属于类中的成员（即是类的一部分），类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或者显式调用，而是加载类时，或创建

对象时隐式调用。

-基本语法：

[修饰符]{

代码

};

*@注意：

1.修饰符，要写的话也只能写static，不然就不写。

2.代码块分为两类，使用static修饰的叫做静态代码块，没有static修饰的，叫做普通代码块。

3.逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断、等）

4.;可以写上，也可以省略（可有可无）

*@优点：

1.相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作。

2.如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的复用性。

*@细节：

（1）static代码块也叫做静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。

如果是普通代码块，每创建一个对象就执行。

（2）类什么时候被加载？

-①创建对象实例时（new）。

-②创建子类对象实例，父类也会被加载。而且父类先被加载，子类后被加载。

-③使用类的静态成员时（静态属性/方法）。而且代码块先被加载，静态成员后被加载。

（3）普通的代码块在创建对象实例时会被隐式的调用。被创建一次就调用一次。

如果只是使用类的静态成员时，普通代码块并不会执行【因为普通代码块是在创建对象时才会被调用，使用静态成员时不用创建对象】

（4）创建一个对象时，在一个类中 调用的顺序是：

-①调用静态代码块和静态属性初始化。

【注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个代码块和多个静态变量初始化，则按照他们的定义顺序调用】

-②调用普通代码块和普通属性的初始化。

【注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性，则按定义顺序调用】

-③调用构造方法。

（5）构造方法/构造器的最前面其实隐含了super()和调用普通代码块。

（6）我们看一下创建一个子类时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用书顺序：

1.父类的静态代码块和静态属性（优先级一样，按定义顺序执行）

2.子类的静态代码块和静态属性（优先级一样，按定义顺序执行）

3.父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）

4.子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）

5.父类的构造方法。

6.子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）

7.子类的构造方法。

(7）静态代码块只能调用静态成员（静态属性/方法），普通代码块可以调用任意成员。

下部分学习计划：

抽象类、接口、枚举、异常处理