现实生活中，我们在超市买东西的时候，往往都需要使用购物车来存储物品，等到所有的物品都购买完成后，在收银台进行结账即可。 大家试想一下，如果程序中要对多个数据求和，就需要把这些数据先存储起来，再对这些数据进行累加。

在python中，若要存储数据，需要用到变量。变量可以理解为去超市购物使用购物车，他的类型和值在赋值的那一刻被初始化。变量的赋值是通过符号来表示的，示例代码如下：

num_one = 100 # num_one就是一个变量，就好比一辆购物车，存储的是数据100

num_two = 87 # num_two也是一个变量，存储的数据是87

result = num1+num2 # 把num_one和num_two两辆”购物车”数据进行累加，放到 result变量中

上述示例中， num_one、 num_two、result都是变量。其中，变量 num_one和num_two就好比一辆购物车，它们分别存储的数据是100和87。变量 result存储的数据是num_one和num_two这两辆“购物车”中的数据累计之和。

变量用来存储数据，那么大家有没有想过，我们应该让变量占用多大空间，保存什么样的数据呢？在讲解变量的类型之前，我们先来看一个生活中的例子，例如，我们要运送一台电脑，大卡车和小轿车都可以完成，但是，如果使用大卡车运送一台电脑，显然有点小题大做，浪费了大。

如果使用变量存储数据时，为了更充分利用内存空间，我们可以为变量指定不同的数据类型。下面我们来看下Python中常见的变量的数据类型。

（1） 数字型

Python中的数字类型包含整型、浮点型和复数类型。示例代码如下:

整 型：0101 83 -239 0x80 299384938832

浮点型：3.1415 4.2E-10 -2.34E-19

复数类型：3.12+1.23j -1.23-98j

（2）布尔类型

布尔类型是特殊的整型，它的值只有两个，分别是True和False。如果将布尔值进行数值运算，True会被当作整型1，False会被当作整型0。

（3）字符串类型

Python中的字符串被定义为一个字符集合，它被引号所包含，引号可以是单引号、双引号或者三引号（三个连续的单引号或者双引号）。字符串具有索引规则，第1个字符的索引是0，第2个字符的索引是1，以此类推。

下面是字符串的示例代码：

string_one = 'Python'

string_two = ''Python''

string_three = '''Python'''

（4）列表和元组类型

我们可以将列表和元组当作是普通的“数组”，它们可以保存任意数量的任意类型的值，这些值称作元素。列表中的元素使用中括号[]包含，元素的个数和值是可以随意修改的。而元组中的元素使用小括号（）包含，元素不可以被修改。下面看一下列表和元组的表示方式。

list_name = [1, 2, 'hello'] # 这是一个列表

tuple_name = (1, 2, 'hello') # 这是一个元组

多学一招

列表与元组的区别：

列表是动态数组，它们不可变且可以重设长度（改变其内部元素的个数）。

元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。

元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。

列表和元组设计哲学上不同：

列表可被用于保存多个互相独立对象的数据集合；

元组用于描述一个不会改变的事务的多个属性。

（5）字典类型

字典是 Python中的映射数据类型，由键-值对组成。字典可以存储不同类型的元素，元素使用大括号{}来包含。通常情况下，字典的键会以字符串或者数值的形式来表示，而值可以是任意类型。示例代码如下:

dict_name

= {"name":"zhangsan", "age":18} #这是一个字典

上述代码中，变量 dict_name是一个字典类型，它存储了两个元素，第1个元素的键为name，值为 zhangsan；第2个元素的键为age，值为18。

在 Python中，只要定义了一个变量，并且该变量存储了数据，那么变量的数据类型就已经确定了。这是因为系统会自动辨别变量的数据类型，不需要开发者显式说明变量的数据类型了。

如果希望查看变量的类型，可以使用“type(变量的名字)”来实现。示例代码如下:

>>> number = 5.2

>>> type(number) // 使用type函数查看类型

上述代码中，变量number存储的值为5.2，系统会自动根据数值判断number变量的数据类型为float。因此，当使用type函数查看变量number的数据类型时，结果为float。

猜你喜欢：

最新Python安装图文教程

