疯狂Java之学习笔记（17）---------------变量和权限

疯狂Java之学习笔记（17）---------------变量和权限

首先先总结一下变量的具体内容

Java变量的声明在 Java 程序设计中，每个声明的变量都必须分配一个类型。声明一个变量时，应该先声明变量的类型，随后再声明变量的名字。下面演示了变量的声明方式。

double salary;

int age;

Boolean op;

其中第一项称为变量类型，第二项称为变量名。分号是必须的，这是 Java 语句的结束符号。

同一类型的不同变量，可以声明在一行，也可以声明在不同行，如果要声明在同一行中，不同的变量之间用逗号分隔，例如下面的例子。

int studentNumber,people;

声明变量的同时可以为变量赋值，也可以声明以后再赋值。如：

int a=1;  //声明时赋值

int a;     a=1;    //声明后赋值

注意：在程序运行过程中，空间内的值是变化的，这个内存空间就称为变量。为了操作方便，给这个空间取了个名字，称为变量名，内存空间内的值就是变量值。所以，申请了内存空间，变量不一定有值，要想变量有值，就必须要放入值。

例如：“int x”; 定义了变量但没有赋值，即申请了内存空间，但没有放入值；int x=5; 不但申请了内存空间而且还放入了值，值为 5。

注意：没有赋值的变量，系统将按下列默认值进行初始化。

二.变量的作用域（全局变量|局部变量）

根据作用域（作用范围）来分，一般将变量分为全局变量和局部变量。从字面上理解很简单，全局变量就是在程序范围之内都有效的变量，而局部变量就是在程序中的一部分内是有效的。

在Java中，全局变量就是在类的整个范围之内，都有效的变量。而局部变量就是在类中某个方法函数内或某个子类内，有效的变量，下面将从实际程序代码中慢慢的体会。

1.全局变量示例

public class var{ ///a 是全局变量

int a=10;

public static void main(String[] args){

var v=new var();

v.print();

}

void print(){

System.out.println("全局变量 a="+a);

}

}

运行结果：

全局变量 a=10

从以上例子可以看出，变量“a”的值在整个类中都有效。

2.局部变量示例

public class Math1{ ///c 是局部变量

public static void main(String[] args){

Math1 v=new Math1();

System.out.println("这个是局部变量 c="+c);

}

void print(){

int c=20;

}

}

以上代码在编译时，会出现错误，就是找不到变量“c”。这说明变量“c”只在方法“print（）”中起作用，在方法外就无法再调用。

从上述代码中可以看出，如果一个变量在类中定义，那么这个变量就是全局变量；而在类中的方法、函数中定义的变量就是局部变量。

三.全局变量与局部变量的声明

public class var{

byte x; short y; int z; long a; float b;

double c; char d; boolean e;

public static void main(String[] args){

var m=new var();

System.out.println(" 打印数据 x="+m.x);

System.out.println(" 打印数据 y="+m.y);

System.out.println(" 打印数据 z="+m.z);

System.out.println(" 打印数据 a="+m.a);

System.out.println(" 打印数据 b="+m.b);

System.out.println(" 打印数据 c="+m.c);

System.out.println(" 打印数据 d="+m.d);

System.out.println(" 打印数据 e="+m.e);

}

}

运行结果：

打印数据 x=0

打印数据 y=0

打印数据 z=0

打印数据 a=0

打印数据 b=0.0

打印数据 c=0.0

打印数据 d=

打印数据 e=false

public class var1{

void printnumber(){

byte x; short y; int z; long a;

float b; double c; char d; boolean e;

}

public static void main(String[] args){

var1 m=new var1();

System.out.println(" 打印数据 x="+m.x);

System.out.println(" 打印数据 y="+m.y);

System.out.println(" 打印数据 z="+m.z);

System.out.println(" 打印数据 a="+m.a);

System.out.println(" 打印数据 b="+m.b);

System.out.println(" 打印数据 c="+m.c);

System.out.println(" 打印数据 d="+m.d);

System.out.println(" 打印数据 e="+m.e);

}

)

这个程序段编译时就会报错，原因是所有局部变量都没有初始化。从以上两段程序代码得出一个结果：全局变量可以不用进行初始化赋值工作，而局部变量必须要进行初始化赋值工作。

java的内存分配问题

在任何编程语言中，无论是基本类型还是引用类型，不论其作用域如何，都必须为其分配一定的内存空间，Java 语言也不例外，Java 的数据类型可以分为两种：基本类型（变量持有数据本身的值）和引用类型（是某个对象的引用，而并非是对象本身）；基本类型包括：boolean、float、double、int、long、short、byte以及char；在Java编程语言中除基本类型以外其余都是引用类型如：类类型、数组类型等。

