Java中static class

Java中static class
Java中static class

Java中的类可以是static吗?答案是可以。在java中我们可以有静态实例变量、静态方法、静态块。类也可以是静态的。

java允许我们在一个类里面定义静态类。比如内部类(nested class)。把nested class封闭起来的类叫外部类。在java中,我们不能用static修饰顶级类(top level class)。只有内部类可以为static。

静态内部类和非静态内部类之间到底有什么不同呢?下面是两者间主要的不同。

(1)内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。

(2)非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。

(3)一个非静态内部类不能脱离外部类实体被创建,一个非静态内部类可以访问外部类的数据和方法,因为他就在外部类里面。

基于上面的讨论,我们可以通过这些特性让编程更简单、有效。

/* 下面程序演示如何在java中创建静态内部类和非静态内部类 */

class OuterClass{

privatestatic String msg = "GeeksForGeeks";

// 静态内部类

publicstaticclass NestedStaticClass{

// 静态内部类只能访问外部类的静态成员

publicvoid printMessage() {

// 试着将msg改成非静态的,这将导致编译错误

System.out.println("Message from nested static class: " + msg);

}

}

// 非静态内部类

publicclass InnerClass{

// 不管是静态方法还是非静态方法都可以在非静态内部类中访问

publicvoid display(){

System.out.println("Message from non-static nested class: "+ msg); }

}

}

class Main

{

// 怎么创建静态内部类和非静态内部类的实例

publicstaticvoid main(String args[]){

// 创建静态内部类的实例

OuterClass.NestedStaticClass printer =

new OuterClass.NestedStaticClass();

// 创建静态内部类的非静态方法

printer.printMessage();

// 为了创建非静态内部类,我们需要外部类的实例

OuterClass outer = new OuterClass();

OuterClass.InnerClassinner =outer.new InnerClass();

// 调用非静态内部类的非静态方法

inner.display();

// 我们也可以结合以上步骤,一步创建的内部类实例

OuterClass.InnerClassinnerObject = new OuterClass().new InnerClass();

// 同样我们现在可以调用内部类方法

innerObject.display();

}

}

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()方法。而这就 是继承的简单实现。 继承不仅仅带来以上特性。它还赋予子类重写(覆盖)父类方法的能力(因为旨在讲类方法的重写,所以这儿就不讲重载以及变量在继承机制中的问题了)。方法的重写(覆盖):继承父类的子类,可以通过拟具有相同方法名与参数组的方法来重写父类中对应的方法,从而让子类更个性化。又因为重写(覆盖)的出现,多态也随之产生。多态:通过父类变量可以引用其子类对象,从而调用子类中那些继承自自己并被重写(覆盖)的方法。

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/f7407565.html, = name ; this.age = age; } public void info(){ // 得到信息 System.out.println("姓名:" + https://www.360docs.net/doc/f7407565.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/f7407565.html,() ; https://www.360docs.net/doc/f7407565.html,() ; https://www.360docs.net/doc/f7407565.html,() ; } }; 运行结果: 姓名:张三,年龄:30,城市:A城 姓名:李四,年龄:31,城市:A城 姓名:王五,年龄:32,城市:A城 以上代码,为了观察方便没有使用private关键字进行封装。以上的程序是一个简单的程序,但是代码中有些不妥之处。 实际上,如果现在假设此城市不叫A城,而改为了B城,而且此类产生了200个对象,那么就意味着要把这些对象的城市属性全部修改一边。这样显然是不行的。最好的方法是修改一次就可以,此时可以把城市属性使用static关键字进行声明,将其变为公共属性。 使用static声明属性: class Person{ // 定义Person类

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关键字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中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 中的 static 使用之静态方法

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

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

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

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

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 + "个对象");

Java关键字final

Java关键字final、static使用总结 常看很多同学在final 和static运用上感到迷茫,现总结一下final和static的运用方法,希望对大家有帮助。 一、final 根据程序上下文环境,Java关键字final有“无法改变”或者“终态”的含义,它可以修饰非抽象类、非抽象类成员方法和变量。 final类不能被继承,没有子类,final类中的方法默认是final的。 final方法不能被子类的方法覆盖,但可以被继承。 final成员变量表示常量,只能被赋值一次,赋值后值不再改变。 final不能用于修饰构造方法。 1、final类 final类不能被继承,因此final类的成员方法没有机会被覆盖,默认都是final 的。在设计类时候,如果这个类不需要有子类,类的实现细节不允许改变,并且确信这个类不会被扩展,那么就设计为final类。这种类通常我们称为完美类。 2、final方法 如果一个类不允许其子类覆盖某个方法,则可以把这个方法声明为final方法。 使用final方法的原因有二: 第一、把方法锁定,防止任何继承类修改它的意义和实现。 第二、高效。编译器在遇到调用final方法时候会转入内嵌机制,大大提高执行效率。 例如: public class Test1 { public static void main(String[] args) { } public void f1() { System.out.println(" f1 "); } } //无法被子类覆盖的方法 public final void f2() { System.out.println("f2"); } public void f3() { System.out.println("f3"); } private void f4() { System.out.println(" f4 "); } } public class Test2 extends Test1 { public void f1(){ System.out.println( " Test1父类方法f1被覆盖!" );

