类，方法，变量（public、protected、private、static、final）

81 阅读 0 评论 54 点赞

我是靠谱客的博主酷炫月光，最近开发中收集的这篇文章主要介绍类，方法，变量（public、protected、private、static、final），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

[修饰符] class 类名{
     零到多个构造器定义;
     零到多个Field;
     零到多个方法;
}

一、类

类修饰符：

public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。
final，将一个类声明为最终（即非继承类），表示他不能被其他类继承。
不加修饰符，默认只有在相同包中的对象才能使用这样的类
（final和abstract不能同时出现）

1.每个编译单元（文件）都只能有一个public类。这表示，每个编译单元都有单一的公共接口，用public类来表现。该接口可以按要求包含众多的支持包访问权限的类。如果在某个编译单元内有一个以上的public类，编译器就会给出出错信息。

2.public类的名称必须完全与含有该编译单元的文件名相匹配，包括大小写。所以对于Widget而言，文件的名称必须是Widget.java，而不是widget.java或WIDGET.java。如果不匹配，同样将得到编译时错误。

3.虽然不是很常用，但编译单元内完全不带public类也是可能的。这种情况下，可以随意对文件命名。

4.一个Java文件可以有多个类作为内部类/Adapter类/其它类，但是只能有一个public主类，且类名必须和文件名一致。

二、类和类的实例对象

类名对象名 = new 类名(); // 创建实例对象的根本方法是使用构造器，这里默认调用的是无参的构造器

static修饰的方法和Field（成员变量），既可以通过类调用，也可以通过实例对象调用。

如果没有static修饰符，只能先创建实例对象，再通过实例对象调用。

二、方法

方法的访问修饰符：
这里写图片描述

static：修饰静态方法，static方法是类的方法。也就是说，类被加载到内存之后，即使没有对象的情况下也能够被正常调用的方法。
每个类中的main方法必须是static方法，作为入口。

abstract：修饰抽象方法，没有方法体，由继承该类的子类来实现。

final：表示该方法已经“完成”，不可被覆盖。
（因此final和abstract不能同时出现）

===
典型的静态方法除了上面的main之外，还有，比如对类本身的一些操作，如：使用类的计数，或者工具类方法（Math.sin(), Thread.sleep()）等等。直接通过类进行调用。

静态方法不能调用非静态方法或变量，因为静态方法伴随着类的加载而加载，此时类的实例对象还没有被创建，即所有非静态方法和变量都没有被加载。因此不能直接调用。

静态方法中也不能使用this，因为this指代的是当前对象。

三、变量

成员变量（即Field）

成员变量的默认值：数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定

成员变量修饰符：

public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
默认，在同一包中的类可以访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。

成员变量根据有无static修饰符，可分为类变量（静态变量）和实例变量。

类变量：无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。静态变量可以通过：ClassName.VariableName的方式访问。

class TiXing{
    float up,height;
    static float down;

    TiXing(float x,float y,float z){
        up=x;
        height=y;
        down=z;
    }
}

public class ep3_9{
    public static void main(String args[]){
        TiXing one=new TiXing(1,2,3);
        System.out.println("one's down is:"+one.down);
        TiXing two=new TiXing(4,5,6);
        System.out.println("one's down is:"+one.down);
        System.out.println("two's down is:"+two.down);
    }
}

one’s down is:3.0
one’s down is:6.0
two’s down is:6.0

==========
局部变量

局部变量则分为形参(方法签名中定义的变量),方法局部变量(在方法内定义)和代码块局部变量(在代码块内定义(例如for循环里面的变量)),并且局部变量定义必须在方法里面!

成员变量可以不显式初始化，它们可以由系统设定默认值；局部变量没有默认值，所以必须设定初始赋值后才能正常使用。

还有，在内存中的位置也不一样。成员变量在所在类被实例化后，存在堆内存中（不管是基础类型还是引用类型）；局部变量不属于任何类或实例，因此它总是保存在其所在方法的栈内存中的。如果局部变量是基本类型的变量，则直接把这个变量的值保存在该变量对应内存中；如果局部变量是一个引用类型的变量，则这个变量里存放的是地址，通过该地址引用到该变量实际引用的对象或数组。

对于局部变量，如果是基本类型，会把值直接存储在栈；如果是引用类型，比如String s = new String("william");会把其对象存储在堆，而把这个对象的引用（指针）存储在栈。
再如
String s1 = new String(“william”);
String s2 = s1;
s1和s2同为这个字符串对象的实例，但是对象只有一个，存储在堆，而这两个引用存储在栈中。

类的成员变量在不同对象中各不相同，都有自己的存储空间(成员变量在堆中的对象中)，基本类型和引用类型的成员变量都在这个对象的空间中，作为一个整体存储在堆。而类的方法却是
该类的所有对象共享的，只有一套，对象使用方法的时候方法才被压入栈，方法不使用则不占用内存。

四、内部类

成员内部类
成员内部类的使用方法：
1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等
2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a
3、定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类对象名 = 外部类对象.new 内部类( );
4、编译上面的程序后，会发现产生了两个 .class 文件

1、外部类是不能直接使用内部类的成员和方法（需要先定义一个对象）
2、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。外部类名.this.变量名

成员内部类中不能使用static修饰符，由于内部类的对象保存有外部类对象的引用，因而不能在内部类中定义静态属性。换言之就是非静态内部类不能脱离外部类而独立存在

java为什么非静态内部类中不能有static修饰的属性，但却可以有常量？
如： public class InnerClassDemo{
int x; class A{
static int a = 0;//这样写是不合法的.
static final int b=0;//这样写是合法的
} }

java类加载顺序，首先加载类，执行static变量初始化，接下来执行对象的创建，如果我们要执行代码中的变量int a
初始化，那么必须先执行加载外部类，再加载内部类，最后初始化静态变量 a
,问题就出在加载内部类上面，我们可以把内部类看成外部类的非静态成员，它的初始化必须在外部类对象创建后以后进行，要加载内部类必须在实例化外部类之后完成
，java虚拟机要求所有的静态变量必须在对象创建之前完成，这样便产生了矛盾。

而java常量放在内存中常量池，它的机制与变量是不同的，编译时，加载常量是不需要加载类的，所以就没有上面那种矛盾。

静态内部类
静态内部类是 static 修饰的内部类，这种内部类的特点是：
1、静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问
2、如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名= new 内部类();

方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

方法内部类不能使用访问控制符和 static 修饰符。