在计算机内存中主要来自四个地方：heap segment（堆区）、stack segment（栈区）、codesegment（代码区）、data segment（数据区）；不同的地方存放不同数据：其中堆区主要存放Java程序运行时创建的所有引用类型都放在其中；栈区主要存放Java程序运行时所需的局部变量、方法的参数、对象的引用以及中间运算结果等数据；代码区主要存放Java的代码；数据区主要存放静态变量及全局变量；以下结合实例来探讨其具体机制。

class Student {

private String name;

private int age;

public Student(String name, int age) {

this.name = name;

this.age = age;

}

}

public class Test {

static int i = 10;

public static void main(String[] args) {

Student s1 = new Student(“feng”, 21);

}

}

当该程序运行起来后，其计算机内存分布大致如下：

对象在内部表示Java虚拟机规范并没有规定其在堆中是如何表示的。对象的内部的表示会直接影响到堆区的设计以及垃圾收集器（GC）的设计。

Java在堆中的表示方法具体有两种：

把堆分成两个部分：一个句柄池，一个对象池；表示如下图所示：

用对象指针直接指向一组数据，而该数据包括对象实例数据以及指向方法区中的数据的指针，具体如下图所示：

小结：通过对对象内存分配的分析，来使读者对Java的底层有一个比较理性的认识，从而进一步掌握Java的基础知识。在深入了解了Java内存的分配以后，才能为以后编写高质量的程序打下坚实的基础，而且可以借鉴该思想来分析其它面向对象语言的内存分配问题。

在网上又找了一些关于内存分配的资料与大家分享一下！写的很详细!

堆栈

静态存储区域

一个由C/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap）— 由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

3、全局区（静态区）（static）— 全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

4、文字常量区 — 常量字符串就是放在这里的，程序结束后由系统释放 。

5、程序代码区 — 存放函数体的二进制代码。

Java中保存地址：

寄存器register 这是速度最快的地方 数据位于和其他所有方式都不同的一个地方 处理器的内部 不过 寄存器的数量十分有限 所以寄存器是根据需要由编译器分配我们对此没有直接的控制权 也不可能在自己的程序里找到寄存器存在的任何迹象。

JVM的寄存器用来存放当前系统状态。然而，基于移植性要求，JVM拥有的寄存器数目不能过多。否则，对于任何本身的寄存器个数小于JVM的移植目标机，要用常规存储来模拟高速寄存器，是比较困难的。同时JVM是基于栈（Stack）的，这也使得它拥有的寄存器较少。

JVM的寄存器包括下面四个：

（1）PC程序计数寄存器

（2）optop操作数栈栈顶地址寄存器。

（3）frame当前执行环境地址寄存器。

（4）vars局部变量首地址寄存器。

这些寄存器长度均为32位。其中PC用来记录程序执行步骤，其余optop,frame,vars都存放JVM栈中对应地址，用来快速获取当前执行所需的信息。

堆栈stack 堆栈位于常规 RAM 随机访问存储器 内 但可通过它的 堆栈指针 获得处理器的直接支持 堆栈指针若向下移 会创建新的内存 若向上移则会释放那些内存这是一种特别快 特别有效的数据保存方式 仅次于寄存器 创建程序时 Java编译器必须准确地知道堆栈内保存的所有数据的长度 以及 存在时间 这是由于它必须生成相应的代码 以便向上和向下移动指针 这一限制无疑影响了程序的灵活性 所以尽管有些 Java数据要保存在堆栈里 特别是对象引用 但 Java 对象并不放到其中

在函数中定义的一些基本类型的变量和对象的引用变量都在函数的堆栈 中分配 。

当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。 所以尽量使用基本类型的变量．

堆(或 内存堆 heap) 一种常规用途的内存池 也在 RAM 内 所有 Java 对象都保存在里面 和堆栈不同 内存堆 或 堆 Heap 最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间 也不必知道存储的数据要在堆里呆多长的时间 因此用堆保存数据时会得到更大的灵活性 要创建一个对象时 只需用 new 命令编制相关的代码即可执行这些代码时 就会在堆里自动进行数据的保存 不过 为了获得这种灵活性我们也必然需要付出一定的代价 假如在内存堆里分配存储空间 和分配规格存储空间相比 前者要花掉更长的时间 和 C++不同 Java 事实上是不允许在堆栈里创建对象的 这样说 只是为了进行理论上的一种比较

堆内存用来存放由 new创建的对象和数组。 由Java虚拟机的自动垃圾回收器来管理。

在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。

引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象

