java中如何使用Static的变量和方法

java中如何使用Static的变量和方法
java中如何使用Static的变量和方法

如何使用Static的变量和方法

有时你希望定义一个类成员,使它的使用完全独立于该类的任何对象。通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ,所以它被声明为static。

声明为static的变量实质上就是全局变量。当声明一个对象时,并不产生static变量的拷贝,而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制:

1.它们仅能调用其他的static 方法。

2.它们只能访问static数据。

它们不能以任何方式引用this 或super(关键字super 与继承有关)。

如果你需要通过计算来初始化你的static变量,你可以声明一个static块,Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块:

// Demonstrate static variables,methods,and blocks.

class UseStatic {

static int a = 3;

static int b;

static void meth(int x) {

System.out.println("x = " + x);

System.out.println("a = " + a);

System.out.println("b = " + b);

}

static {

System.out.println("Static block initialized.");

b = a * 4;

}

public static void main(String args[]) {

meth(42);

}

}

一旦UseStatic 类被装载,所有的static语句被运行。首先,a被设置为3,接着static 块执行(打印一条消息),最后,b被初始化为a*4 或12。然后调用main(),main() 调用meth() ,把值42传递给x。3个println ( ) 语句引用两个static变量a和b,以及局部变量x 。

注意:在一个static 方法中引用任何实例变量都是非法的。

下面是该程序的输出:

Static block initialized.

x = 42

a = 3

b = 12

在定义它们的类的外面,static 方法和变量能独立于任何对象而被使用。这样,你只要在类的名字后面加点号运算符即可。例如,如果你希望从类外面调用一个static方法,你可以使用下面通用的格式:classname.method( )

这里,classname 是类的名字,在该类中定义static方法。可以看到,这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

下面是一个例子。在main() 中,static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo {

static int a = 42;

static int b = 99;

static void callme() {

System.out.println("a = " + a);

}

}

class StaticByName {

public static void main(String args[]) {

StaticDemo.callme();

System.out.println("b = " + StaticDemo.b);

}

}

下面是该程序的输出:

a = 42

b = 99

java static 的使用方法

类方法 方法被声明为static后,则称为类方法。类方法相对于实例方法,前者区别于后者的地方:前者为属于该类的所有实例对象共享,无须实例化对象,仅通过类名即可访问(当然,是否能够直接访问,还取决于所声明的访问权限)。 因为被static化后产生上述特殊性,所以static变量都会在类被加载时初始化,而类方法也同时随类加载而进驻内存。先来段代码热热身吧~ 上段代码,输出结果为: null A Class 由结果可知,即字符串prvateStr的值为空。嘿,可别认为值应该是下面那样啊。那样 的话,进行下去就太具挑战性了。 A Class A Class 请记住一点,类变量初始化的顺序与其在类中的赋值顺序一致。

重写(覆盖) 或许大家对于面向对象编程语言最初的印象就是其语言单元是以父类、子类的关系存在着,而构建这一关系的就是继承机制了。子类可以继承父类一切非private的变量与方法,并且可以添加自己的变量与方法。在构建一个系统时,这机制让我们强烈地感觉到编程是一 门优雅的艺术。 来段小小的代码简单地展示下: 结果如下: Jack I am a thinking animal, and a Programmer

如上,子类Programmer中并没定义字符串characteristic,但我们却在其方法printProfession()中调用了;同样,我们正常使用了父类定义的printName()方法。而这就 是继承的简单实现。 继承不仅仅带来以上特性。它还赋予子类重写(覆盖)父类方法的能力(因为旨在讲类方法的重写,所以这儿就不讲重载以及变量在继承机制中的问题了)。方法的重写(覆盖):继承父类的子类,可以通过拟具有相同方法名与参数组的方法来重写父类中对应的方法,从而让子类更个性化。又因为重写(覆盖)的出现,多态也随之产生。多态:通过父类变量可以引用其子类对象,从而调用子类中那些继承自自己并被重写(覆盖)的方法。

实验4:静态变量、静态方法与包