Python基础视频教程下载

dict_name = {"name":"zhangsan", "age":18} #这是一个字典dict_name = {"name":"zhangsan", "age":18} #这是一个字典

2. 标识符

2.1 标识符概述

就是给类，接口，方法，变量等起名字时使用的字符序列

2.2 组成规则

由英文大小写字母、数字字符、$（美元符号）、_（下划线）组成

2.3 注意事项

• 不能以数字开头

• 不能是Java中的关键字

• 区分大小写

2.4 标识符常见命名规则：见名知意

2.4.1 包

其实就是文件夹，用于把相同的类名进行区分，全部小写，单级：liuyi，多级：cn.itcast

为了便于对硬盘上的文件进行管理，通常都会将文件分目录进行存放。同理，在程序开发中，也需要将编写的类在项目中分目录存放，以便于文件管理。为此，Java引入了包(package)机制，程序可以通过声明包的方式对Java类定义目录。

Java中的包是专门用来存放类的，通常功能相同的类存放在相同的包中。在声明包时，使用package语句，具体示例如下：

package cn.itcast.chapter01; // 使用package关键字声明包
public class Example01{…}

需要注意的是，包的声明只能位于Java源文件的第一行。

在实际程序开发过程中，定义的类都是含有包名的，如果没有显式地声明package语句，创建的类则处于默认包下，在实际开发中，这种情况是不应该出现的，本教材的示例代码主要展现的是功能部分的代码，所以在大多数示例代码中没有为示例指定包名，但是在提供的源码中，都已使用包名。

在开发时，一个项目中可能会使用很多包，当一个包中的类需要调用另一个包中的类时，就需要使用import关键字引入需要的类。使用import可以在程序中一次导入某个指定包下的类，这样就不必在每次用到该类时都书写完整类名，简化了代码量。使用import关键字的具体格式如下所示：

import 包名.类名;

需要注意的是，import通常出现在package语句之后，类定义之前。如果有时候需要用到一个包中的许多类，则可以使用 import 包名.*; 来导入该包下所有类。

在JDK中，不同功能的类都放在不同的包中，其中Java的核心类主要放在java包及其子包下，Java扩展的大部分类都放在javax包及其子包下。为了便于后面的学习，接下来简单介绍Java语言中的常用包。

• java.util:包含Java中大量工具类、集合类等，例如Arrays、List、Set等。

• java.net:包含Java网络编程相关的类和接口。

• java.io:包含了Java输入、输出有关的类和接口。

• java.awt:包含用于构建图形界面(GUI)的相关类和接口。

除了上面提到的常用包，JDK中还有很多其它的包，比如数据库编程的java.sql包，编写GUI的javax.swing包等等，JDK中所有包中的类构成了Java类库。在以后的章节中，这些包中的类和接口将逐渐介绍，这里只需要有个大致印象即可。

2.4.2 类或者接口

一个单词：单词的首字母必须大写，举例：Student,Dog
多个单词：每个单词的首字母必须大写举例：HelloWorld，StudentName

2.4.3 方法和变量

一个单词：单词的首字母小写，举例：main,age
多个单词：从第二个单词开始，每个单词的首字母大写，举例：studentAge,showAllNames()

2.4.4 常量

一个单词：全部大写，举例：PI
多个单词：每个字母都大写，用_隔开，举例：STUDENT_MAX_AGE

3. 注释

3.1 注释概述

用于解释说明程序的文字

3.2 Java中注释分类格式

• 单行注释，格式：//注释文字

• 多行注释，格式：/* 注释文字 */

• 文档注释，格式：/** 注释文字 */

/*
    注释：用于解释说明程序的文字

    Java中注释的分类及格式
        单行注释：//
        多行注释：/星 星/
            注意：多行不可以嵌套使用，而单行是可以的
        文档注释：被javadoc工具解析生成一个说明书，面向对象部分讲解。
*/

//这是我的注释案例
class ZhuShiDemo {
    //main方法是主方法
    //是程序的入口
    //被jvm调用
    public static void main(String[] args) {
        System.out.println("好好学习,天天向上");
    }
}

• 对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行

• 对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档

• 注释是一个程序员必须要具有的良好编程习惯