静态存储static storage  静态 Static 是指 位于固定位置 尽管仍在 RAM 里程序运行期间 静态存储的数据将随时等候调用 可用 static 关键字指出一个对象的特定元素是静态的 但 Java 对象本身永远都不会不会置入静态存储空间

常数存储constant storage 常数值通常直接置于程序代码内部 这样做是安全的 因为它们永远都不会改变有的常数需要严格地保护 所以可考虑将它们置入只读存储器 ROM

非 RAM 存储 若数据完全独立于一个程序之外 那么即使程序不运行了 它们仍可存在 并处在程序的控制范围之外 其中两个最主要的例子便是 流式对象 和 持久性对象 对于流式对象 对象会变成字节流通常会发给另一台机器 而对于持久性对象我们可把它们保存在磁盘或磁带中 即使程序中止运行 它们仍可保持自己的状态不变之所以要设计这些类型的数据存储 最主要的一个考虑便是把对象变成可在其他媒体上存在的形式 以后一旦需要 还可重新变回一个普通的 存在于 RAM 里的对象 目前 Java 只提供了有限的 持久性对象 支持 在未来的 Java 版本中 有望提供对 持久性 更完善的支持。

栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

Java的堆或者说内存堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

堆栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和对象句柄。

栈有一个很重要的特殊性，就是存在栈中的数据可以共享 。 假设我们同时定义：

int a = 3;

int b = 3；

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

String是一 个特殊的包装类数据。可以用：

String str = new String("abc");

String str = "abc";

两种的形式来创建，第一种是用new()来新 建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。

－＞ String str = new String("abc");自己补充：应该说有会产生两个对象，一个为new String("abc")的实体对象放到内存堆中， 一个为堆栈对象ｓｔｒ 也就是类实例对象的引用对象。

而第二种（String str = "abc";）是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。

比较类里面的数值是否相等时，用equals()方法；当 测试两个包装类的引用是否指向同一个对象时，用==， 下面用例子说明上面的理论。

String str1 = "abc";

String str2 = "abc";

System.out.println(str1==str2); //true

可以看出str1和 str2是指向同一个对象的。

String str1 =new String ("abc");

String str2 =new String ("abc");

System.out.println(str1==str2); // false

用new的方式是生成不同的对象。每一次生成一个 。

因此用第二种方式（String str = "abc";）创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。

另一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象。由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。