实验4:静态变量、静态方法与包实验目的 1、熟练静态变量、静态方法、实例变量、实例方法的概念 2、掌握包的概念与应用。 实验内容 一、静态变量 1.阅读下列程序,并按照要求完成后续功能。 class Point { private int x,y; Point (int xValue, int yValue) { x=xValue; y=yValue; }; public int GetX() { return x; } public int GetY() { return y; } public void SetY(int value) { y=value; } public void SetX(int value) { x=value; } } class Managerpoint { static int count=0; Point createPoint(int x,int y)

{ 提示:在此处加入代码,完成程序的输出要求 } } public class one { public static void main(String[] args) { // TODO Auto-generated method stub Managerpoint mPoint =new Managerpoint(); for(int i=0;i<9;i++){ Point p=mPoint.createPoint(i,20); System.out.print("当前点的总数为:"+Managerpoint.count); System.out.println("当前点的x值为:"+p.GetX()); } } } 注意:本例中使用的“20”仅仅是作为一个测试数据。 在提示处加入代码,要求: ●除提示处代码,其他代码保持不变 ●Main方法的执行结果为: 当前点的总数为:1当前点的x值为:0 当前点的总数为:2当前点的x值为:1 当前点的总数为:3当前点的x值为:2 当前点的总数为:4当前点的x值为:3 当前点的总数为:5当前点的x值为:4 当前点的总数为:6当前点的x值为:5 当前点的总数为:7当前点的x值为:6 当前点的总数为:8当前点的x值为:7 当前点的总数为:9当前点的x值为:8 2.改错。 理解静态方法可访问静态变量,但在静态方法中不能直接访问实例变量。 提示: 阴影处为需要修改的代码。 public class one { int x=8; int y=9; final int i=10; static int getY(){ return y; } static int getI(){ return i;

JAVA三种变量的初始化

JAVA三种变量的初始化 问题讨论变量的初始化,所以先来看一下Java中有哪些种类的变量。 1. 类的属性,或者叫值域 2. 方法里的局部变量 3. 方法的参数 对于第一种变量,Java虚拟机会自动进行初始化。如果给出了初始值,则初始化为该初始值。如果没有给出,则把它初始化为该类型变量的默认初始值。 int类型变量默认初始值为0 float类型变量默认初始值为0.0f double类型变量默认初始值为0.0 boolean类型变量默认初始值为false

char类型变量默认初始值为0(ASCII码) long类型变量默认初始值为0 所有对象引用类型变量默认初始值为null,即不指向任何对象。注意数组本身也是对象,所以没有初始化的数组引用在自动初始化后其值也是null。 对于两种不同的类属性,static属性与instance属性,初始化的时机是不同的。instance属性在创建实例的时候初始化,static属性在类加载,也就是第一次用到这个类的时候初始化,对于后来的实例的创建,不再次进行初始化。这个问题会在以后的系列中进行详细讨论。 对于第二种变量,必须明确地进行初始化。如果再没有初始化之前就试图使用它,编译器会抗议。如果初始化的语句在try块中或if块中,也必须要让它在第一次使用前一定能够得到赋值。也就是说,把初始化语句放在只有if块的条件判断语句中编译器也会抗议,因为执行的时候可能不符合if后面的判断条件,如此一来初始化语句就不会被执行了,这就违反了局部变量使用前必须初始化的规定。但如果在

else块中也有初始化语句,就可以通过编译,因为无论如何,总有至少一条初始化语句会被执行,不会发生使用前未被初始化的事情。对于try-catch也是一样,如果只有在try块里才有初始化语句,编译不通过。如果在catch或finally里也有,则可以通过编译。总之,要保证局部变量在使用之前一定被初始化了。所以,一个好的做法是在声明他们的时候就初始化他们,如果不知道要初始化成什么值好,就用上面的默认值吧! 其实第三种变量和第二种本质上是一样的,都是方法中的局部变量。只不过作为参数,肯定是被初始化过的,传入的值就是初始值,所以不需要初始化。

Java--static关键字的

static关键字 如果使用一个类则会在实例化对象时分别开辟栈内存及堆内存,在堆内存中要保存对象中的属性,每个对象都有自己的属性,如果你现在有些属性希望被共享,则就必行将其声明为static属性,而且一个属性声明为static属性,可以直接使用类名称进行调用,如果一个类中的方法想由类调用,则可以声明为static方法。 一.使用static声明属性 如果程序中使用static声明属性,则属性成为全局属性(有些也称为静态属性),那么声明为全局属性到底有什么用吶?观察以下代码: class Person{ // 定义Person类 String name ; // 定义name属性,暂时不封装 int age ; // 定义age属性,暂时不封装 String country = "A城" ; // 定义城市属性,有默认值 public Person(String name,int age){ https://www.360docs.net/doc/154570123.html, = name ; this.age = age; } public void info(){ // 得到信息 System.out.println("姓名:" + https://www.360docs.net/doc/154570123.html, + ",年龄:" + this.age + ",城市:" + country) ; } }; public class StaticDemo01{ public static void main(String args[]){ Person p1 = new Person("张三",30) ; // 实例化对象 Person p2 = new Person("李四",31) ; // 实例化对象 Person p3 = new Person("王五",32) ; // 实例化对象 https://www.360docs.net/doc/154570123.html,() ; https://www.360docs.net/doc/154570123.html,() ; https://www.360docs.net/doc/154570123.html,() ; } }; 运行结果: 姓名:张三,年龄:30,城市:A城 姓名:李四,年龄:31,城市:A城 姓名:王五,年龄:32,城市:A城 以上代码,为了观察方便没有使用private关键字进行封装。以上的程序是一个简单的程序,但是代码中有些不妥之处。 实际上,如果现在假设此城市不叫A城,而改为了B城,而且此类产生了200个对象,那么就意味着要把这些对象的城市属性全部修改一边。这样显然是不行的。最好的方法是修改一次就可以,此时可以把城市属性使用static关键字进行声明,将其变为公共属性。 使用static声明属性: class Person{ // 定义Person类

Java中的static变量、方法、代码块

1、static变量 按照是否静态的对类成员变量进行分类可分两种:一种是被static修饰的变量,叫静态变量或类变量;另一种是没有被static修饰的变量,叫实例变量。两者的区别是: 对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也可以通过对象来访问(但是这是不推荐的)。 对于实例变量,每创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响(灵活)。 2、static方法 静态方法可以直接通过类名调用,任何的实例也都可以调用,因此静态方法中不能用this和super关键字,不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法),只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联!这个需要去理解,想明白其中的道理,不是记忆!!! 因为static方法独立于任何实例,因此static方法必须被实现,而不能是抽象的abstract。 3、static代码块 static代码块也叫静态代码块,是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。 例子: class A{ static{ System.out.println("A static block"); // (3)运行 } { System.out.print("Q"); // (5)运行 } public A (){ System.out.println("x"); // (6)运行 } } class B extends A{ static{ System.out.println("B static block"); // (4)运行 } { System.out.print("W"); // (7)运行 }

JAVA语言中的final修饰符

final关键字可用于修饰类,变量和方法,final关键字有点类似c#里的sealed关键字(如果大家学过C#就知道),它用于表示它修饰的类,方法和变量不可改变。 final变量 final修饰变量时,表示该变量一旦获得了初始值就不可改变,final既可修饰成员变量(包括类变量和实例变量),也可以修饰局部变量,形参。严格来说final修饰的变量不要被改变,一旦获得初始值之后,该final变量的值就不能被重新赋值。 因为final变量获得初始值之后不能被重新赋,因此final修饰成员变量和修饰局部变量时有一定的不同:下面我将会写到有哪些方面的不同,还有就是为什么会不同。 final修饰成员变量 成员变量是随类初始化或对象初始化而初始化的。当类初始化时,系统会为该类属性分配内存,并分配默认值;当创建对象时,系统会为该对象的实例属性分配内存,并分配默认值。也就是说,当执行静态初始化块时可以对类属性赋初始值,当执行普通初始块,构造器时可对实例属性赋初始值。因此,成员变量的初始值可以在定义该变量时指定默认值,可以在初始化块,构造器中指定初始值,否则,成员变量的初始值将是由系统自动分配的初始值。 对于final修饰的成员变量而言,一旦有了初始值之后,就不能重新赋值,因此不可以在普通方法中对成员变量重新赋值。成员变量只能在定义该成员变量时指定默认值,或者在静态初始化块,初始化块,构造器中为成员变量指定初始值,如果既没有在定义成员变量时指定初始值,也没有在初始化块,构造器中为成员变量指定初始值,那么这些成员变量的值将一直是0,\u0000,false null这些成员变量也就失去了存在的意义。 因此当使用final修饰成员变量的时候,要么在定义成员变量时候指定初始值,要么

java基础知识点总结

Created by AIwen on 2017/5/14. java是面向对象的程序设计语言;类可被认为是一种自定义的数据类型,可以使用类来定义变量,所有使用类定义的变量都是引用变量,它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征,而对象则是类的具体存在,java程序使用类的构造器来创建该类的对象。 java也支持面向对象的三大特征:封装、继承、和多态。java提供了private、protected、和public三个访问控制修饰符来实现良好的封装,提供了extends关键字让子类继承父类,子类继承父类就可以继承到父类的成员变量和和方法,如果访问控制允许,子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段。使用继承关系来实现复用时,子类对象可以直接赋给父类变量,这个变量具有多态性。 面向对象的程序设计过程中有两个重要的概念:类(Class)和对象(object,也被称为实例,instance)。类可以包含三种最常见的成员:构造器、成员变量、和方法。 构造器用于构造该类的实例,java语言通过new关键字类调用构造器,从而返回该类的实例。构造器是一个类创建对象的根本途径,如果一个类没有构造器,这个类通常无法创建实例。因此java语言提供了一个功能:如果程序员没有为一个类编写构造器,则系统会为该类提供一个默认的构造器,这个构造器总是没有参数的。一旦程序员为一个类提供了构造器,系统将不再为该类提供构造器。 构造器用于对类实例进行初始化操作,构造器支持重载,如果多个重载的构造器里包含了相同的初始化代码,则可以把这些初始化代码放置在普通初始化块里完成,初始化块总在构造器执行之前被调用。静态初始化块代码用于初始化类,在类初始化阶段被执行。如果继承树里某一个类需要被初始化时,系统将会同时初始化该类的所有父类。 构造器修饰符:可以是public、protected、private其中之一,或者省略构造器名:构造器名必须和类名相同。 注意:构造器既不能定义返回值类型,也不能使用void声明构造器没有返回值。如果为构造器定义了返回值类型,或使用void声明构造器没有返回值,编译时不会出错,但java会把这个所谓的构造器当成方法来处理——它就不再是构造器。 实际上类的构造器是有返回值的,当使用new关键字来调用构造器时,构造器返回该类的实例,可以把这个类的实例当成构造器的返回值。因此构造器的返回值类型总是当前类,无须定义返回值类型。不要在构造器里显式的使用return来返回当前类的对象,因为构造器的返回值是隐式的。 java类名必须是由一个或多个有意义的单词连缀而成的,每个单词首字母大写,其他字母全部小写,单词与单词之间不要使用任何分隔符。 成员变量: 成员变量的修饰符:public、protected、private、static、final前三个只能出现一个再和后面的修饰符组合起来修饰成员变量,也可省略。 成员变量:由一个或者多个有意义的单词连缀而成,第一个单词首字母小写,后面每个单词首字母大写,其他字母全部小写,单词与单词之间不要使用任何分隔符。 类型:可以是java语言允许的任何数据类型,包括基本类型和引用类型。 成员方法: 方法修饰符:public、protected、private、static、final、abstract,前三个只能出现一个,static和final最多只能出现其中的一个,和abstract组合起来使用。也可省略。 返回值类型:可以是java语言的允许的任何数据类型,包括基本类型和引用类型。 方法名:和成员变量的方法命名规则相同,通常建议方法名以英文动词开头。 方法体里多条可执行语句之间有严格的执行顺序,排在方法体前面的语句总先执行,排在方法体后面的语句总是后执行。 static是一个特殊的关键字,它可用于修饰方法、成员变量等成员。static修饰的成员表明它属于这个类本身,而

Java 中的 static 使用之静态方法

Java 中的static 使用之静态方法 与静态变量一样,我们也可以使用 static 修饰方法,称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。静态方法的使用如: 需要注意: 1、静态方法中可以直接调用同类中的静态成员,但不能直接调用非静态成员。如: 如果希望在静态方法中调用非静态变量,可以通过创建类的对象,然后通过对象来访问非静态变量。如: 、在普通成员方法中,则可以直接访问同类的非静态变量和静态变量,如下所示:

3、静态方法中不能直接调用非静态方法,需要通过对象来访问非静态方法。如: ava 中的static 使用之静态初始化块 Java 中可以通过初始化块进行数据赋值。如: 在类的声明中,可以包含多个初始化块,当创建类的实例时,就会依次执行这些代码块。如果使用 static 修饰初始化块,就称为静态初始化块。 需要特别注意:静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。 我们来看一段代码:

运行结果: 通过输出结果,我们可以看到,程序运行时静态初始化块最先被执行,然后执行普通初始化块,最后才执行构造方法。由于静态初始化块只在类加载时执行一次,所以当再次创建对象 hello2 时并未执行静态初始化块。 封装 1、概念: 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问 2、好处 a:只能通过规定的方法访问数据 b:隐藏类的实例细节,方便修改和实现。 什么是Java 中的内部类 问:什么是内部类呢? 答:内部类( Inner Class )就是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。 问:那为什么要将一个类定义在另一个类里面呢?清清爽爽的独立的一个类多好啊!! 答:内部类的主要作用如下:

Java关键字final使用总结

Java关键字final使用总结 一、final 根据程序上下文环境,Java关键字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 数据成员就可以实现依对象而有所不同,却有保持其恒定不变的特征。

java中如何使用Static的变量和方法

如何使用Static的变量和方法 有时你希望定义一个类成员,使它的使用完全独立于该类的任何对象。通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ,所以它被声明为static。 声明为static的变量实质上就是全局变量。当声明一个对象时,并不产生static变量的拷贝,而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制: 1.它们仅能调用其他的static 方法。 2.它们只能访问static数据。 它们不能以任何方式引用this 或super(关键字super 与继承有关)。 如果你需要通过计算来初始化你的static变量,你可以声明一个static块,Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块: // Demonstrate static variables,methods,and blocks. class UseStatic { static int a = 3; static int b; static void meth(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Static block initialized."); b = a * 4; } public static void main(String args[]) { meth(42); } } 一旦UseStatic 类被装载,所有的static语句被运行。首先,a被设置为3,接着static 块执行(打印一条消息),最后,b被初始化为a*4 或12。然后调用main(),main() 调用meth() ,把值42传递给x。3个println ( ) 语句引用两个static变量a和b,以及局部变量x 。 注意:在一个static 方法中引用任何实例变量都是非法的。 下面是该程序的输出: Static block initialized. x = 42 a = 3 b = 12

Java静态方法、静态变量,初始化顺序

Java静态方法、静态变量、初始化顺序 成员变量分为实例变量和静态变量。其中实例变量属于某一个具体的实例,必须在类实例化后才真正存在,不同的对象拥有不同的实例变量。而静态变量被该类所有的对象公有(相当于全局变量),不需要实例化就已经存在。南京Java软件培训机构 方法也可分为实例方法和静态方法。其中,实例方法必须在类实例化之后通过对象来调用,而静态方法可以在类实例化之前就使用。与成员变量不同的是:无论哪种方法,在内存中只有一份——无论该类有多少个实例,都共用同一个方法。南京Java软件培训机构 实例方法的调用: 1.ClassA a = new ClassA(); //必须经过实例化,用对象名访问 2. a.instanceMethod(); 静态方法的调用: 1. 1. a.staticMethod(); //无需经过实例化,用类名或者对象名访问 2. 静态方法的声明和定义 定义一个静态方法和定义一个实例方法,在形式上并没有什么区别,只是在声明的头部,需要加上一个关键字static。南京Java软件培训机构 3.静态方法和实例方法的区别 静态方法和实例方法的区别主要体现在两个方面: · 在外部调用静态方法时,可以使用“类名.方法名”的方式,也可以使用“对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说,调用静态方法可以无需创建对象。 · 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制。 实例代码:静态方法访问成员变量示例: 1.class accessMember{ 2.private static int sa; //定义一个静态成员变量 3.private int ia; //定义一个实例成员变量 4.//下面定义一个静态方法 5.static void statMethod(){ 6.int i = 0; //正确,可以有自己的局部变量 7.sa = 10; //正确,静态方法可以使用静态变量 8.otherStat(); //正确,可以调用静态方法 9.ia = 20; //错误,不能使用实例变量 10.insMethod(); //错误,不能调用实例方法 11.}

Java中super的几种用法并与this的区别

4.super和this的异同: 1)super(参数):调用基类中的某一个构造函数(应该为构造函数中的第一条语句) 2)this(参数):调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句) 3)super:它引用当前对象的直接父类中的成员(用来访问直接父类中被隐藏的父类中成员数据或函数,基类与派生类中有相同成员定义时如:super.变量名super.成员函数据名(实参) 4)this:它代表当前对象名(在程序中易产生二义性之处,应使用this来指明当前对象;如果函数的形参与类中的成员数据同名,这时需用this来指明成员变量名) 5)调用super()必须写在子类构造方法的第一行,否则编译不通过。每个子类构造方法的第一条语句,都是隐含地调用super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错。 6)super()和this()类似,区别是,super()从子类中调用父类的构造方法,this()在同一类内调用其它方法。 7)super()和this()均需放在构造方法内第一行。 8)尽管可以用this调用一个构造器,但却不能调用两个。 9)this和super不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有super语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。 10)this()和super()都指的是对象,所以,均不可以在static环境中使用。包括:static 变量,static方法,static语句块。 11)从本质上讲,this是一个指向本对象的指针, 然而super是一个Java关键字。1.静态方法 通常,在一个类中定义一个方法为static,那就是说,无需本类的对象即可调用此方法声明为static的方法有以下几条限制: 1)它们仅能调用其他的static 方法。 2)它们只能访问static数据。 3)它们不能以任何方式引用this 或super。 class Simple { static void Go() { System.out.println("Welcome"); } } public class Cal { public static void main(String[] args) { Simple.go(); } } 调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说,静态方法常常为应用程序中的其它类提供一些实用工具所用,在Java的类库中大量的静态方法正是出于此目的而定义的。 2. 静态变量 声明为static的变量实质上就是全局变量。当声明一个对象时,并不产生static变量的拷贝,而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例