• 初学者编写程序可以养成习惯：先写注释再写代码

• 将自己的思想通过注释先整理出来，在用代码去体现

• 因为代码仅仅是思想的一种体现形式而已

/*
    需求：我准备写一个java程序，把"HelloWorld"这句话输出在控制台

    分析：
        A:要写一个Java程序，必须定义类
        B:把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法
        C:把数据输出在控制台，必须使用输出语句

    实现：
        A:java语言提供了一个关键字：class用来定义类，后面跟的是类名
        B:main方法的格式是固定的：
            public static void main(String[] args) {

            }
        C:输出语句的格式是固定的：
            System.out.println("HelloWorld");
            "HelloWorld"这个内容是可以改变的
*/

//这是我的HelloWorld案例
class HelloWorld {
    /*
        为了程序能够独立运行，定义main方法
        main方法是程序的入口
        被jvm自动调用
    */
    public static void main(String[] args) {
        //为了把数据显示在控制台，我们就使用了输出语句
        System.out.println("HelloWorld");
    }
}

4. 常量

4.1 常量概述

在程序执行的过程中其值不可以发生改变

4.2 Java中常量分类

4.2.1 字面值常量

• 字符串常量：用双引号括起来的内容，举例：“hello”，“world”

• 整数常量：所有整数，举例：12，23

• 小数常量：所有小数，举例：12.34，56.78

• 字符常量：用单引号括起来的内容，举例：‘a’,’A’,’0’

• 布尔常量，较为特有，举例：true，false

• 空常量，举例：null

4.2.2 自定义常量

/*
    常量：
        在程序执行过程中，其值不发生改变的量。

    分类：
        A:字面值常量
        B:自定义常量(后面讲)

    字面值常量
        A:字符串常量 用双引号括起来的内容。
            举例："hello","world","HelloWorld"
        B:整数常量  所有的整数
            举例：100,200
        C:小数常量  所有的小数
            举例：10.23,110.11
        D:字符常量  用单引号括起来的内容
            举例：'a','A','0'
            错误的：'ab'
        E:布尔常量  比较特殊
            举例：true,false
        F:空常量   后面讲
            举例：null
*/
class ConstantDemo {
    public static void main(String[] args) {
        //字符串常量的输出
        System.out.println("hello");

        //整数常量的输出
        System.out.println(100);

        //小数常量的输出
        System.out.println(100.10);

        //字符常量的输出
        System.out.println('a');
        System.out.println('A');
        System.out.println('0');
        //这个是有问题的
        //System.out.println('ab');

        //布尔常量的输出
        System.out.println(true);
        System.out.println(false);
    }
}

5. 变量

在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。

5.1 变量概述

在程序执行的过程中，在某个范围内其值可以发生改变的量，理解：如同数学中的未知数

5.2 变量定义格式

数据类型 变量名 = 初始化值;
注意：格式是固定的，记住格式，以不变应万变

5.3 变量的组成规则

1、从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用。通过画图说明一个变量的组成部分

数据类型，变量名，变量值

2、为什么要定义变量呢?用来不断的存放同一类型的常量，并可以重复使用

6. 数据类型和类型转换

Java是一门强类型的编程语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。

6.1 数据类型

6.1.1 Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间

6.1.2 所谓有效数字：具体地说，是指在分析工作中实际能够测量到的数字。所谓能够测量到的是包括最后一位估计的，不确定的数字。对于一个近似数，从左边第一个不是0的数字起，到精确到的位数止，所有的数字都叫做这个数的有效数字。

6.1.3 Java 各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响，以保证Java程序的可移植性。

• Java语言的整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ ，如：

int i1 = 600; //正确     long l1 = 88888888888L; //必须加l否则会出错

• - 与整数类型类似，Java浮点类型有固定的表数范围和字段长度，不受平台影响。

  Java浮点类型常量有两种表示形式，十进制数形式，如: 3.14       314.0

• Java 浮点型常量默认为 double型，如要声明一个常量为 float 型，则需在数字后面加 f 或 F ，如：
  java<br />double d = 12345.6; //正确 <br />float f = 12.3f; //必须加f否则会出错<br />

