黑马程序员第十篇控制逻辑(foundation, completed)

来源：互联网发布：java api1.6 编辑：程序博客网时间：2024/06/05 10:41

——- android培训、java培训、期待与您交流！ ———-

目录
1.包 (package)
2.类的访问级别
3.什么是封装
4.最终修饰符
5.静态修饰符

1.包 (package)

在Java中，包的概念就类似Windows里的目录的概念，是一层一层的关系。实际开发中会使用到很多的类，使用方便高效的方法将这些类进行管理也具有比较重要的意义，Java中提供包将不同的类组织起来进行管理。类按照其功能分别存放在各个包里。

1.1 创建包

使用包（package）是为了更好地将代码进行管理。

语法

package 包名

创建包时有以下几个注意事项

package为Java保留的关键字，不能使用别的符号进行代替
package语句放在源文件的最前面，在此之前不允许有任何的语句
package语句只能有一个，不能有多个。因为一个类不可能同时属于两个包，就好比不能将一个物体同时放进两个箱子中一样。
如果包有多层用句点”.”分隔。例如java.util，表示此源文件中的类在Java包下的util子包中。

1.2 如何使用包

当创建完毕一个包就要引入一个包，引入一个包的关键词为import,语法如下

import 包名.*import 包名.类名;

如果一个类需要使用和自己同处于一个包下的类，可以直接访问

首先创建一个package a

package a;public class aaa{    String emp = "包中的成员变量";    public void getMes()    {        System.out.println("emp");    }}

如果想在其他程序中使用该类，则在其他程序中加入如下语句。
import a.aaa;

下面演示如何运行包里的方法

import a.aaapublic class test{    public static void main(String[] args)    {        aaa a = new aaa();        a.getMes();         }}输出结果:    包中的成员变量

总结

一段程序可以有多个import语句
当程序有多个import语句时，没有先后顺序
import 包名.* 表示引入该包下的所有类
import 包名.aaa 表示引入该包下的aaa类
import 语句要在package语句之后使用

1.3 什么是静态引入

静态引入就是引入包中的静态成员变量和静态方法。静态引入的关键词为static，需要在import和包名之间加入static，这样不仅可以导入类，还可以导入静态方法和静态成员变量。静态引入的语法如下：

import static 包名.aaa.*;

//带”*”的形式表示引入包下这个类里的所有的静态方法和静态成员变量。

import static 包名.aaa.方法名称;

//当只需要引入具体类的静态方法时用第二种形式。

不推荐使用”*”这种方式的包引入，因为其不利于代码的阅读，降低程序可读性。

下面通过代码来演示如何静态引入

import static java.lang.System.out;public class test{    public static void main(String[] args)    {        System.out.println("通过静态引入来打印数据");      }}

2.类的访问级别

2.1 公开的访问级别（public）

使用public修饰符，表示在任何包中的任何类都能访问该类。需要注意的是，虽然可以被任何包中的任何类访问，但是在不同的包下还需要使用引用语句。

