java变量类型及修饰符

Java变量类型

局部变量

• 局部变量声明在方法、构造函数或语句块中
• 局部变量在方法、构造函数、或者语句块被执行的时候创建，当他们执行完，就会被销毁
• 访问修饰符不能用于局部变量
• 局部变量只在声明它的方法、构造函数或者语句块中可见
• 局部变量是在栈上分配的
• 局部变量没有默认值，所以局部变量被声明后，必须初始化，才可以使用

		package com.runoob.test;
		public class Test{ 
		   public void pupAge(){
		      int age = 0;
		      age = age + 7;
		      System.out.println("小狗的年龄是: " + age);
		   }
		   
		   public static void main(String[] args){
		      Test test = new Test();
		      test.pupAge();
		   }
		}

结果为：

		小狗的年龄是： 7

在下面例子中age没有初试化，所以编译的时就会报错：

		package com.runoob.test;
		 
		public class Test{ 
		   public void pupAge(){
		      int age;
		      age = age + 7;
		      System.out.println("小狗的年龄是 : " + age);
		   }
		   
		   public static void main(String[] args){
		      Test test = new Test();
		      test.pupAge();
		   }
		}

结果为：

实例变量

• 实例变量声明在一个类中，但在方法、构造函数和语句块之外
• 当一个对象被初试化之后，每个实例变量的值就跟着确定
• 实例变量在对象被创建的时候创建，在对象被销毁的时候销毁
• 实例变量的值至少被一个方法、构造函数或者语句块引用，使得外部变量能够通过这些信息访问实例变量
• 实例变量可以声明在使用前或使用后
• 访问修饰符开修饰实例变量
• 实例变量对于类中的方法、构造方法或者语句块是可见的，一般情况下应该吧实例变量设置为私有。通过使用访问修饰符可以使实例变量对子类可见
• 实例变量有默认值。数值型变量的默认值为0，布尔型变量的默认值为false，引用类型变量的默认值为null。变量的值可以在声明的时候指定，也可以在构造方法中指定
• 实例变量可以直接通过变量名访问，但在静态方法以及其他类中，就应该使用完全限定名

		import java.io.*;
		public class Employee{
		   // 这个实例变量对子类可见
		   public String name;
		   // 私有变量，仅在该类可见
		   private double salary;
		   //在构造器中对name赋值
		   public Employee (String empName){
		      name = empName;
		   }
		   //设定salary的值
		   public void setSalary(double empSal){
		      salary = empSal;
		   }  
		   // 打印信息
		   public void printEmp(){
		      System.out.println("名字 : " + name );
		      System.out.println("薪水 : " + salary);
		   }
		 
		   public static void main(String[] args){
		      Employee empOne = new Employee("RUNOOB");
		      empOne.setSalary(1000);
		      empOne.printEmp();
		   }
		}

结果为：

名字：RUNOOB
薪水：1000.0

类变量（静态变量）

• 类变量也称为静态变量，在类中以static关键字声明，但必须在方法之外
• 无论一个类创建多少个对象，类只拥有类变量的一份值拷贝
• 静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变
• 静态变量储存在静态存储区。经常被声明为常量，但是单独使用static声明变量
• 静态变量在第一次被访问时创建，在程序结束时销毁
• 与实例变量相似。数值型变量默认值为0，布尔型变量默认值为false，引用型变量默认值为null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化
  -静态变量可以通过：ClassName.VariableName的方式访问
  类变量被声明为public static fianl类型时，类变量的名称一般建议使用大写字母，如果静态变量不是public和final类型，起命名方式与实例变量以及局部变量的命名方式一致

		mport java.io.*;
		 
		public class Employee {
		    //salary是静态的私有变量
		    private static double salary;
		    // DEPARTMENT是一个常量
		    public static final String DEPARTMENT = "开发人员";
		    public static void main(String[] args){
		    salary = 10000;
		        System.out.println(DEPARTMENT+"平均工资:"+salary);
		    }
		}

结果为：

开发人员平均工资：100000.0

Java修饰符

• 访问修饰符
• 非访问修饰符
  修饰符用来定义类、方法或者变量，通常放在语句的最前端

		public class ClassName {
		   // ...
		}
		private boolean myFlag;
		static final double weeks = 9.5;
		protected static final int BOXWIDTH = 42;
		public static void main(String[] arguments) {
		   // 方法体
		}

访问控制修饰符
java中，可以使用访问控制修饰符来保护对类、变量、方法和构造方法的访问。java支持四种不同的权限。

• default：在同一个包类可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private：在同一类中可见。使用对象：变量、方法。注意：不能修饰类
• public：对所有类可见。使用对象：类、接口、变量、方法
• protected：对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类
  

默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final，而接口里的方法默认情况下访问权限设置为public.
如：变量和方法的声明可以不使用任何修饰符

		String version = "1.5.1" ;
		boolean processOrder(){
			returm true;
		}