• char* 型数据用来表示通常意义上的“字符”

  • 字符常量为用单引号括起来的单个字符，例如：char ch1= 'a'; char ch2='中';

  • Java字符采用 Unicode 编码，每个字符占两个字节，因而可用十六进制编码形式表示。

  • 注：Unicode是全球语言统一编码

• boolean类型

  • boolean 类型适于逻辑运算，一般用于程序流程控制 。

  • boolean 类型数据只允许取值 true 或 false ，不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。

• 数据类型

  • 基本数据类型：整型byte、short、int、long，浮点型float、double，字符型char，布尔型boolean

  • 引用数据类型：类class、接口interface、数组[]

/*
    数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。

    数据类型分类：
        A:基本数据类型
        B:引用数据类型(类,接口,数值)

    基本数据类型:4类8种
        A:整数            占用字节数
            byte            1
            short           2
            int             4
            long            8

        B:浮点数
            float           4
            double          8

        C:字符
            char            2
        D:布尔
            boolean         1

        注意：
            整数默认是int类型
            浮点数默认是double类型。

            长整型后缀用L或者l标记。建议使用L。
            单精度浮点数用F或者f标记。建议使用F。
*/
class DataTypeDemo {
    public static void main(String[] args) {
        //定义变量的格式：
        //数据类型 变量名 = 初始化值;

        //定义一个字节变量
        byte b = 10;
        System.out.println(10);
        System.out.println(b);

        //定义一个短整型变量
        short s = 100;
        System.out.println(s);

        //定义一个整型变量
        int i = 1000;
        System.out.println(i);

        //超过了int的范围
        //int j = 1000000000000;
        long j = 1000000000000L;
        //long j = 100L;
        System.out.println(j);

        //定义浮点数据变量
        float f = 12.345F;
        System.out.println(f);

        double d = 12.345;
        System.out.println(d);

        //定义字符变量
        char ch = 'a';
        System.out.println(ch);

        //定义布尔变量
        boolean flag = true;
        System.out.println(flag);
    }
}

运行结果:

 

6.1.4 使用变量的时候要注意的问题：

 

A：作用域
变量定义在哪个大括号内，它就在这个大括号内有效。
并且，在同一个大括号内不能同时定义同名的变量。

B：初始化值
 没有初始化值的变量不能直接使用。
 你只要在使用前给值就行，不一定非要在定义的时候立即给值。
 推荐在定义的时候给值。

定义变量的格式：       
   a：数据类型 变量名 = 初始化值;      
   b：数据类型 变量名;    
   变量名 = 初始化值;

C：在一行上建议只定义一个变量        
   可以定义多个，但是不建议

6.2 类型转换

当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。

根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。

6.2.2 默认转换(从小到大的转换)

自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。

要实现自动类型转换，必须同时满足两个条件，

• 第一是两种数据类型彼此兼容，

• 第二是目标类型的取值范围大于源类型的取值范围。

（1）整数类型之间可以实现转换，如byte类型的数据可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值给int、long类型的变量，int类型的数据可以赋值给long类型的变量
（2）整数类型转换为float类型，如byte、char、short、int类型的数据可以赋值给float类型的变量。
（3）其它类型转换为double类型，如byte、char、short、int、long、float类型的数据可以赋值给double类型的变量。

A：byte，short，char—int—long—float—double

B：byte，short，char相互之间不转换，他们参与运算首先转换为int类型

6.2.2 强制转换：

强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。

当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。

从大的数据类型到小的数据类型
格式：目标数据类型 变量 = (目标数据类型) (被转换的数据);
注意：不要随意的去使用强制转换，因为它隐含了精度损失问题

/*
    面试题：
        byte b1=3,b2=4,b;
        b=b1+b2;
        b=3+4;
        哪句是编译失败的呢？为什么呢？
        b = b1 + b2;是有问题的。
        因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
        常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
*/
class DataTypeDemo6 {
    public static void main(String[] args) {
        //定义了三个byte类型的变量，b1，b2，b3
        //b1的值是3，b2的值是4，b没有值
        byte b1 = 3,b2 = 4,b;

        //b = b1 + b2; //这个是类型提升，所有有问题

        b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
    }
}