(http://blog.csdn.net/gaowenming/archive/2010/02/22/5316423.aspx)资料借鉴

总结完毕！

封装和隐藏

理解封装

封装（Encapsulation）是面向对象三大特征之一（封装、继承、多态），它指的是将对象的状态信息隐藏在内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。

对一个类或对象实现良好的封装，可以实现以下目的：

µ隐藏类的实现细节。

µ让使用者只能通过事先预定的方法访问数据，从而可以在该方法里加入控制逻辑，限制对属性不合理访问。

µ可进行数据检查，从而有利于保证对象信息的完整性。

µ便于修改，提高代码的可维护性。

为了实现良好的封装，需要从两个方面考虑：

µ将对象的属性和实现细节隐藏起来，不允许外部直接访问。

µ把方法暴露出来，让方法来操作或访问这些属性。

注意：对于类而言，可以使用public和默认访问控制符修饰，使用public修饰的类可以被所有类使用，不使用任何访问控制符修饰的类只能被同一个包中的所有类访问。

定义Person类，实现良好的封装。

public class Person{

private String name;

private int age;

public void setName(String name) {

//要求用户名必须在2～6位之间

if (name.length() > 6 || name.length() < 2){

System.out.println("您设置的人名不符合要求");

}else{

this.name = name;

}

}

public String getName(){

return this.name;

}

public void setAge(int age){

//要求用户年龄必须在0～100之间

if (age > 100 || age < 0){

System.out.println("您设置的年龄不合法");

}else{

this.age = age;

}

}

public int getAge(){

return this.age;

}

}

注意：属性的getter方法和setter方法有重要的意义，命名应遵循的原则：将原属性名的首字母大写，并在前面分别增加set和get动词，就变成setter和getter方法名 。

访问控制符的使用总结：

µ类中绝大部分属性应该使用 private修饰，除了一些static修饰的、类似全局变量的属性，才考虑使用 public修饰。

µ有些方法只是用于辅助实现该类的其他方法，这些方法被称为工具方法，也应用 private修饰。

µ如果某个类主要用作其他类的父类，该类里包含的大部分方法可能仅希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰这些方法。

µ希望暴露出来给其他类自由调用的方法使用public修饰。

µ顶级类通常都希望被其他类自由使用，所以大部分顶级类都使用public修饰。

¯ package和import

µ 包：Java中，包（package）是一组相关的类和接口的集合。Java编译器将包与文件系统的目录一一对应起来。

µ

µ

优点：

ü避免大量类的重名冲突，扩大名字空间。

ü包体现了

封装机制

。

µ 包的创建：如果希望把一个类放在指定的包结构下，应该在Java源程序的 第一个非注释行放如下格式的代码：package packageName[.packageName[…]]；

µ

例4.18 包的创建。

package hbsi；

public class HelloWorld{

public static void main(String[] args) {

System.out.println("Hello World!");

}

}

注意：

ü包名是有效地标识符即可，但从可读性规范角度来看，包名应该全部由小写字母组成。

ü为了避免不同公司之间类名的重复，Sun建议使用单位Internet域名倒写来作为包名，

üpackage语句必须作为源文件的第一句非注释性语句，一个源文件只能指定一个包，该源文件中可以定义多个类，则这些类将全部位于该包下。

ü如果没有显示指定package语句，则处于无名包下。实际企业开发中，通常不会把类定义在无名包下。

µ 包中类的使用

如果要使用包中的类，可以有两种方法：

ü引用包中的类（使用类的全限定名称）myPackage .mySubPackage . Book bookObj＝new myPackage .mySubPackage . Book();

üimport语句引入包中的类

格式：import  包名 .类名；

或       import  包名 .*；       //“*”号表示所有类

例如： import  myPackage .mySubPackage.*；

Book bookObj=new Book();

注意：在引入具有层次结构的包时，“*”号仅仅表示该包中的所有类，如果该包中还有子包，那么子包中的类时不被包括的。

µ比较两种方法的优缺点：

ü适用包名作前缀的方法使程序清晰，很容易就看出所使用的类位于哪个包中；而引入包的方法要知道某个类所在的包比较困难．

ü使用引入包的方法会带来名字冲突的问题，而使用包名作前缀不会存在这样的问题．

ü使用包名作前缀书写程序时比较麻烦．

µ静态导入

JDK1.5以后更是增加了一种静态导入的语法，它用于导入指定类的某个静态属性值或全部静态属性值。

ü导入指定类单个静态属性

import static 父包.子包…类名.静态属性名;

例：import static java.lang.System.out;

ü导入指定类全部静态属性

import static 父包.子包…类名.*;

例：import static java.lang.Math.*;

隐藏的实现

在面向对象的设计中，最关键的问题就是”将会变与不会变的东西分离开来”。

有时为了不让客户程序员修改他们不该修改的东西，有时为了让自己修改代码之后不会让客户程序出现问题，就必须设置一些控制访问符，来限定各自的访问范围。

Java 中的范围控制符有4个，分别是private、package(默认的范围)、protected、public,

权限范围由小到大。

方法及属性的访问控制

Private的访问范围是只有在本类中才可以访问

Package的访问范围是在本package中的所有类都可以访问

Protected的访问范围是该类的子类，及和它在同一package中的类可以访问

Public在任何地方都可以访问

类的访问控制

类的访问权限只能是package(默认)和public的

为了控制不让别人随便访问这个类，可以通过将这个类的构造函数设为private，这样就只有你就没有人可以创建这个对象啦。

你可以用一个static（静态）方法创建对象。

实例：

public  class Sample {

private Sample (){

System.out.println("create a Sample ");

}

public  static Sample get Sample (){

return new Sample ();

}

}

或者可以先定义创建一个private的static的对象，再通过一个public的static方法返回这个对象的引用，这样做到话可以实现 singleton（单例）模式，只会创建一个对象。

实例:

public  class Sample {

private static Sample s1 = new Sample ();

public static Sample getSample(){

return s1;

}}

隐藏与覆盖的区别

关于隐藏和覆盖的区别，要提到RTTI（run-time type identification）（运行期类型检查），也就是运行期的多态，当一个父类引用指向子类对象的时候，请看下面我编写的一段代码：

代码如下:

public class RunTime {

public static void main(String[] args) {

Animal a = new Cat();

System.out.println(a.A);

System.out.println(a.b);

a.voice();

a.method();

}

}

class Dog extends Animal {

public int b = 3;

public static int A = 3;

public static void method(){

System.out.println("狗");

}

public void voice() {

System.out.println("狗叫");

}

}

class Cat extends Animal {

public int b = 4;

public static int A = 4;

public static void method(){

System.out.println("猫");

}

public void voice() {

System.out.println("猫叫");

}

}

class Animal {

public int b = 0;

public static int A = 0;

public static void method(){

System.out.println("动物");

}

public void voice() {

System.out.println("动物叫");

}

}

输出结果是：

0

0

猫叫

动物

转载自：https://blog.csdn.net/u011225629/article/details/45309955

Java JVM

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。