JAVA学习总结

1、Print、Println、Printf的区别 Print: 将信息显示在命令窗口中,输出光标定位在最后一个字符之后; Println:将信息显示在命令窗口中,输出光标换行定位在下一行开头; Printf: 将信息进行格式化显示在命令窗口中,输出光标定位在最后一个字符之后,其来自C语言,产生格式化输出的函数(来自stdio.h中); 2、异常 如果有多个catch 语句,那么捕获父类异常的catch 语句必须放在后面,否则它会捕获它的所有子类异常,而使得子类异常catch 语句永远不会执行。 一般情况下 finally 语句块一般放在最后一个catch 语句块后,不管程序是否抛出异常,它都会执行。 throw与throws的区别 区别一:throw 是语句抛出一个异常;throws 是方法抛出一个异常; throw语法:throw <异常对象> 在方法声明中,添加throws子句表示该方法将抛出异常。 throws语法: [<修饰符>]<返回值类型><方法名>([<参数列表>])[throws<异常类>] 其中:异常类可以声明多个,用逗号分割。 区别二:throws可以单独使用,但throw不能; 区别三:throw要么和try-catch-finally语句配套使用,要么与throws配套使用。 但throws可以单独使用,然后再由处理异常的方法捕获。 可检测异常和非检测异常 Java的可检测异常和非检测异常泾渭分明。 可检测异常经编译器验证,对于声明抛出异常的任何方法,编译器将强制执行处理 或声明规则。 非检测异常不遵循处理或声明规则。在产生此类异常时,不一定非要采取任何适当 操作,编译器不会检查是否已解决了这样一个异常。有两个主要类定义非检测异常:RuntimeException和Error。 对于未检查异常,在方法抛出时可以不用throws 来声明,而检查异常则必须在throws声明后才能进行throw 抛出异常。 为什么Error子类属于非检测异常?这是因为无法预知它们的产生时间。若Java应用程序内存不足,则随时可能出现OutOfMemoryError;起因一般不是应用 程序中的特殊调用,而是JVM自身的问题。另外,Error类一般表示应用程序无法 解决的严重问题,故将这些类视为非检测异常。 RuntimeException类也属于非检测异常,一个原因是普通JVM操作引发的运行时异常随时可能发生。与Error不同,此类异常一般由特定操作引发。但这些操 作在Java应用程序中会频繁出现。例如,若每次使用对象时,都必须编写异常处 理代码来检查null引用,则整个应用程序很快将变成一个庞大的try-catch块。 因此,运行时异常不受编译器检查与处理或声明规则的限制。 将RuntimeException类作为未检测异常还有一个原因:它们表示的问题不一定作为异常处理。可以在try-catch结构中处理NullPointerException,但若在 使用引用前测试空值,则更简单,更经济。同样,可以在除法运算时检查0值,而 不使用ArithmeticException。