public class test{    ...//方法体..}

2.2 默认的访问级别

在类的声明前面不加任何的修饰符，即成为具有默认访问级别的类。默认的访问级别和公开的访问级别很相似；
不同点就是默认的访问级别不能访问不同包下的类，只能访问同包下的类。

class test{    ...//方法体}

下面演示一个错误代码，使用默认类在不同包下是禁止访问的

//创建一个b包

package b;class test1{    String emp = "不同包中的成员变量";}

//创建一个a包

package a;import b.*;public class test{    public static void main(String[] args)    {        test1 t1 = new test1();        String s = t1.emp;        System.out.println(s);    }}输出结果:    提示 找不到test1类，    因为test1被修饰的是被默认的访问级别，默认的访问级别不能访问到不同包里的类，将test1类修饰为public就可解决上述问题。

3.什么是封装

在Java中，封装就是在一个类里定义了一些成员变量和方法，通过限制其成员变量和方法的可见性，使得外界不能访问它们。因此封装展现了接口，隐藏了细节。

封装允许把成员变量标识为public，但是在实际的应用中最好把所有的变量都保持为private。

以下代码演示如何进行封装

class bike{    private String name;    private String color;    private String size;    public String getName()    {        return name;    }    public void setName(String name)    {        this.name = name;    }    public String  getColor()    {        return color;    }    public void setColor(String color)    {        this.color = color;    }    public String getSize()    {        return size;    }    public void setSize(String size)    {        this.size = size;    }}public class test{    public static void main(String[] args)    {        bike b = new bike();        b.setName("自行车");        b.setColor("黄色");        b.setSize("26尺寸");        String name = b.getName();        String color = b.getColor();        String size = b.getSize();        System.out.println(name + " : " + color + " : " + size);    }}输出结果    自行车 : 黄色 : 26尺寸

总结

推荐在编写代码的过程中将成员变量修饰为私有类型的，即private。声明为private类型后有利于代码的可读性，便于维护。

4.最终修饰符 (final)

最终修饰符，在字面上可以说为最终的，不变的意思。

4.1 final修饰对象类型的成员变量

使用final修饰变量的基本含义就是该变量一旦被初始化之后就不允许再被修改。 final关键字修饰成员变量，其值是不能改变的，必须进行初始化（最初设定值）。

使用final修饰的原始类型，一旦赋值之后，就不能再改变。而对于引用类型，一旦为其赋值，将不能够重新用来引用另一个对象，不过可以修改器引用对象的成员变量。

错误示范

final String color;错误，需要赋值  初始化

Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。

关于final的注意事项

final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类

　final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2、final方法

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

3、final变量（常量）

　用final修饰的成员变量表示常量，值一旦给定就无法改变！
　final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
　从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

4、final参数

当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

5.静态修饰符

静态修饰符 static是Java保留的关键字， static即静态的意思。所谓静态就是在内存中只能有一份。static能修饰变量，方法，语句块，内部类，被static修饰的成员和普通的成员有很大的不同之处。

5.1 什么是静态变量

静态变量只能存在一份，它属于类，不随着对象的创建而建立副本。如果不想在创建对象的时候就需要知道一些相关信息，那么就声明为static类型的，被修饰为static类型的成员变量不属于对象，它是属于类的。静态成员变量会被该类中的所有对象共享。

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

　被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

　用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

　static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用–废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

　static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表…)
类名.静态变量名

　用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块。

用static关键字修饰成员变量的语法

static 成员变量类型  成员变量名称static String color = “绿色”;

通过代码演示static修饰的成员变量是属于类的，只存在一份

public class test{    static String color = "绿色";    public test(String color)    {        this.color += color;    }    public static void main(String[] args)    {        test t1 = new test("黄色");        test t2 = new test("红色");        System.out.println("t1.color");        System.out.println("t2.color");        System.out.println("color");    }}输出结果    绿色黄色红色    绿色黄色红色    绿色黄色红色

A+=B A=B+A

1、static变量

　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2、静态方法

　静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
　因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块

　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

4、static和final一块用表示什么

static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

最后贴一个java例子，大家测试一下，走一下，就知道，执行顺序了，明白，构造函数，main函数，static块的顺序了。

public class Test{    public  Test(){    System.out.println("Constructor");  }private static int a; private int b; static{ Test.a=3; System.out.println(a); Test t=new Test(); t.f(); t.b=1000; System.out.println(t.b); System.out.println("static 1"); } static{ Test.a=4; System.out.println(a); System.out.println("static 2"); } public static void main(String[] args) { // TODO 自动生成方法存根    System.out.println("Main"); Test t=new Test();t.f();} static{ Test.a=5; System.out.println(a); System.out.println("static 3"); } public void f(){ System.out.println("hhahhahah"); } }

6. 修饰符补充

1.native

使用对象：成员

介绍：与操作平台相关，定义时并不定义其方法，方法的实现被一个外部的库实现。

2.strictfp

使用对象：类、方法

介绍：strictfp修饰的类中所有的方法都隐藏了strictfp修饰词，方法执行的所有浮点计算遵守

IEEE 754标准，所有取值包括中间的结果都必须表示为float或double类型，而不能利用由本地平台浮

点格式或硬件提供的额外精度或表示范围。

3.synchronized

使用对象：方法

介绍：对于一个静态的方法，在执行之前jvm把它所在的类锁定；对于一个非静态类的方法，执行

前把某个特定对象实例锁定。

4.volatile

使用对象：字段

介绍：因为异步线程可以访问字段，所以有些优化操作是一定不能作用在字段上的。volatile有时

可以代替synchronized。

5.transient