Java常见关键字及用法总结

Java常见关键字及用法总结 关键字目录 abstract - 1 - boolean - 2 - break - 2 - byte - 2 - case - 3 - catch - 3 - char - 4 - class - 4 - continue - 5 - default - 5 - do - 6 - double - 6 - else - 6 - extends - 6 - false - 7 - final - 7 - finally - 7 - float - 8 - for - 8 - if - 8 - implements - 9 - import - 9 - instanceof - 9 - int - 9 - interface - 10 - long - 10 - native - 10 -

new - 11 - null - 11 - package - 11 - private - 11 - protected - 12 - public - 12 - return - 13 - short - 13 - static - 13 - super - 14 - switch - 14 - synchronized - 15 - this - 16 - throw - 16 - throws - 16 - transient - 17 - try - 17 - true - 18 - void - 18 - volatile - 18 - while - 18 - 1.abstract abstract 关键字可以修改类或方法。 abstract 类可以扩展(增加子类),但不能直接实例化。 abstract 方法不在声明它的类中实现,但必须在某个子类中重写。-示例- public abstract class MyClass{ } public abstract String myMethod();

Java中DateFormat用法说明

首先说明一下关键的参数 G年代标志符 y年 M月 d日 h时在上午或下午(1~12) H时在一天中(0~23) m分 s秒 S毫秒 E星期 D一年中的第几天 F一月中第几个星期几 w一年中第几个星期 W一月中第几个星期 a上午/下午标记符 k时在一天中(1~24) K时在上午或下午(0~11) z时区 /////////////////////////////////////////////////下面是例子,以及执行结果 import java.text.*; import java.util.Date; public class FormatDateTime{ public static void main(String[]args){ ///打印出2006年11月17日15时19分56秒 SimpleDateFormat myFmt=new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒"); //打印06/11/1715:19 SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm"); //2006-11-1715:19:56 SimpleDateFormat myFmt2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//2006年11月17日15时19分56秒星期五 SimpleDateFormat myFmt3=new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒E"); //一年中的第321天一年中第46个星期一月中第3个星期在一天中15时CST时区 SimpleDateFormat myFmt4=new SimpleDateFormat( "一年中的第D天一年中第w个星期一月中第W个星期在一天中k时z时区"); Date now=new Date(); System.out.println(myFmt.format(now)); System.out.println(myFmt1.format(now)); System.out.println(myFmt2.format(now)); System.out.println(myFmt3.format(now)); System.out.println(myFmt4.format(now)); System.out.println(now.toGMTString());//17Nov200607:19:56GMT System.out.println(now.toLocaleString());//2006-11-1715:19:56 System.out.println(now.toString());//Fri Nov1715:19:56CST2006 } }

C#Static用法大汇总

C#Static用法大汇总 2010-05-06 12:11:20| 分类:c# |字号订阅 静态变量 当我们编写一个类时,其实就是在描述其对象的属性和行为,而并没有产生实质上的对象,只有通过new关键字才会产生出对象,这时系统才会分配内存空间给对象,其方法才可以供外部调用。 有时候,我们希望无论是否产生了对象或无论产生了多少对象的情况下,某些特定的数据在内存空间里只有一份,例如所有的中国人都有国家名称,每一个中国人都共享这个国家名称,不必在每一个中国人的实例对象中都单独分配一个用于代码国家名称的变量。例子:protected void Page_Load(object sender, EventArgs e) { //直接使用“类名.成员”的格式,不能使用“对象名.成员”的格式,这点与JAVA不一样,JAVA两种都可以使用 Response.Write(Chinese.Country); } class Chinese { public static string Country = "中国"; public void getCountry() { //类中的成员方法也可以直接访问静态成员变量