static和this的理解和用法总结

static和this的理解和用法小结 关键字static和this是初学者比较头疼的知识点,自己也一直比较模糊.现在整理一下,既可以加深自己的印象也可以便于以后查询. 其实在think in java里关于为什么要使用static写的比较详细,不明白的多读几遍会有很大的收获.一般在两钟情形下需要使用static关键字:一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象,甚至根本不创建对象。另一种情形是我们需要一个特殊的方法,它没有与这个类的任何对象关联。也就是说,即使没有创建对象,也需要一个能调用的方法。一旦将什么东西设为static,数据或方法就不会同那个类的任何对象实例联系到一起.所以尽管从未创建那个类的一个对象,仍能调用一个static方法,或访问一些static数据。而在这之前,对于非static数据和方法,我们必须创建一个对象,并用那个对象访问数据或方法。这是由于非static数据和方法必须知道它们操作的具体对象.有这样的一个类,其中定义一个静态数据: class Test { Static int i = 47; } Test st1 = new StaticTest();Test st2 = new StaticTest();即使们new了两个Test对象,但它们仍然只占据Test.i的一个存储空间。这两个对象都共享同样的i。对方法来说,static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法. 静态变量)一个静态对象属于一个类,但它不属于实例对象,也不是实例对象状态的一部分.每一个静态变量只存在一份.静态变量通常称为类变量(class variable).在实际中,经常需要这样的一个变量,它被一个类的所有实例对象所共享,如果它同时又是公有的,那么它就可以被这个类的任意访问者所使用.静态变量存在于类的作用域之内.通常声明为private.java中许多时候会用到public static final 这样的变量。静态变量可以被位于同一个作用域内的任意方或静态方法访问,访问时使用变量名称即可。如果在类作用域以外访问类,则要使用一个含有类名的表达式访问静态变量,例如: Integer.MAX_VALUE, 其中MAX_VALUE是在类库中声明过的。 静态方法)静态方法或类方法属于一个而不是属于某个实例对象实现的一部分。可以直接通过类来调用这种方法,而并不是只能由某个特定的实例对象调用。静态的方法不能用abstract声明,而且无论是否明确地指定实际上都是final型的。静态方法的声明格式: modifiers static typeName methodName (parameterList){ statementSequence } modifiers(可以从public,protect,private中选择一个),后面可以加上 final,nativc,synchronized中的一个或几个的组合。 static main是静态方法的一个特殊用法,用static main 方法来建立程序的初始状态,创建一组初始对象,并进行合理的方法调用,使得程序能够继续执行下去,static main方法使用String数组型参数包含了用户在运行时给出的任意命令行参数。