1、在定义Long或者Float类型变量的时候，要加L或者f。

• 整数默认是int类型，浮点数默认是double。

• byte，short在定义的时候，他们接收的其实是一个int类型的值。

• 这个是自己做了一个数据检测的，如果不再它们的范围内，就报错。

2、byte值的问题

byte b1 = 127;
byte b2 = (byte)128; //-128
byte b3 = (byte)129; //-127
byte b4 = (byte)130; //-126
byte的范围：-128 ~ 127
128：10000000
-128：10000000 (这里的1即是符号位，也是数值位)

3、数据类型转换之默认转换
 byte，short，char -- int -- long -- float -- double
 long：8个字节
 float：4个字节
 A：它们底层的存储结构不同
 B：float表示的数据范围比long的范围要大
   long：2^63-1
   float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

4、Java语言中的字符char可以存储一个中文汉字吗?为什么呢?        
可以。因为java语言中的字符占用两个字节。Java语言采用的是Unicode编码。

参考地址：https://github.com/JackChan1999/Java_Basic_Introduction

更多好文

java精品入门-0基础第一篇

JDK、JRE、JVM的区别与联系

亲，需要你的“分享”和“在看”

IT入门 感谢关注

程序员题库→ 程序员用的单词表→ 练习地址：http://520mg.com/it/#/main/397

一、总述

类、方法、成员变量和局部变量的可用修饰符

修饰符	类	成员访求	构造方法	成员变量	局部变量
abstract（抽象的）	√	√	－	－	－
static （静态的）	－	√	－	√	－
public（公共的）	√	√	√	√	－
protected（受保护的）		√	√	√	－
private（私有的）	－	√	√	√	－
synchronized（同步的）	－	√	－	－	－
native（本地的）	－	√	－	－	－
transient（暂时的）	－	－	－	√	－
volatie（易失的）	－	－	－	√	－
final（不要改变的）	√	√	－	√	√

二、类修饰符

访问修饰符：公共类修饰符public（只能是它）

非访问控制符：抽象类修饰符 abstract 、最终类修饰符 final

（1）公共类修饰符 public ： Java 语言中类的访问控制符只有 public 即公共的。每个 Java 程序的有且只有一个类是 public，它被称为主类 ，其他外部类无访问控制修饰符，具有包访问性。注意：一个类的内部类可以被其他访问控制修饰符protected、default、 private修饰，相当于类的成员。

（2）抽象类修饰符 abstract ：用 abstract 修饰符修饰的类，被称为抽象类。

（3）最终类修饰符 final ：当一个类不能被继承时可用修饰符 final修饰为最终类。被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。final关键字不能用来抽象类和接口

（4）类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。

1、如果一个类包含抽象方法（用abstract修饰的方法），那么这个类必须是抽象类

2、继承抽象类的子类必须重写父类所有的抽象方法（用abstract修饰的方法）。否则，该子类也必须声明为抽象类（也必须用abstract修饰）。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

接口通常是不带修饰符的，一般都是public interface

以上是对于外部类，外部类只能用public、adstract、final修饰，如果是内部类类则可以用 修饰成员变量的修饰符修饰内部类，比如 private, static, protected 修饰。

三、方法修饰符

1、按修饰符分

访问控制修饰符：公共访问控制符public、保护访问控制符protected、缺省默认default、私有访问控制符private

非访问控制符：抽象方法控制符abstract 、静态方法控制符static 、最终方法控制符final 、本地方法控制符native 、同步方法控制符synchronized

（1）抽象方法控制符 abstract ：用修饰符 abstract 修饰的方法称为抽象方法。抽象方法仅有方法头，没有方法体和操作实现。

（2）静态方法控制符 static ：用修饰符 static 修饰的方法称为静态方法。静态方法是属于整个类的类方法；而不使用static 修饰、限定的方法是属于某个具体类对象的方法。 由于 static方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即 static 方法只能处理 static的域。

（3）最终方法控制符 final ：用修饰符 final修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重写覆盖（可以被继承）。final固定了方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被 private 修饰符限定为私有的方法，以及所有包含在 final 类 ( 最终类) 中的方法，都被认为是最终方法。