HttpContext.Current.Response.Write("你好!" + Country); } } 需要注意的是:不能把任何方法体内的变量声明为静态,如下面这样是不行的: public void getCountry() { //类中的成员方法也可以直接访问静态成员变量 HttpContext.Current.Response.Write("你好!" + Country); static int i = 1; } 静态方法 我们有时也希望不必创建对象就可以调用某个方法,换句话说也就是使该方法不必和对象绑定在一起。要实现这样的效果,只需要在类中定义的方法前加上static关键字就可以了,我们称这种方法为静态成员方法,还可以在类的非静态成员方法中象访问其他静态方法一样去访问这个静态方法,例子: protected void Page_Load(object sender, EventArgs e) { Chinese.getCountry(); } class Chinese { public static void getCountry()

java中static作用详解

java中static作用详解 static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,但是Java语言中没有全局变量的概念。 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说,它不依赖类特定的实例,被类的所有实例共享。 只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区 内定找到他们。因此,static对象可以在它的任何对象创建之前访问, 无需引用任何对象。 用public修饰的static成员变量和成员方法本质是全局变量和全局方法,当声明它类的对象市,不生成static变量的副本,而是类的所有实例共享同一个static变量。 static变量前可以有private修饰,表示这个变量可以在类的静态代码 块中,或者类的其他静态成员方法中使用(当然也可以在非静态成员方法中使用 --废话),但是不能在其他类中通过类名来直接引用,这一点很重要。实际上你需要搞明白,private是访问权限限定,static表示不要实例化就可以使用,这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。 static修饰的成员变量和成员方法习惯上称为静态变量和静态方法,可 以直接通过类名来访问,访问语法为: 类名.静态方法名(参数列表...) 类名.静态变量名 用static修饰的代码块表示静态代码块,当Java虚拟机(JVM)加载类时,就会执行该代码块(用处非常大,呵呵)。 1、static变量 按照是否静态的对类成员变量进行分类可分两种:一种是被static修饰的变量,叫静态变量或类变量;另一种是没有被static修饰的变量,叫实例变量。 两者的区别是: 对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也可以通过对象来访问(但是这是不推荐的)。 对于实例变量,没创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响(灵活)。

Java中static、this、super、final用途,用法及实例

本文具体讲解了Java中static、this、super、final用法,具体内容有static的静态方法、静态变量、静态类;this & super在一般方法中和在构造函数中的情况;final的成员、方法、类和它在设计模式中的应用。 AD: 一、static 请先看下面这段程序: public class Hello { public static void main(String[] args){ //(1) System.out.println("Hello,world!"); //(2) } } 看过这段程序,对于大多数学过Java 的从来说,都不陌生。即使没有学过Java,而学过其它的高级语言,例如C,那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”,一点别的用处都没有,然而,它却展示了static关键字的主要用法。 在1处,我们定义了一个静态的方法名为main,这就意味着告诉Java编译器,我这个方法不需要创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗?一般,我们都是在命令行下,打入如下的命令(加下划线为手动输入): javac Hello.java java Hello Hello,world! 这就是你运行的过程,第一行用来编译Hello.java这个文件,执行完后,如果你查看当前,会发现多了一个Hello.class文件,那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中,你可能会想,为什么要这样才能输出。好,我们来分解一下这条语句。(如果没有安装Java文档,请到Sun的官方网站浏览J2SE API)首先,System是位于https://www.360docs.net/doc/f7407565.html,ng包中的一个核心类,如果你查看它的定义,你会发现有这样一行:public static final PrintStream out;接着在进一步,点击PrintStream这个超链接,在METHOD页面,你会看到大量定义的方法,查找println,会有这样一行: public void println(String x) 好了,现在你应该明白为什么我们要那样调用了,out是System的一个静态变量,所以可以直接使用,而out所属的类有一个println方法。 静态方法 通常,在一个类中定义一个方法为static,那就是说,无需本类的对象即可调用此方法。如下所示:

java中的static

java之static使用详解 文章录入:王子责任编辑:dingkai1983 1843 【字体:小大】 一、static 请先看下面这段程序: public class Hello{ public static void main(String[] args){ //(1) System.out.println("Hello,world!"); //(2) } } 看过这段程序,对于大多数学过Java 的从来说,都不陌生。即使没有学过Java,而学过其它的高级语言,例如C,那你也应该能看懂这段代码的意思。它只是简单的输出"Hello,world",一点别的用处都没有,然而,它却展示了static关键字的主要用法。 在1处,我们定义了一个静态的方法名为main,这就意味着告诉Java编译器,我这个方法不需要创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗?一般,我们都是在命令行下,打入如下的命令(加下划线为手动输入):javac Hello.java java Hello Hello,world! 这就是你运行的过程,第一行用来编译Hello.java这个文件,执行完后,如果你查看当前,会发现多了一个Hello.class文件,那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中,你可能会想,为什么要这样才能输出。好,我们来分解一下这条语句。(如果没有安装Java文档,请到Sun的官方网站浏览J2SE API)首先,System是位于https://www.360docs.net/doc/f7407565.html,ng包中的一个核心类,如果你查看它的定义,你会发现有这样一行:public static final PrintStream out;接着在进一步,点击PrintStream这个超链接,在METHOD页面,你会看到大量定义的方法,查找println,会有这样一行:public void println(String x)。 好了,现在你应该明白为什么我们要那样调用了,out是System的一个静态变量,所以可以直接使用,而out所属的类有一个println方法。 静态方法 通常,在一个类中定义一个方法为static,那就是说,无需本类的对象即可调用此方法。如下所示: class Simple{ static void go(){ System.out.println("Go..."); } } public class Cal{ public static void main(String[] args){ Simple.go(); }

相关文档
最新文档