java实践教程5-基本类型和引用类型变量

上两次课我们知道了,java语言中的两种数据类型。这节课呢,我们对上两次课做一个补充,也加深一下理论知识的学习。理论的东西是很有用的啊。这节课介绍基本类型变量和引用类型变量。 Java中数据类型分为两大类,上次课已经讲完了,是基本类型和对象类型。相应的,变量也就有两种类型:基本类型和引用类型。基本类型自然不用说了,它的值就是一个数字,一个字符或一个布尔值。引用类型,可是引用类型呢?它是一个对象类型的啊,值是什么呢?它的值是指向内存空间的引用,就是地址,所指向的内存中保存着变量所表示的一个值或一组值。很好理解吧,因为一个对象,比如说一个人,不可能是个数字也不可能是个字符啊,所以要想找它的话只能找它的地址了。 罗唆: 我们在学习计算机的过程中,所谓的难的东西,就是以前没有听过的概念,和不常用的思想。像是这个引用类型的概念就是以前不常用的,基本类型当然好理解不讲大家也知道。所以我们对于这样陌生的概念我们只要多琢磨一下就会明白的。 我们废话少说,接下来看看这两种类型变量的不同处理吧。基本类型自然是简单,声明是自然系统就给它空间了。例如, int baijq; baijq=250; //声明变量baijq的同时,系统给baijq分配了空间。 引用类型就不是了,只给变量分配了引用空间,数据空间没有分配,因为谁都不知道数据是什么啊,整数,字符?我们看一个错误的例子: MyDate today; today.day = 4; //发生错误,因为today对象的数据空间未分配。 那我们怎么给它赋值啊?引用类型变量在声明后必须通过实例化开辟数据空间,才能对变量所指向的对象进行访问。举个例子: MyDate today; //将变量分配一个保存引用的空间 today = new MyDate(); //这句话是2步,首先执行new MyDate(),给today变量开辟数据空间,然后再执行赋值操作。 小总结: 刚才说了一大堆,其实就是一件事。如果是引用类型的变量,必须先得new 一个对象出来。不new哪来的对象啊,不new哪有数据空间啊?没有数据空间怎么能访问呢?这回明白了吧!