（4）本地方法控制符 native ：用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符 native 来修饰。

（5）同步方法控制符 synchronized ：该修饰符主要用于多线程程序中的协调和同步。

2、类的方法

类成员的访问控制符：即类的方法和成员变量的访问控制符

一个类作为整体对象不可见，并不代表他的所有域和方法也对程序其他部分不可见，需要有他们的访问修饰符判断。权限如下：

访问修饰符	同一个类	同包	不同包，子类	不同包，非子类
public	√	√	√	√
protected	√	√	√
默认（default）	√	√
private	√

（1）构造方法

构造方法只能用public（所有的类访问）、protected（只能自己和子类访问）、private（只能在本类访问），而不能是abstract, static, final, native, strictfp, 或者synchronized的。原因如下：

1. 构造器不是通过继承得到的，所以没有必要把它声明为final的。
2. 同理，一个抽象的构造器将永远不会被实现。（所以也不能声明为abstract的）
3. 构造器总是关联一个对象而被调用，所以把它声明为static是没有意义的。
4. 没有实际的需要把构造器定义成同步的，因为它将会在构造的时候锁住该对象，直到所有的构造器完成它们的工作，这个构造的过程对其它线程来说，通常是不可访问的。 （synchronized）
5. 本地化的方法情况特别复杂，所以JVM调用起来非常麻烦，需要考虑很多种情况，没有native关键字的情况下，JVM实现起来比较容易。

（2）类方法（静态方法）

类方法：使用static关键字说明的方法（与实例方法区分：是否用static修饰）

1.系统只为该类创建一个版本，这个版本被该类和该类的所有实例共享。

2.类方法只能操作类变量，不能访问实例变量。类方法可以在类中被调用，不必创建实例来调用，当然也可以通过对象来调用。

3.静态方法可以直接访问类变量（静态成员变量）和静态方法。

解释：因为静态方法在加载类的时候就被调用了

4.静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量（静态成员变量）或静态方法。

普通成员变量或成员方法只有在创建对象的时候才会被创建，而静态方法在加载类的时候就被加载了，那时候还没有对象，更不必谈在静态方法中访问其中的普通成员变量和成员方法了

5.静态方法中，不能使用this关键字。

（3）成员方法

• public（公共控制符）
• private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
• protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。
• final，指定该方法不能被重载。
• static，指定不需要实例化就可以激活的一个方法。
• synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
• native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

（4）抽象类的抽象方法

抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。原因如下：

1. 抽象方法没有方法体，是用来被继承的，所以不能用private修饰；
2. static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；
3. 使用synchronized关键字是为该方法加一个锁。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的，是在其子类实现的。所以，锁应该归其子类所有。所以，抽象方法也就不能用synchronized关键字修饰了；
4. native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个把方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？

3、接口的方法

接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符（private、static、synchronized、native）这里也不能用。而且protected访问修饰符也不能使用，因为接口可以让所有的类去实现（非继承），不只是其子类（比如如果实现类和接口不在同一个包内就会出现问题）。所以要用public去修饰，接口才可以被实现。

默认写法：public abstract（默认不写）

（1）静态方法（static）

用static修饰的方法就是静态方法，静态方法必须要有实现体（一定要有花括号），并且静态方法是不能被实现类实现的，只能通过接口调用这个方法

静态方法必须要有方法体，即一定要有花括号，是因为静态方法不能被实现类实现，但是接口的方法又必须全部被实现，所以矛盾，所以静态方法必须要有实现

格式：public static 返回数据类型 方法名（参数列表）{}

省略了abstract

（2）默认方法（default）

default的加入就是为了解决接口中不能有默认方法的问题，在实现类中可以重写这个default方法也可以不重写。

default修饰的方法跟接口中的静态方法的区别就是default方法可以被实现类重写，这样就可以得到扩展并且不修改原来接口中功能，而静态方法就有点太苛刻了，还不如把静态方法写在实现类中，这样每个实现类都可以自己写自己的功能实现。

格式：default 返回数据类型 方法名(){}

（3）其他抽象方法

四、变量修饰符

1、类的成员变量修饰符