私有访问修饰符-private
私有访问修饰符是最严格的的访问级别，所以被声明为private的方法、变量和构造方法只能被所属类访问，并且类和接口不能被声明为private
声明为私有访问类型的变量只能通过公有类中的公共的getter方法被外部类访问
Private访问修饰符的主要用来隐藏类的实现细节和保护类的数据
如：

		public class Logger {
		   private String format;
		   public String getFormat() {
		      return this.format;
		   }
		   public void setFormat(String format) {
		      this.format = format;
		   }
		}

实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）
公有访问修饰符-public
被声明为public的类、方法、构造方法和接口能够被任何其他类访问
如果几个相互访问的public类分布在不同的包内，则需要导入相应的public类所在的包。由于类的继承性，类所有的公有方法和变量都能被其他子类继承
如：

		public static void main(String [] arguments){
		}

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。
受保护的访问修饰符-protected
protected需要从以下来说明：
      子类与基类在同一个包中：被声明为protect的变量、方法和构造器能被同一个包中的任何其他类访问
      *子类与基类不在同一个包中：那么在子类中，子类实例可以访问其从基类*继承而来的protected方法，而不能访问基类实例的protected方法
protected可以修饰数据成员，构造方法，方法成员，不能修饰1类
接口以接口成员变量和成员方法不能被声明为protected方法
子类能够访问protected修饰的方法和变量，这样就能保护不相关的类使用这些方法和变量
如：

		class AudioPlayer {
		   protected boolean openSpeaker(Speaker sp) {
		      // 实现细节
		   }
		}
		 
		class StreamingAudioPlayer extends AudioPlayer {
		   protected boolean openSpeaker(Speaker sp) {
		      // 实现细节
		   }
		}

父类使用了protected访问修饰符，子类重写了父类的openSpeaker()方法
如果把openSpeaker()方法声明为private,那么除了AudioPlayer 之外的类将不能访问该方法
如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。
如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。

访问控制和继承

• 父类中声明为public的方法在子类中也必须为public
• 父类中声明为protected的方法在子类中要么声明为protected,要么声明为public,不能声明为private
• 父类中声明为private的方法，不能被继承

非访问修饰符
为了实现一些其他的功能，Java也提供了许多非访问修饰符
static修饰符，用来修饰方法变量
final修饰符，用来修饰类，方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承的类重新定义，修饰的变量为常量，是不可修改的1
abstract修饰符，用来定义抽象类和抽象方法
synchronized和volatile修饰符，主要用于线程的编程

static修饰符
静态变量
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
如：

		public class InstanceCounter {
		   private static int numInstances = 0;
		   protected static int getCount() {
		      return numInstances;
		   }
		 
		   private static void addInstance() {
		      numInstances++;
		   }
		 
		   InstanceCounter() {
		      InstanceCounter.addInstance();
		   }
		 
		   public static void main(String[] arguments) {
		      System.out.println("Starting with " +
		      InstanceCounter.getCount() + " instances");
		      for (int i = 0; i < 500; ++i){
		         new InstanceCounter();
		          }
		      System.out.println("Created " +
		      InstanceCounter.getCount() + " instances");
		   }
		}

结构为：

		Starting with 0 instances
		Created 500 instances

final修饰符
final变量
final用来表示“最后的，最终的含义”，变量一旦被赋值，不能被重新赋值。被final修饰的实例变量必须显示指定初始值。
final修饰符通常和static修饰符一起用来创建类常量
如：

		public class Test{
		  final int value = 10;
		  // 下面是声明常量的实例
		  public static final int BOXWIDTH = 6;
		  static final String TITLE = "Manager";
		 
		  public void changeValue(){
		     value = 12; //将输出一个错误
		  }
		}

final方法
父类中的final方法可以被子类继承，但是不能被子类重写
声明final方法的主要目的是防止该方法的内容被修改
如：

		public class Test{
		    public final void changeName(){
		       // 方法体
		    }
		}

final类：
final类不能被继承，没有类能够继承final类的任何特性
abstract修饰符
抽象类
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充
一个类不能同时被abstract和final修饰，如果一个类包含抽象方法，那么该类一定要一个声明为抽象类，否则将会出现变异错误
抽象类可以包含抽象方法和非抽象方法。
如：

		abstract class Caravan{
		   private double price;
		   private String model;
		   private String year;
		   public abstract void goFast(); //抽象方法
		   public abstract void changeColor();
		}

抽象方法
抽象方法是一个没有任何实现的方法，该方法的具体实现由其子类提供。
抽象方法不能被声明为final和static.
任何抽象类的子类必须实现父类非所有抽象方法，除非该子类也是抽象类
如果一个类包含若干抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法声明以分号结尾。例如：public abstract sample();
如：

		public abstract class SuperClass{
		    abstract void m(); //抽象方法
		}
		 
		class SubClass extends SuperClass{
		     //实现抽象方法
		      void m(){
		          .........
		      }
		}

线程的修饰符后续耿欣
注：以上知识来源于菜鸟驿站java课程，更多详细请关注菜鸟驿站