Java中的静态变量_静态方法_静态块与静态类

Java中的静态变量、静态方法、静态块与静态类 在Java中,static是一个关键字,我们不能用它来作为类名或包名,static主要有四种用途,即作为静态变量、静态方法、静态块和静态类。 1、静态变量Java static variables 静态变量就是类变量,它并不属于类的实例,仅属于类本身。在所有能访问该类的地方,也就可能访问或修改该变量,它是非线程安全的,因此,静态变量通常是和final关键字结合在一起,用来标识该变量是一个公共资源和常量。 只要静态变量不是private私有的,那么我们可通过ClassName.variableName的方式进行访问。 2、静态方法Java static methods 静态方法与静态变量一样,也是属于类本身而不属于类的实例对象。在一个静态方法中,除了局部变量外,它能访问的外部变量也必须是静态的,能访问的外部方法也必须是静态的,实例变量和实例方法均不能访问。

3、静态块Java static Block 静态块是由一些语句组成的段落,它在类被加载进内存时执行,且无论类被使用多少次它都只会执行一次。一个类的静态块可以有多个,其执行顺序由它在代码中的顺序决定。 4、静态类Java static methods 静态类都是内部类,static不能用于修饰顶级的类。对于单例模式用静态类来实现就是一个很不错的选择。 5、完整示例