一个类的成员变量的声明必须在类体中，而不能在方法中，方法中声明的是局部变量。

public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。

private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。

protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。

friendly ，在同一个包中的类可以访问，其他包中的类不能访问。

final，最终修饰符，指定此变量的值不能变。

static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。

transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。

volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。

抽象类中变量的修饰符与一般类一致

2、接口中的变量

接口中的属性默认是public static final 的，（因为是final的，所以都是常量），只能读不能改

public static final 可以省略不写

即

1：public static final String name = “张三”;

2：String name = “张三”;

以上两种写法都可以

public的话可以理解，需要被实现类使用

如果是非static的话，因一个类可以多继承，容易出现重名导致编译错误

接口的方法都是抽象的，可变的东西都应该归属到实现类中，这样接口才能起到标准化、规范化的作用，因此接口里的属性必须是不变的，即final的，可以不变实现类修改（如果能被实现类任意修改，接口就没有创建这个常量的必要了

3、方法中的局部变量

因为接口中的方法都是抽象方法，而抽象方法没有实现，即没有方法体。所以，只有一般类中的方法和抽象类中的非抽象方法才会有局部变量。

方法中对于变量的修饰符只有两种：

1、缺省（default）：即什么都不写，这是一个普通的变量，必须为其设置初始值。
2、final：表示变量值不可以被改变，即常量

一般类和抽象类中的静态方法中的变量自动就是静态的，不需要加static

五、常考修饰符

1、final

（1）修饰类

• 该类不能被继承
• final不能修饰抽象类和接口
• final类中的方法不会被覆盖，因此默认都是final的
• 用途：设计类时，如果该类不需要有子类，不必要被扩展，类的实现细节不允许被改变，那么就设计成final类

（2）修饰方法

• 该方法可以被继承，但是不能被覆盖
• 用途：一个类不允许子类覆盖该方法，则用final来修饰
• 好处：可以防止继承它的子类修改该方法的意义和实现；更为高效，编译器在遇到调用fianal方法转入内嵌机制，提高了执行效率
• 父类中的private成员方法不能被子类覆盖，因此，父类的private方法默认是final型的(可以查看编译后的class文件)

（3）修饰变量

• 用final修饰后变为常量。包括静态变量、实例变量和局部变量这三种
• **特点：**只能被赋一次值，必须被显示初始化。可以先声明，不给初值，这种叫做final空白。但是使用前必须被初始化。一旦被赋值，将不能再被改变。

（4）修饰参数

• 用final修饰参数时，可以读取该参数，但是不能对其作出修改

2、static

1、简介

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属 于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

2、定义和使用

1）类变量当 static 修饰成员变量时，该变量称为类变量。

该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行作。

static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。 static成员变量的初始化顺序按照定义的顺序进行初始化。

定义格式：static 数据类型 变量名；举例：static int numberID；

2）静态方法

当 static 修饰成员方法时，该方法称为类方法 。

静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。 类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。 定义格式： 修饰符 static 返回值类型 方法名 (参数列表){ // 执行语句}

调用格式：

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属 于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

3）静态代码块

定义在成员位置，使用static修饰的代码块{ }。 位置：类中方法外。执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

3、注意事项：

• 静态方法可以直接访问类变量和静态方法。
• 静态方法不能直接访问普通成员变量或成员方法。
• 反之，成员方法可以直接访问类变量或静态方法。
• 静态方法中，不能使用this和super关键字。
• 静态方法不能被abstract修饰
• 静态方法和静态变量都可以通过类名直接被访问。
• 当类被加载时，静态代码块只被执行一次。类中不同的静态代码块按它们在类中出现的顺序被依次执行

static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况

3、注意事项：

• 静态方法可以直接访问类变量和静态方法。
• 静态方法不能直接访问普通成员变量或成员方法。
• 反之，成员方法可以直接访问类变量或静态方法。
• 静态方法中，不能使用this和super关键字。
• 静态方法不能被abstract修饰
• 静态方法和静态变量都可以通过类名直接被访问。
• 当类被加载时，静态代码块只被执行一次。类中不同的静态代码块按它们在类中出现的顺序被依次执行

static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况