Java学习Static关键字用法源代码

Java学习Static关键字用法源代码
Java学习Static关键字用法源代码

1.如果不用static修饰,一个类中的对象相同的属性只能重复赋值public class Hello {

public static void main(String[] args) {

Student s1=new Student();//创建了一个实例化的对象p1,它是Person类对象的具体化

Student s2=new Student();

Student s3=new Student();

s1.schoolname="XXX大学";

s2.schoolname="XXX大学";

s3.schoolname="XXX大学";

}

}

class Student{

String schoolname;//学校名

int Num;//学号

String name;//姓名

}

2.static 关键字的用法一:修饰静态成员

一个类中相同的属性可以被定义成静态成员变量

public class Hello {

public static void main(String[] args) {

Student s1=new Student();//创建了一个实例化的对象p1,

它是Person类对象的具体化

Student s2=new Student();

Student s3=new Student();

Student.schoolname="XXX大学";

System.out.println("学生s1的学校名

"+s1

System.out.println("学生s2的学校名

"+s2

System.out.println("学生s3的学校名

"+s3

}

}

class Student{

static String schoolname;//定义的静态成员变量学校名int Num;//学号

String name;//姓名

}

3.static 关键字的用法二:修饰方法,静态方法

静态方法不用创建具体的对象就可以被调用:格式类名.静态方法名

public class Hello {

public static void main(String[] args) {

Student.schoolname="XXX大学";

Student.say();

Student.play();

System.out.println("学生的学校名

"+Student.schoolname);

}

}

class Student{

static String schoolname;//定义的静态成员变量学校名int Num;//学号

String name;//姓名

static void play() {

System.out.println("我在玩");

}

static void say() {

int name;

int Num;//局部变量

System.out.println("我的名字");

}

}

3.static 关键字的用法三:修饰代码块,静态代码块

静态代码块只执行一次,随着类第一次实例化对象的创建执行。

public class Hello {

public static void main(String[] args) {

Student.schoolname="XXX大学";

Student s1=new Student();

Student s2=new Student();

Student.say();

Student.play();

System.out.println("学生的学校名

"+Student.schoolname);

}

}

class Student{

static String schoolname;//1.定义的静态成员变量学校名int Num;//学号

String name;//姓名

//2.被static修饰的方法是静态方法

static void play() {

System.out.println("我在玩");

}

static void say() {

int name;

int Num;//局部变量

System.out.println("我的名字");

}

static {

System.out.println("静态代码块执行了");

}

}

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

java关键字

Java 关键字速查表 访问控制: private 私有的 protected 受保护的 public 公共的 类、方法和变量修饰符abstract 声明抽象 class 类 extends 扩允,继承 final 终极,不可改变的implements实现 interface 接口 native 本地 new 新,创建 static 静态 strictfp 严格,精准synchronized 线程,同步transient 短暂 volatile 易失 程序控制语句 break 跳出循环 continue 继续 return 返回 do 运行 while 循环 if 如果 else 反之 for 循环 instanceof 实例 switch 开关 case 返回开关里的结果 default 默认 错误处理 catch 处理异常 finally 有没有异常都执行 throw 抛出一个异常对象throws 声明一个异常可能被抛出try 捕获异常 包相关 import 引入 package 包

基本类型 boolean 布尔型 byte 字节型 char 字符型 double 双精度, float 浮点 int 整型 long 长整型 short 短整型 null 空 true 真 false 假 变量引用 super 父类,超类 this 本类 void 无返回值 java关键字 关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字。Java的关键字对java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名。一个Java语言中的关键字,用在类的声明中来指明一个类是不能被实例化的,但是可以被其它类继承。一个抽象类可以使用抽象方法,抽象方法不需要实现,但是需要在子类中被实现break 一个Java的关键字,用来改变程序执行流程,立刻从当前语句的下一句开始执行从。如果后面跟有一个标签,则从标签对应的地方开始执行case Java语言的关键字,用来定义一组分支选择,如果某个值和switch中给出的值一样,就会从该分支开始执行。catch :Java的一个关键字,用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。char :Java语言的一个关键字,用来定义一个字符类型 abstract boolean break byte case catch char class continue default do double else extends final finally float for if implements import instanceof int interface long native new package private protected public return short static super switch synchronized this throw throws transient try void volatile while 详细介绍

c语言关键字的用法详解优选稿

c语言关键字的用法详 解 集团文件版本号:(M928-T898-M248-WU2669-I2896-DQ586-M1988)

1.Static用法 1.1static声明的变量在C语言中有两方面的特征: 1)、变量会被放在程序的全局存储区中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2)、变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 1.2特点 A.若全局变量仅在单个C文件中访问,则可以将这个变量修改为静态全局变量,以降低模块间的耦合度; B.若全局变量仅由单个函数访问,则可以将这个变量改为该函数的静态局部变量,以降低模块间的耦合度; C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时,需要考虑重入问题; D.如果我们需要一个可重入的函数,那么,我们一定要避免函数中使用static变量(这样的函数被称为:带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时,则必须是static的局部变量的地址作为返回值,若为auto类型,则返回为错指针。 函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件(所以又称内部函

数)。使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名。 扩展分析:术语static有着不寻常的历史.起初,在C中引入关键字st atic是为了表示退出一个块后仍然存在的局部变量。随后,static在C 中有了第二种含义:用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字,所以仍使用static关键字来表示这第二种含义。最后,C++重用了这个关键字,并赋予它与前面不同的第三种含义:表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java 中此关键字的含义相同)。 1.3关键字static的作用是什么? 1.4 这个简单的问题很少有人能回答完全。在C语言中,关键字static有三个明显的作用: 1.4.1在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 int testStatic() { int x=1; x++; return x; }

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选择题

1、Java属于以下哪种语言?() A、机器语言 B、汇编语言 C、高级语言 D、以上都不对 2、在JDK安装目录下,用于存放可执行程序的文件夹是? A、bin B、jre C、lib D、db 3、下列Java命令中,哪一个可以编译HelloWorld.java文件? A、java HelloWorld B、java HelloWorld.java C、javac HelloWorld D、javac HelloWorld.java 4、以下关于java命令作用的描述中,正确的是 A、它专门负责解析由Java编译器生成的.class文件 B、它可以将编写好的Java文件编译成.class文件 C、可以把文件压缩 D、可以把数据打包 5、下面关于配置path环境变量作用的说法中,正确的是() A、在任意目录可以使用javac和java命令 B、在任意目录下可以使用class文件 C、在任意目录可以使用记事本 D、在任意目录下可以使用扫雷游戏 6、下面关于path和classpath的说法中,错误的是() A、path用来指定java 虚拟机(JVM) 所在的目录 B、classpath用来指定我们自己所写的或要用到的类文件(.jar文件) 所在的目录 C、在dos命令行中,classpath和path环境变量的查看与配置的方式不相同 D、只要设置了classpath 这个环境变量系统就不会再在当前目录下查询某个类 7、下面关于classpath的说法中,错误的是()。 A、classpath和path环境变量的查看与配置的方式完全相同。 B、为了让Java虚拟机能找到所需的class文件,就需要对classpath环境变量进行设置。 C、从JDK5.0开始,如果classpath环境变量没有进行设置,Java虚拟机会自动将其设置为“.”,也就是当前目录。 D、在命令行窗口中配置了classpath后,重新打开新命令行窗口依然生效 8、下面哪种类型的文件可以在Java虚拟机中运行?() A、.java B、.jre C、.exe D、.class 9、阅读下段代码片段,选择正确的运行结果 public static void main(String[] args) {

super关键字用法

使用super来引用父类的成分,用this来引用当前对象一、super关键字 在JAVA类中使用super来引用父类的成分,用this来引用当前对象,如果一个类从另 外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢?使用super来引用,this指的是当前对象的引用,super是当前对象里面的父对象的引用。 1.1.super关键字测试 1package cn.galc.test; 2 3/** 4 * 父类 5 * @author gacl 6 * 7*/ 8class FatherClass { 9public int value; 10public void f() { 11 value=100; 12 System.out.println("父类的value属性值="+value); 13 } 14 } 15 16/** 17 * 子类ChildClass从父类FatherClass继承 18 * @author gacl 19 * 20*/ 21class ChildClass extends FatherClass { 22/**

23 * 子类除了继承父类所具有的valu属性外,自己又另外声明了一个value属性, 24 * 也就是说,此时的子类拥有两个value属性。 25*/ 26public int value; 27/** 28 * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现,即重写了f()方法的方法体。 29*/ 30public void f() { 31super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法 32 value=200;//这个value是子类自己定义的那个valu,不是从父类继承下来的那个value 33 System.out.println("子类的value属性值="+value); 34 System.out.println(value);//打印出来的是子类自定义的那个value的值,这个值是200 35/** 36 * 打印出来的是父类里面的value值,由于子类在重写从父类继承下来的f()方法时, 37 * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法, 38 * 即相当于是这个父类对象自己调用f()方法去改变自己的value 属性的值,由0变了100。 39 * 所以这里打印出来的value值是100。 40*/ 41 System.out.println(super.value); 42 } 43 } 44 45/** 46 * 测试类 47 * @author gacl 48 * 49*/ 50public class TestInherit { 51public static void main(String[] args) { 52 ChildClass cc = new ChildClass();

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中的关键字总结 final 关键字 1、用final修饰的类不能被继承,没有子类; 2、用final修饰的方法,方法不能被重写; 3、用final修饰变量,变量的值不能被修改,表示常量,(书写规范:全部字母都要大写;多个单词,可以使用下划线(_)分开;) 注意:如果被final修饰的变量是一个引用类型的数据,那么通过这个引用改变堆空间中的数据,不会报错;如果被final修饰的变量是一个引用类型的数据,那么通过这个引用改变堆空间中的数据,不会报错; 4、final用于成员变量表示该成员变量为常量,不能被修改,必须在变量定义时赋值。 5、final用于局部变量表示该局部变量为常量,不能被修改,可以在变量定义时赋值,也可以先定义变量后赋值。 什么时候用final关键字? 有的时候不想别人重写我的方法就使用final关键字修饰该方法; static关键字 1、static用于成员变量表示该变量只有一份,也就是说静态成员变量属于类而不属于某个具体的类实例对象,所有的类实例对象共享这个静态成员变量;静态函数是不需要对象的,直接可以使用类名来调用; 2、非静态函数可以调用静态函数;静态函数不能调用非静态函数(非静态函数都是通过对象调用的);静态函数不能使用非静态成员变量,但可以使用静态成员变量; 3、静态函数调用时不需要对象的,所以不能使用和对象有关的关键字;(this;super;) 4、构造函数不能使用static修饰(构造函数是创建对象,开辟空间,给所有成员变量赋默认值之后,有JVM调用进栈,用来给对象的成员变量赋初始值的) static用于类,这里指的是内部类,那么在别的地方就可以通过外部类名来引用这个静态的内部类。 5、static还可以用于类的代码块,叫做静态代码块,静态代码块在类加载的时候就执行完毕,而类只加载一次;是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内,JVM加载类时会执行这些静态的代码块,如果static代码块有多个,JVM将按照它们在类中出现的先

c++static关键字

C/C++中的static关键字 C/C++中的static有两种用法: 面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类的问题。 A. 面向过程程序设计中的stati c关键字 1) 静态全局变量 在全局变量前,加上关键字static,该变量就被定义成为一个静态全局变量。静态全局变量定义和使用类似:#include using namespace std; void fn(); static int n; //定义静态全局变量 void main() { n=20; cout< using namespace std; void fn(); void main()

{ fn(); fn(); fn(); } void fn() { static n=10; // 定义了静态局部变量,仅初始化一次! cout << n < using namespace std; static void fn(); //声明静态函数 void main() { fn(); } void fn() //定义静态函数 { int n=10;

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常用词汇

Abstract class 抽象类:抽象类是不允许实例化的类,因此一般它需要被进行扩展继承。 Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。 Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。 Anonymous class 匿名类:当你需要创建和使用一个类,而又不需要给出它的名字或者再次使用的使用,就可以利用匿名类。 Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。 API 应用程序接口:提供特定功能的一组相关的类和方法的集合。 Array 数组:存储一个或者多个相同数据类型的数据结构,使用下标来访问。在Java中作为对象处理。 Automatic variables 自动变量:也称为方法局部变量method local variables,即声明在方法体中的变量。 Base class 基类:即被扩展继承的类。HP0-538 Blocked state 阻塞状态:当一个线程等待资源的时候即处于阻塞状态。阻塞状态不使用处理器资源 Call stack 调用堆栈:调用堆栈是一个方法列表,按调用顺序保存所有在运行期被调用的方法。 Casting 类型转换 :即一个类型到另一个类型的转换,可以是基本数据类型的转换,也可以是对象类型的转换。 char 字符:容纳单字符的一种基本数据类型。 Child class 子类:见继承类Derived class Class 类:面向对象中的最基本、最重要的定义类型。350-018 Class members 类成员:定义在类一级的变量,包括实例变量和静态变量。 Class methods 类方法:类方法通常是指的静态方法,即不需要实例化类就可以直接访问使用的方法。 Class variable 类变量:见静态变量Static variable

c语言关键字的用法详解

1. Static用法 1.1 static声明的变量在C语言中有两方面的特征: 1)、变量会被放在程序的全局存储区中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2)、变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 1.2 特点 A.若全局变量仅在单个C文件中访问,则可以将这个变量修改为静态全局变量,以降低模块间的耦合度; B.若全局变量仅由单个函数访问,则可以将这个变量改为该函数的静态局部变量,以降低模块间的耦合度; C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时,需要考虑重入问题; D.如果我们需要一个可重入的函数,那么,我们一定要避免函数中使用static变量(这样的函数被称为:带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时,则必须是static 的局部变量的地址作为返回值,若为auto类型,则返回为错指针。 函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名。 扩展分析:术语static有着不寻常的历史.起初,在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后,static在C中有了第二种含义:用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字,所以仍使用static关键字来表示这第二种含义。最后,C++重用了这个关键字,并赋予它与前面不同的第三种含义:表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。 1.3 关键字static的作用是什么? 这个简单的问题很少有人能回答完全。在C语言中,关键字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。

java笔记(super关键字的使用)

super 关键字的使用 super 关键字出现在子类中,主要功能就是完成子类调用父类中的内容,也就是调用父类中的属性或方法。 super 调用父类中的构造方法: class Person { String name; int age; public Person(String name,int age) { https://www.360docs.net/doc/ab16090351.html,=name; this.age=age; } } class Student extends Person { String school; public Student() { super("张三",27); } } public class TestPersonStudentDemo { public static void main(String args[]) { Student s=new Student(); S.shchool=”北京”; System.out.println("我是:"+https://www.360docs.net/doc/ab16090351.html,+",今年:"+s.age+"岁,学校:"+s.school) ; } } 输出结果为:我是张三,今年27岁,学校:北京 本程序在子类的构造方法中明确地指明了调用的是父类中有两个参数的构造方法,所以程序在编译时不再去找父类中无参的构造方法。 用super 调用父类中的构造方法,只能放在子类的第一行。 通过super 调用父类的属性和方法: class Person 父类构造方法 子类构造方法 调用父类构造方法

{ String name; int age; public Person() { } public String talk() { return "我是:"+https://www.360docs.net/doc/ab16090351.html,+",今年:"+this.age+"岁"; } } class Student extends Person { String school; public Student(String name,int age,String school) { //在这里用super 调用父类中的属性 https://www.360docs.net/doc/ab16090351.html,=name; super.age=age; //调用父类中的talk()方法 System.out.print(super.talk()); //调用本类中属性 this.school=school; } } public class TestPersonStudentDemo3 { public static void main(String args[]) { Student s=new Student("张三",27,"北京"); System.out.println(",学校:"+s.school); } } 输出结果为: 我是:张三,今年:27岁,学校:北京 限制子类的访问 有些时候,父类并不希望子类可以访问自己的类中全部的属性或方法,所以需要将一些属性父类构造方法 子类构造方法 父类一般方法

C语言关键字static

C语言关键字-static 用法1:在一个函数体内使用static定义一个变量,保证该变量只进行一次初始化 例:#include "stdio.h" int test(void) { static int i=0; //对应 int i=0 结果为i=1 i=1 i=1 i=1 i=1 i++; return i; } int main( ) { for(int j=0;j<5;j++) printf("test=%d\n",test()); return 0; } 输出结果:i=1 i=2 i=3 i=4 i=5 用法2:在模块内,函数体外声明的static变量,只能 被模块内函数调用,而模块是无效的(其中模块即:一个.c文件和一个.h文件的结合,其中在STM32单片机

C设计中经常使用)。同样的一个在模块内被声明为static的函数也只能在模块内被其它函数调用,而模块外是无权调用的。一句话总结就是保护一些不能被其它文件访问的全局变量和函数;防止了不同人定义的文件变量名和函数名的重复引起的错误 例://file1.cpp int VarA=0; static int VarB=0; extern void FunB(void) //其中函数前面加extern表示定义为外部函数,其实可以省略,因为C语言默认省略为外部可 //调用 { ; } static int FunA (void) //加了static为静态函数,只能在本模块使用 { int i=0; i++; return i; } //file2.cpp

extern int VarA; //可以 extern int VarB;//错误,为静态变量 extern int FunB;//可以 extern int FunA;//错误,为静态函数 总结:众所周知局部变量在存储方式上可以分为auto (默认的,可省略) static register这3种其中auto 是分配在栈上,占用动态存储空间,在函数调用结束后自动释放;static 分配在静态存储空间,两者的作用域相同,但是生存周期不同,static在所处模块初期初始化一次,其后不再进行初始化,同时如果没有初始化则默认是0或者空字符,但是auto的无初始化的值是随机的数;其中针对C++系统不管是否有static修饰都会调用默认构造函数进行初始化。

相关文档
最新文档