//static variable example private static int count; //kept private to control it's value through setter public static String str; public int getCount() { return count; } //static method example public static void setCount(int count) { if(count > 0) StaticExample.count = count; } //static util method public static int addInts(int i, int...js){ int sum=i; for(int x : js) sum+=x; return sum; } //static class example - used for packaging convenience only public static class MyStaticClass{ public int count; } }

静态属性和非静态属性的赋值与取值

public class Test { static int age; //由static修饰,静态属性 int classNum; public static void main(String[] args) { Test person = new Test(); //在这个对象中赋值,12给了classNum,它是非静态属性,所以只在本空间中存在 person.classNum = 12; person.age = 20; //20给了静态属性,也就是说它存在于方法区,所有对象共用 //非静态属性 System.out.println("person中classNum的值:"+ person.classNum);//person中classNum的值:12 System.out.println("person中age的值:" + person.age);//person中age的值:20

Test person2 = new Test(); //因此,在这个新建的空间中,classNum获取不到值,但是age能获取得到20 //非静态属性 System.out.println("person2中classNum的值:" + person2.classNum);//person2中classNum的值:0 System.out.println("person2中age的值:" + person2.age);//person2中age的值:20 } } package com.qianfeng.day07.demo4; public class Pet2 { static int i = 0; /*运用场景: * 1、所有的对象共用某一个属性时,使用静态属性 * 2、跟final 一起使用,可以当常量用 * 3、国际化字符切换*/ public Pet2() { i++; method(); } public static void method() { System.out.println("生成的是第" + i + "个对象");

static变量和static函数的各自的特点

static变量和static函数的各自的特点 static变量大致分为三种用法 一、用于局部变量中,成为静态局部变量. 静态局部变量有两个用法,记忆功能和全局生存期. 二、用于全局变量,主要作用是限制此全局变量被其他的文件调用. 三、用于类中的成员.表示这个成员是属于这个类但是不属于类中任意特定对象 static 声明的变量. 在C语言中有两方面的特征: 1、变量会被放在程序的全局存储区中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2、变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 Tips: A.若全局变量仅在单个C文件中访问,则可以将这个变量修改为静态全局变量,以降低模块间的耦合度; B.若全局变量仅由单个函数访问,则可以将这个变量改为该函数的静态局部变量,以降低模块间的耦合度; C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时,需要考虑重入问题; D.如果我们需要一个可重入的函数,那么,我们一定

要避免函数中使用static变量(这样的函数被称为:带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时,则必须是static的局部变量的地址作为返回值,若为auto类型,则返回为错指针。 函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名。 扩展分析:术语static有着不寻常的历史.起初,在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后,static在C中有了第二种含义:用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字,所以仍使用static关键字来表示这第二种含义。最后,C++重用了这个关键字,并赋予它与前面不同的第三种含义:表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。

相关文档
最新文档