java中的修饰符static ,final,abstract

合集下载

修饰符的作用范围

修饰符的作用范围

修饰符的作用范围
修饰符是编程语言中常见的概念,它可以用来限制变量、函数、类等的作用范围。

在编程中,修饰符有着重要的作用,可以帮助程序员更好地管理和控制代码,从而提高程序的可靠性和安全性。

修饰符的作用范围主要分为三个方面:访问控制、继承和多态。

其中,访问控制指的是控制外部代码对成员变量和成员函数的访问权限;继承指的是子类继承父类的属性和方法,从而扩展或修改父类的功能;多态指的是同一方法在不同对象或类中的表现形式不同。

在Java编程中,常用的修饰符包括 public、private、protected、static、final、abstract、synchronized等。

其中,public修饰的成员变量和成员函数可以被任何代码访问,private修饰的成员变量和成员函数只能在本类中被访问,protected修饰的成员变量和成员函数可以在本类和子类中被访问。

在继承中,子类可以通过使用关键字“extends”继承父类的属
性和方法。

此时,父类的修饰符对子类的作用范围也会产生影响。

如果父类的成员变量和成员函数被private修饰,那么子类将无法访问这些成员。

如果父类的成员变量和成员函数被protected修饰,那么子类可以访问这些成员。

在多态中,同一个方法可以被不同的对象或类调用,而表现形式也可能不同。

例如,在面向对象编程中,一个动物类中的eat()方法可以被不同的子类继承并重写,从而表现出不同的吃的方式。

总之,修饰符在编程中扮演着重要的角色,它可以帮助程序员更
好地管理和控制代码,从而提高程序的可靠性和安全性。

程序员应该根据实际需求选择合适的修饰符,并学会灵活运用。

java接口默认修饰符

java接口默认修饰符

java接⼝默认修饰符概论: java接⼝可以是public 的,也可以是friendly的,但⼀定是abstracted的。

java接⼝⾥的⽅法只能是public的、abstract的。

java接⼝⾥的成员变量只能是public 的,static 的,final的;并且必须赋初值,否则通不过编译。

C++⽀持多重继承,如果两个⽗类有相同的成员变量,处理起来⽐较困难。

java 接⼝的成员变量之所以这样设计,就是为了解决C++ 中的这个问题。

成员变量必须是static 的,所以接⼝⾥的成员变量就不再属于某个对象,⽽是属于这个接⼝的。

⼦类的对象⾥就没有⽗类的这个成员变量。

那怎样使⽤⽗类⾥的成员变量呢?public interface Father {int i = 0;}public interface Father2 {int i = 2;}public class Son implements Father, Father2 {static int i = 3;public static void main(String[] args) {System.out.println(Father.i);System.out.println(Father2.i);System.out.println(i);}}接⼝问题: 实现两个接⼝,这两个接⼝⾥有两个签名相同,返回值不同的⽅法。

⼀个类同时实现,报错。

package test;public interface InterfaceTest { void todo();}/*** 以下是反编译的内容,接⼝默认是abstract的,* 接⼝⾥的⽅法默认都是public的、abstract的。

*package test;public abstract interface InterfaceTest { public abstract void todo();}*/上⾯⽤得是第三⽅的⼀个反编译⼯具,⽤ Eclipse 反编译插件编译后的结果却不同,如下:package test;public interface InterfaceTest { void todo();}接下来⼀探究竟:1.创建⼀个java 接⼝:public interface TestInterface {void say();}2.为这个接⼝添加⼀个abstract 修饰符public abstract interface TestInterface {void say();}结果⼀切正常,它的实现类运⾏毫不影响。

java 访问控制修饰符

java  访问控制修饰符

java 访问控制修饰符面向对象的基本思想之一是封闭实现细节并且公开接口。

Java语言采用访问控制修饰符来控制类及类的方法和变量的访问权限,从而只向使用者暴露接口,但隐藏实现细节。

访问控制分4种级别。

表6-7总结了这4种访问级别所决定的可访问范围。

●公开级别:用public修饰,对外公开。

●受保护级别:用protected修饰,向子类及同一个包中的类公开。

●默认级别:没有访问控制修饰符,向同一个包中的类公开。

●私有级别:用private修饰,只有类本身可以访问,不对外公开。

表6-7 4种访问级别的可访问范围护、默认和私有。

顶层类只可以处于公开或默认访问级别,因此顶层类不能用private表6-8列出了类、成员方法、构造方法、成员变量和局部变量可用的各种修饰符。

其中“√”表示可以修饰。

表中的类仅限于顶层类(Top Level Class),而不包括内部类。

内部类是指定义在类或方法中的类,下面会对此做详细介绍。

从上表中可以看出,修饰顶层类的修饰符包括abstract 、public 和final ,而static 、protected 和private 不能修饰顶层类。

成员方法和成员变量可以有多种修饰符,而局部变量只能用final 修饰。

如图6-19所示,ClassA 和ClassB 位于同一个包中,ClassC 和ClassD 位于另一个包中,并且ClassC 是ClassA 的子类。

ClassA 是public 类型,在ClassA 中定义了4个成员变量:a 、b 、c 和d ,它们分别处4个访问级别。

图6-19 访问指示在ClassC中,可以访问ClassA的a和b变量。

ClassB是默认访问级别,位于pack1包中,只能被同一修饰符中的ClassA访问,。

Java程序设计补充习题(2面向对象部分)

Java程序设计补充习题(2面向对象部分)

第二部分面向对象程序设计注意:选择题为不定项选择1、以下哪些是Java的修饰符()A. staticB. finalC. protectedD. const2、面向对象技术的特性是()A、继承性B、有效性C、多态性D、封装性3、下列哪个命题为真?()A、所有类都必须定义一个构造函数。

B、构造函数必须有返回值。

C、构造函数可以访问类的非静态成员。

D、构造函数必须初始化类的所有数据成员。

4、关于子类与父类关系的描述正确的是()A、子类型的数据可以隐式转换为其父类型的数据;B、父类型的数据可以隐式转换为其子类型的数据;C、父类型的数据必须通过显式类型转换为其子类型的数据;D、子类型实例也是父类型的实例对象。

5、读程序,以下可以在main()方法中添加的语句是哪些?()class Test{private float f=1.0f;int m=12;static int n=1;public static void main(String args[]){Test t=new Test();//...}}A. t.fB. this.nC. Test.mD. Test.n6、下面哪个关键字不是用来控制对类成员的访问的?()A、publicB、protectedC、defaultD、private7、Java语言正确的常量修饰符应该是()A、finalB、static finalC、staticD、public static final8、接口的所有成员域都具有、static和属性。

9、接口的所有成员方法都具有和属性。

10、编译下列源程序会得到哪些文件?()class A1{}class A2{}public class B{public static void main(String args[]){}}A. 只有B.classB. 只有A1.class和A2.class文件C. 有A1.class、A2.class和B.class文件D. 编译不成功11、下列哪种说法是正确的?()A、私有方法不能被子类重写。

Java中final、finally、finalize的简单区别,中等区别,详细区别(Lawliet 修改+注释版)

Java中final、finally、finalize的简单区别,中等区别,详细区别(Lawliet 修改+注释版)

简单区别:
中等区别:
虽然这三个单词在Java中都存在,但是并没有太多关联:
final:java中的关键字,修饰符。

1.如果一个类被声明为final,就意味着它不能再派生出新的子类,不能作为父类被继承。

因此,一个类不能同时被声明为absrtact抽象类的和final的类。

2.如果将变量或者方法声明为final,可以保证它们在使用中不被改变.
2.1 被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取,不可修改。

2.2被声明final的方法只能使用,不能重载。

finally:java的一种异常处理机制。

finally是对Java 异常处理模型的最佳补充。

finally 结构使代码总会执行,而不管有无异常发生。

使用finally 可以维护对象的内部状态,并可以清理非内存资源。

特别是在关闭数据库连接这方面,如果程序员把数据库连接的close()方法放到finally中,就会大大降低程序出错的几率。

finalize:Java中的一个方法名。

Java技术使用finalize()方法在垃圾收集器将对象从内存中清除出去前,做必要的清理工作。

这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。

它是在Object类中定义的,因此所有的类都继承了它。

子类覆盖finalize()方法以整理系统资源或者执行其他清理工作。

finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。

Java中的关键字有哪些?

Java中的关键字有哪些?

Java中的关键字有哪些?1)48个关键字:abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

1.访问修饰符的关键字(3个)public(公有的):可跨包protected (受保护的):当前包内可⽤private (私有的):当前类可⽤2.定义类、接⼝、抽象类和实现接⼝、继承类的关键字、实例化对象(6个)class (类):public class A(){}花括号⾥是已实现的⽅法体,类名需要与⽂件名相同interface (接⼝):public interface B(){}花括号⾥有⽅法体,但没有实现,⽅法体句⼦后⾯是英⽂分号“;”结尾 abstract (声明抽象):public abstract class C(){}介于类与接⼝中间,可以有,也可以没有已经实现的⽅法体implements (实现):⽤于类或接⼝,实现接⼝public class A interface B(){} extends (继承):⽤于类继承类public class A extends D(){}new (创建新对象):A a=new A();A表⽰⼀个类3.包的关键字(2个)import (引⼊包的关键字):当使⽤某个包的⼀些类时,仅需要类名,即可⾃动插⼊类所在的包package (定义包的关键字):将所有相关的类放在⼀个包类以便查找修改等4.数据类型的关键字(9个)byte (字节型):8bitchar (字节型):16bitboolean (布尔型):--short (短整型):16bitint (整型):32bitfloat (浮点型):32bitlong (长整型):64bitdouble (双精度):64bitvoid (⽆返回):public void A(){}其他需要反回的经常与return连⽤5.条件循环(流程控制)(12个)if (如果) :if(条件语句{执⾏代码}如果条件语句成⽴,就开始执⾏{}⾥⾯的内容else (否则,或者) :常与if连⽤,⽤法相同:if(...){...}else{...}while (当什么时候):while(条件语句){执⾏代码}for(满⾜三个条件时):for(初始化循环变量;判断条件;循环变量值{}switch (选择结构):switch(表达式){case常量表达式1:语句1;...case常量表达式2;语句2;default:语句;}default就是如果没有匹配的case就执⾏它,default并不是必须的。

Java访问权限控制

Java访问权限控制

Java访问权限控制Java访问权限控制修饰符⽤来定义类、⽅法或者变量,通常放在语句的最前端。

Java语⾔提供了很多修饰符,主要分为以下两类:访问修饰符⾮访问修饰符其中⾮访问修饰符主要有:static、final、abstract、synchronized和volatile,⾮访问修饰符根据各⾃的特性来保证特定功能的实现。

Java中使⽤访问控制符来保护对类、变量、⽅法和构造⽅法的访问,访问控制修饰符对应的权限控制的⼤⼩情况为:public > protected > default(包访问权限) > private。

1. 编译单元和包编译单元:即为最⼩的可以被编译且执⾏的Java⽂件。

⼀个.java⽂件就是⼀个编译单元,⼀个编译单元必须只包含有⼀个public类,可以包含有其他⾮public的类,并且⽤publi类标⽰的类名必须和⽂件名相同。

如果.java⽂件中不包含有publi类,则这个类也是没有意义的,因为不能被外界所访问。

.java⽂件中包含有⼏个类,编译后就会⽣成⼏个.class⽂件。

包含有⼀组类,是以⼀个名字空间集合在⼀起的类⽽已。

2. 访问控制修饰符public : 对所有类可见使⽤对象:类、接⼝、变量、⽅法protected : 对同⼀包内的类和所有⼦类可见使⽤对象:变量、⽅法。

注意:不能修饰类(外部类)default (即缺省,什么也不写): 在同⼀包内可见,不使⽤任何修饰符使⽤对象:类、接⼝、变量、⽅法。

private : 在本类中可见使⽤对象:变量、⽅法。

注意:不能修饰类(外部类)private和protected修饰符不能⽤以修饰类/接⼝2.1 公有访问修饰符-public被声明为 public 的类、⽅法、构造⽅法和接⼝能够被任何其他类访问。

如果⼏个相互访问的 public 类分布在不同的包中,则需要导⼊相应 public 类所在的包。

由于类的继承性,类所有的公有⽅法和变量都能被其⼦类继承。

JAVA语言客观作业及判断题

JAVA语言客观作业及判断题

Java对事件的处理是采用委托方式进行的,即将需要进行事件处理的组件委托给指定的事件处理器进行处理。

答案:正确Java程序是由若干类定义组成的,类定义包括定义类头和定义类体。

答案:正确类的修饰符有静态修饰符static、最终修饰符final、易失修饰符volatile和过度修饰符transient。

答案:错误子类拥有的成员数目大于等于父类拥有的成员数目。

答案:错误Container类的add()方法将GUI组件添加到容器中。

答案:正确Frame,Panel,Apple,Button 4种组件都属于容器组件。

答案:错误在Java中对象可以赋值,只要使用赋值号(等号)即可,相当于生成了一个各属性与赋值对象相同的新对象。

答案:错误在Java的方法中定义一个常量要用const关键字。

答案:错误一个程序里有且只能有一个公共类,它就是主类。

答案:正确最终类不能派生子类。

最终方法不能被覆盖。

答案:正确在Applet中可以调用它的drawImage()方法直接画出一幅图像。

答案:错误一个复选按钮实现的是“二选一”的结构;一个单选按钮实现的是“多选一”的结构。

答案:正确当一个方法在运行过程中产生一个异常,则这个方法会终止,但是整个程序不一定终止运行。

答案:正确当一个方法在运行过程中产生一个异常,则这个方法会终止,但是整个程序不一定终止运行。

答案:正确Final类中的属性和方法都必须被final修饰符修饰。

答案:错误接口是特殊的类,所以接口也可以继承,子接口将继承父接口的所有常量和抽象方法。

答案:正确新创建的Frame视窗对象,会自动显示在屏幕上。

答案:错误Applet可以运行在浏览器中。

答案:正确Java源程序文件应以.java为后缀名保存,文件内包含几个类的定义就编译生成几个对应的字节码文件。

答案:正确类头定义主要说明类的名字、父类名和接口名。

答案:错误为了提高效率,Java中对多次出现的用双引号括起来的字符串字面量只存储一个对象。

java中 static,final,transient,volatile,Volatile关键字的作用

java中 static,final,transient,volatile,Volatile关键字的作用
但是在以下两种场景,不应该使用这种优化方式:
缓存行非64字节宽的处理器(自行调整补充字节长度,原理一样)
共享变量不会被频繁的写。追加字节会导致CPU读取性能下降,如果共享变量写的频率很低,那么被锁的几率也很小,就没必要避免相互锁定了
Volatile无法保证原子性
volatile是一种“轻量级的锁”,它能保证锁的可见性,但不能保证锁的原子性。
由于自增操作是不具备原子性的,它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行,就有可能导致下面这种情况出现:
假如某个时刻变量inc的值为10,线程1对变量进行自增操作,线程1先读取了变量inc的原始值,然后线程1被阻塞了;然后线程2对变量进行自增操作,线程2也去读取变量inc的原始值,由于线程1只是对变量inc进行读取操作,而没有对变量进行修改操作,所以不会导致线程2的工作内存中缓存变量inc的缓存行无效,所以线程2会直接去主存读取inc的值,发现inc的值时10,然后进行加1操作,并把11写入工作内存,最后写入主存。
如下面的例子
public class Test {
public volatile int inc = 0;
public void increase() {
inc++;
}
public static void main(String[] args) {
追加字节优化Volatile性能
在某些情况下,通过将共享变量追加到64字节可以优化其使用性能。
在JDK 7 的并发包里,有一个队列集合类LinkedTransferQueue,它在使用volatile变量时,用一种追加字节的方式来优化队列出队和入队的性能。队里定义了两个共享结点,头结点和尾结点,都由使用了volatile的内部类定义,通过将两个共享结点的字节数增加到64字节来优化效率,具体分析如下:

Java修饰符有哪些-修饰符介绍-作用范围

Java修饰符有哪些-修饰符介绍-作用范围

Java修饰符有哪些-修饰符介绍-作用范围Java修饰符分为访问控制修饰符和非访问控制修饰符:访问控制修饰符用于限制类、属性或方法程序中的访问和调用权限,包括public、private、protected等;非访问控制修饰符包括static、final、abstract、native等。

一、介绍1、public修饰符public修饰符意味着公有,可以修改类、属性和方法。

如果一个变量或方法被使用了public修饰符,则可以被包内其他类、对象以及包外的类、对象和方法使用。

2、private修饰符private修饰符只能修改成员变量和成员方法。

如果用private 修饰符声明的变量和方法则只能其所在的类本身使用,其他的类或对象不能访问它们。

封装就是利用了这一特性,使属性成为私有。

3、protected修饰符protected修饰符意味着受保护,只能用于修改成员变量和成员方法,不能用于修改类。

对受保护的变量和方法的访问被限制在类本身、包内的所有类,以及从它所在的类派生出来的子类(无论是在同一个包内还是在不同的包内)。

4. 默认(friendly)修饰符如果一个类、方法或变量名称前面没有任何访问控制符,那么该成员就有默认的访问控制符。

默认访问控制成员可以被它所在的包中的其他类访问,所以它被称为包访问特性。

friendly不是一个Java关键字。

二、作用范围private void priMethod(),访问权限为私有权限,只能在VisitP中使用;protected void proMethod(),访问权限为受保护,能被类本身和定义它的类的子类访问;public void pubMethod(),访问权限为公有,可以被任何类使用;void friMethod(),访问权限为默认(友好),可以被与定义它的类在同一包中的所有类使用。

JAVA复习题(继承)

JAVA复习题(继承)

JAVA复习题(继承)一、选择题1、Java语言的类间的继承关系是(B)。

A)多重的B)单重的C)线程的D)不能继承2、以下关于Java语言继承的说法正确的是(C)。

A)Java中的类可以有多个直接父类B)抽象类不能有子类C)Java中的接口支持多继承D)最终类可以作为其它类的父类3、现有两个类A、B,以下描述中表示B继承自A的是(D)。

A)classAextendsBB)classBimplementsAC)classAimplementsBD)c lassBextendsA4、下列选项中,用于定义接口的关键字是(A)。

A)interfaceB)implementsC)abstractD)class5、下列选项中,用于实现接口的关键字是(B)。

A)interfaceB)implementsC)abstractD)class6、Java语言的类间的继承的关键字是(B)。

A)implementsB)extendsC)classD)public7、以下关于Java语言继承的说法错误的是(A)。

A)Java中的类可以有多个直接父类B)抽象类可以有子类C)Java中的接口支持多继承D)最终类不可以作为其它类的父类8、现有两个类M、N,以下描述中表示N继承自M的是(D)。

A)classMextendsNB)classNimplementsMC)classMimplementsND)c lassNextendsM9、现有类A和接口B,以下描述中表示类A实现接口B的语句是(A)。

A)classAimplementsBB)classBimplementsAC)class AextendsBD)classBextendsA10、下列选项中,定义抽象类的关键字是(C)。

A)interfaceB)implementsC)abstractD)class11、下列选项中,定义最终类的关键字是(D)。

A)interfaceB)implementsC)abstractD)final12、下列选项中,哪个是java语言所有类的父类(C)A)StringB)VectorC)ObjectD)KeyEvent13、java语言中,用于判断某个对象是否是某个类的实例的运算符是(A)A)instanceofB)+C)isinstanceD)&&14、下列选项中,表示数据或方法可以被同一包中的任何类或它的子类访问,即使子类在不同的包中也可以的修饰符是(B)A)publicB)protectedC)privateD)final15、下列选项中,表示数据或方法只能被本类访问的修饰符是(C)A)publicB)protectedC)privateD)final16、下列选项中,接口中方法的默认可见性修饰符是(A)A)publicB)protectedC)privateD)final17、下列选项中,表示终极方法的修饰符是:(B)A)interfaceB)finalC)abstractD)implements18、下列选项中,定义接口MyInterface的语句正确的是:(A)A)interfaceMyInterface{}B)implementsMyInterface{}C)classMyI nterface{}D)implementsinterfaceMy{}19、如果子类中的方法mymethod()覆盖了父类中的方法mymethod(),假设父类方法头部定义如下:voidmymethod(inta),则子类方法的定义不合法的是:(C)A)publicvoidmymethod(inta)B)protectedvoidmymethod(inta)C)pr ivatevoidmymethod(inta)D)voidmymethod(inta)二、填空题1、如果子类中的某个变量的变量名与它的父类中的某个变量完全一样,则称子类中的这个变量________了父类的同名变量。

java试题

java试题

1.下面关于枚举的描述正确的一项是?A. 枚举中定义的每一个枚举项其类型都是String;B. 在Java中可以直接继承java.util.Enum类实现枚举类的定义;C. 利用枚举类中的values()方法可以取得全部的枚举项;D. 枚举中定义的构造方法只能够使用private权限声明;答案:C2.String和Object类在那个包中定义的?A. ngB. java.utilC. D. java.sql答案:A3.定义类时不可能用到的关键字是?A. finalB. publicC. protectedD. static解析:可以修饰类的修饰符有public,static,final和abstract。

所以答案:C4.下列关于包、类和源文件的描述中,不正确的一项是?A. 一个包可以包含多个类B. 一个源文件中,只能有一个public classC. 属于同一个包的类在默认情况不可以互相访问,必须使用import导入D. 系统不会为源文件创建默认的包答案:C5.下面对于多态性的描述,错误的一项是?A. 面向对象多态性描述的就是对象转型的操作B. 对象可以自动实现向上转型;C. 对象的向下转型需要强制转型D. 可以利用instanceof方法判断某一个对象是否属于某个类的实例答案:A6.现在有如下一段程序:class Happy {public static void main(String args[]) {float [][] f1 = {{1.2f,2.3f},{4.5f,5.6f}} ;Object oo = f1 ;f1[1] = oo ;System.out.println("Best Wishes "+f1[1]);}}运行该程序会出现什么结果?A. {4.5,5.6}B. 4.5C. compilation error in line NO.5D. exception答案:C7.下列说法正确的一项是?A. ng.Integer是接口B. String定义在java.util包中C. Double类在ng包中D. Double类在ng.Object包中答案:C8.下面代码存在什么问题?public class MyClass {public static void main(String arguments[]) { amethod(arguments);}public void amethod(String[] arguments){ System.out.println(arguments);System.out.println(arguments[1]);}}A. 错误,void amethod()不是static类型B. 错误,main()方法不正确C. 错误,数组必须导入参数D. 方法amethod()必须用String类型描述答案:A9.一个异常将终止?A. 整个程序B. 只终止抛出异常的方法C. 产生异常的try块D. 上面的说法都不对答案:C10.下面哪种权限是同一包可以访问,不同包的子类可以访问,不同包的非子类不可以访问?A. privateB. defaultC. protectedD. public答案:C11.下面关于try块的描述正确的一项是?A. try块后至少应有一个catch块B. try块后必须有finally块C. 可能抛出异常的方法应放在try块中D. 对抛出的异常的处理应放在try块中答案:C12.如要在字符串s(内容为“welcome to mldn !! ”),中,发现字符't'的位置,应该使用下面哪种方法?A. mid(2,s);B. charAt(2);C. s.indexOf('t');D. indexOf(s,'v');答案:C13.编译和运行下面代码可能会发生什么?class Base {private void amethod(int iBase) {System.out.println("Base.amethod");}}class Over extends Base {public static void main(String args[]) {Over o = new Over();int iBase = 0 ;o.amethod(iBase) ;}public void amethod(int iOver) {System.out.println("Over.amethod");}}A. Compile time error complaining that Base.amethod is privateB. Runntime error complaining that Base.amethod is privateC. Output of Base amethodD. Output of Over.amethod答案:D.在一个类文件中,导入包、类和打包是怎样的排列顺序?A. package、import、classB. class、import、packageC. import、package、classD. package、class、import答案:A15.下面关于泛型的描述中错误的一项是?A. “? extends 类”表示设置泛型上限B. “? super 类”表示设置泛型下限C. 利用“?”通配符可以接收全部的泛型类型实例,但却不可修改泛型属性内容D. 如果类在定义时使用了泛型,则在实例化类对象时需要设置相应的泛型类型,否则程序将无法编译通过答案:D16.所有程序可处理异常的共同父类是?A. ErrorB. ExceptionC. ThrowableD. RuntimeException答案:B17.finally块中的代码什么时候被执行?A. 总是被执行B. 如果try块后面没有catch块时,finally块中的代码才会执行C. 异常发生时才被执行D. 异常没有发生时才执行答案:A8.关于Java8中提供的四个核心函数式接口的描述,正确的一项是?A. Predicate接口中的方法不能够返回数据,只能够接收并操作数据B. Consumer接口中的方法可以对数据进行判断,并且可以返回判断结果C. Function接口中的方法可以接收参数,并且将数据处理后返回D. Supplier接口中的方法可以接收基本数据类型参数,但是没有返回值解析:Consumer<T>接受一个输入参数并且无返回值。

staticprivate与final的用法总结

staticprivate与final的用法总结

staticprivate与final的⽤法总结1.static表⽰静态。

他是属于类的。

可以在本⾝类⾥直接调⽤,或在其它类⾥⽤类名.⽅法名调⽤。

不加static表⽰是实例的⽅法,必须⽤实例来调⽤。

在本类⾥也⼀样,必须⽤实例调⽤2.private是私有的意思. private class Demo{ Demo类就是私有的了. 类是不能⽤private修饰的, 当类被修饰成private没有任何意思. 因为外部任何对象都访问不到Demo类了. private String str; str属性就私有的了外部类就访问不到这个属性了 private void hello(){ 外部类就访问不到hello()⽅法了 } } ⽤private关键字:使得你的程序更安全变量⼀般都是⽤private申明然后再本类通过 set get ⽅法控制该属性3.final—修饰符(关键字)如果⼀个类被声明为final,意味着它不能再派⽣出新的⼦类,不能作为⽗类被继承。

因此⼀个类不能既被声明为abstract的,⼜被声明为final的。

将变量或⽅法声明为final,可以保证它们在使⽤中不被改变。

被声明为final的变量必须在声明时给定初值,⽽在以后的引⽤中只能读取,不可修改。

被声明为final的⽅法也同样只能使⽤,不能重载。

static:静态修饰符 private:私有的,定义私有属性或⽅法,不能被其他类调⽤ final:不可变的。

我们在系统中经常定义某个常量(对象的值不可变)如下: private static final String VAR = "This is a unable changed Variable"; 该变量只能在当前这个类中被使⽤,并且是带有static修饰的静态函数中被调⽤。

加了final则该属性的值将不能被改变。

abstract:声明⽅法的存在⽽不去实现它的类被叫做抽象类(abstract class),它⽤于要创建⼀个体现某些基本⾏为的类,并为该类声明⽅法,但不能在该类中实现该类的情况。

JAVA学习(一)——基本语法

JAVA学习(一)——基本语法

JAVA学习(⼀)——基本语法 tips:前端开发写惯了弱类型语⾔,再来学强类型语⾔,真的是被各种修饰符、类型声明给整的云⾥雾⾥,⽽且java语法和javascript语⾔差别还是很⼤的,所以做好笔记,把⼀些需要注意的地⽅记下来是⾮常重要的,接下来就开始学习java啦。

 ⼀、基本语法: 1、⼤⼩写敏感:Java是⼤⼩写敏感的,这就意味着标识符Hello与hello是不同的。

2、类名:对于所有的类来说,类名的⾸字母应该⼤写。

如果类名由若⼲单词组成,那么每个单词的⾸字母应该⼤写,例如 MyFirstJavaClass 。

3、⽅法名:所有的⽅法名都应该以⼩写字母开头。

如果⽅法名含有若⼲单词,则后⾯的每个单词⾸字母⼤写。

4、源⽂件名:源⽂件名必须和类名相同。

当保存⽂件的时候,你应该使⽤类名作为⽂件名保存(切记Java是⼤⼩写敏感的),⽂件名的后缀为.java。

(如果⽂件名和类名不相同则会导致编译错误)。

5、主⽅法⼊⼝:所有的Java 程序由public static void main(String args[])⽅法开始执⾏。

备注⼀下: 5.1、public static void main(String args[]){}:为java主函数,java虚拟机会⾃动寻找到main⽅法,然后开始执⾏后⾯的程序,java程序的规定的格式写法; 5.2、public:可外部访问; 5.3、static:标记为静态函数,将该函数存储在静态存储区,不需要实例化(new)即可使⽤; 5.4、void:⽆返回值; 5.5、String args[]:可在命令⾏通过此参数给函数传值,可在其他类调⽤这个类的main函数时传值。

public class MyFirstJavaProgram {/* 第⼀个Java程序.* 它将打印字符串 Hello World*/public static void main(String []args) {System.out.println("Hello World"); // 打印 Hello World}} ⼆、类(class) 1、局部变量 2、成员变量:定义在类中,⽅法体之外的变量,和局部变量略有不同。

JAVA修饰符学习

JAVA修饰符学习

面向对象的技术已经成为软件开发的主导技术,在这个过程中它几乎改变了计算机科学中的每个方面。

几个概念:类:对象的集合体,对象模板。

举例说明:现实中的汽车是一个类,它具有车的共同属性和行为:如动力驱动,有四个或四个以上轮子,加油等。

小汽车、面包车、卡车等都是它的子类,它们都具有汽车(其父类)的属性和行为(注意:子类也是类,它可能还有子类),这就是继承。

Java只支持单继承,即一个类只能有一个父类。

对象是类的具体化:一个类可以有多个对象。

一个类可以有多个子类,每个子类不尽相同。

所谓:“一母生九子,九子各不同”。

如小汽车可以是四轮驱动也可以是两轮驱动等;桑塔纳3000有红的、白的、黑的等多种颜色(这个就是类的多态性)。

我们可以使用桑塔纳3000,但并不知道它是怎么造出来的,这种对用户隐藏实现细节就是封装。

类的封装、继承和多态性是面向对象编程的三个核心特征。

包:是管理类的有效机制,实际上对应一系列文件夹,管理类和平常管理文件类似。

类名要求:1、不能使用关键字;2、第一个字符不能为数字;3、首字母应该大写,同包内不能重复;4、类名应该有意义。

我先面的例子为了好理解,所以没有遵守第4条。

对于修饰符问题,是阻挡在Java初学者面前的一块顽石。

不管是类的还是方法或变量的,我们总是记了忘忘了记。

不掌握修饰符的用法,根本就没法进行下一步的学习,所以今天又总结了一些小东西,和大家共享,希望能给初学者帮助为盼。

在以后学习中我会不断总结Java的学习内容,用以帮助学习和自勉。

下面的代码复制粘贴后就可以使用,在Eclipse中没有错误。

//注意:下面类A在a包中package a;/*类修饰符:* public:公共类。

同包不同包的类都能访问;* default:默认类。

只能被同一包的其他类访问,默认方式不加修饰符;* final:最终类。

该类不能被继承,即该类不能有子类;* abstract:抽象类。

该类不能被实例化。

*//*方法和变量权限修饰符,建立在其类能访问的基础上,这点很重要* public:公共,在哪都能访问* protected:包私有级,不同包子类可以访问* default:友好方法,什么都不加,包私有级,不同包子类不可以访问* private:类私有级,只有所属类能访问* final:最终方法,不能由子类改变* abstract:抽象方法,无方法体* static:类方法修饰符,类方法只能调用类方法;但它不是访问权限修饰符* 类方法以外的方法称实例方法:实例方法可以调用其他实例方法和类方法* 记忆方法:有static类方法的只能调用static或被别的方法调用*/public class A {// 常用变量的修饰符有:public protected private static final// 实例变量,有private只能在同一个类中使用// 如果一个对象改变了实例变量的值,不会影响其他变量的访问// 不同对象的实例变量将被分配不同的内存空间// 下面以一家人举例:public String surname;// 如姓:张为public可以被任何地方访问/** protected变量同包能用,不同包不能访问,但不同包子类可以访问举例:带家里的存折,家里人能用。

java定义类、属性、方法

java定义类、属性、方法

定义属性的语法格式如下:
[修饰符] 属性类型 属性名 [=默认值]
属性语法格式的详细说明如下: 1、修饰符:修饰符可以省略,也可以是public、protected、private、static、final,其中public、protected、private三个最多只能出现其中之一,可以与static、final组合起来修饰属性。
3、形参列表:和定义方法形参列表的格式完全相同。
值得指出的是,构造器不能定义返回值类型声明,也不能使用void定义构造器没有返回值。如果为构造器定义了返回值类型,或使用void定义构造器没有返回值,编译时不会出错,但Java会把这个所谓的构造器当成方法来处理。
[修饰符] 构造器名 (形参列表)
{
//由零条到多条可执行性语句组成的构造器执行体
}
构造器语法格式的详细说明如下:
1、修饰符:修饰符可以省略,也可以是public、protected、private其中之一。
2、构造器名:构造器名必须和类名相同。
构造器用于对类实例进行初始化操作,构造器支持重载,如果多个重载的构造器里包含了相同的初始化代码,则可以把这些初始化代码放置在普通初始化块里完成,初始化块总在构造器执行之前被调用。除此之外,Java还提供了一种静态初始化块,静态初始化块用于初始化类,在类初始化阶段被执行。如果继承树里的某一个类需要被初始化时,系统将会同时初始化这棵继承树里的所有类。
类和对象
Java是面向对象的程序设计语言,类是面向对象的重要内容,我们可以把类当成一种自定义数据类型,可以使用类来定义变量,这种类型的变量统称为引用型变量。也就是说,所有类是引用数据类型。
定义类
面向对象的程序设计过程中有两个重要概念:类(class)和对象(object,也被称为实例,instance),其中类是某一批对象的抽象,可以把类理解成某种概念;对象才是一个具体存在的实体,从这个意义上来看,我们日常所说的人,其实应该是人的对象,而不是人类。

Java修饰词的总结

Java修饰词的总结

Java语言定义了public、protected、private、abstract、static和final这6常用修饰词外还定义了5个不太常用的修饰词。

下面是对这11个Java修饰词的介绍:1.public使用对象:类、接口、成员介绍:无论它所处在的包定义在哪,该类(接口、成员)都是可访问的2.private使用对象:成员介绍:成员只可以在定义它的类中被访问3.static使用对象:类、方法、字段、初始化函数介绍:成名为static的内部类是一个顶级类,它和包含类的成员是不相关的。

静态方法是类方法,是被指向到所属的类而不是类的实例。

静态字段是类字段,无论该字段所在的类创建了多少实例,该字段只存在一个实例被指向到所属的类而不是类的实例。

初始化函数是在装载类时执行的,而不是在创建实例时执行的。

4.final使用对象:类、方法、字段、变量介绍:被定义成final的类不允许出现子类,不能被覆盖(不应用于动态查询),字段值不允许被修改。

5.abstract使用对象:类、接口、方法介绍:类中包括没有实现的方法,不能被实例化。

如果是一个abstract方法,则方法体为空,该方法的实现在子类中被定义,并且包含一个abstract方法的类必须是一个abstract类6.protected使用对象:成员介绍:成员只能在定义它的包中被访问,如果在其他包中被访问,则实现这个方法的类必须是该成员所属类的子类。

7.native使用对象:成员介绍:与操作平台相关,定义时并不定义其方法,方法的实现被一个外部的库实现。

8.strictfp使用对象:类、方法介绍:strictfp修饰的类中所有的方法都隐藏了strictfp修饰词,方法执行的所有浮点计算遵守IEEE 754标准,所有取值包括中间的结果都必须表示为float或double类型,而不能利用由本地平台浮点格式或硬件提供的额外精度或表示范围。

9.synchronized使用对象:方法介绍:对于一个静态的方法,在执行之前jvm把它所在的类锁定;对于一个非静态类的方法,执行前把某个特定对象实例锁定。

答案JAVA程序设计基础(复习提纲及练习题

答案JAVA程序设计基础(复习提纲及练习题

复习....参考考试题型:1.单项选择题(本大题共15小题,每小题1分,共15分)2. 判断题(10小题,每小题1分,共10分)3.填空题(本大题共10空,每个空2分,共20分)4.阅读程序,写出程序运行后的输出结果(本大题共3小题,每小题6分,共18分)5. 编程题(本大题共3小题,共37分),其中第1题:9分(位操作),第2题14(分排序或字符串处理),第3题14分(类与对象)。

涉及数组、排序、字符串处理、类和对象(实例)、位操作(手写推算步骤及最终结果,要求看样题)等。

考试涉及的相关知识点:1.java程序类型:(1)java application(需主类)、java程序、源程序、类、接口、字节码文件、包、JDK JVM javac.exe java.exe跨平台java开发步骤一二维数组等(2)java applet:java小程序(可以没有主类,是图形界面),主要用于网页(3)java script:网页或网站的“脚本”程序2.标识符和关键字:class、interface final abstract static void byte short int long float double boolean String return 异常常用的关键字(try catch finally throw throws)3.表达式:=比较运算符:> >= < <= != ==逻辑运算符:&& || !位运算符:& |~ ^ >> >>> <<instanceof ++ -- 前后关系?:算合语句s+=5 s-=5 s*=5 s/=5 int a=b=10;4.程序控制结构:顺序、选择、循环(1)单路选择结构if(){ }(2)多路选择结构if( ) {.. else ..}(3)else if 结构(4)switch (break);while(){ … }do{ …. } while( ); break continuefor( ; ; ){ … }5.面向对象的程序设计:类:class 成员变量方法成员修饰符(访问、特征)static变量成员或方法实例变量成员或方法UML图对象:Object 创造对象new方法:void 方法、非void 方法、static 方法(类方法)、非static 方法(实例方法)方法参数传递:实参形参传值传引用(数组对象接口)多态:重载重写this 、super构造方法(在类的继承中可能用到的关键字super)包:关键字import 、package继承(组合:主类main() 与继承):继承创新改造子类不能降低父类的访问级别Super、this 、上转型对象Abstract、final接口:interface(1)实现:implements 也是一种继承(包括一般类与抽象类,多实现)(2)继承:extends (与类相比的“多继承”)(3)静态块(静态初始化器) static { …}、构造块{…}、构造方法以及在类的继承和实例生成中的相互关系和执行顺序。

Java接口成员变量和方法默认修饰符

Java接口成员变量和方法默认修饰符

Java接⼝成员变量和⽅法默认修饰符
Java的interface中,成员变量的默认修饰符为:public static final
所以我们在interface中定义成员变量的时候,可以
1:public static final String name = "张三";
2:String name = "张三";
以上两种都可以,⽼司机⼀般都是第⼆种。

既然是静态最终的变量,也就意味着在外⾯访问的时候不能修改这个成员变量的值。

所以在接⼝中定义成员变量的,⼀般都是常量。

不会修改的。

如果要进⾏修改的话,定义在接⼝具体实现类中。

说完成员变量的默认修饰符,顺便也提下⽅法的默认修饰符,⽅法的默认修饰符是:public abstract
即:公共抽象的,就是⽤来被实现该接⼝的类去实现该⽅法。

所以在接⼝中定义⽅法时候,也有两种⽅式
1:public abstract List<String> getUserNames(Long companyId);
2:List<String> getUserNames(Long companyId);
同样⽼司机都是第⼆种。

接⼝只是对⼀类事物属性和⾏为的更⾼次抽象;对修改关闭,对扩展开放,可以说是java中开闭原则的⼀种体现吧。

类方法成员变量和局部变量的可用修饰符权限

类方法成员变量和局部变量的可用修饰符权限

类方法成员变量和局部变量的可用修饰符权限在Java编程语言中,类、方法、成员变量和局部变量可以使用不同的修饰符权限来控制其可见性和访问级别。

这些修饰符权限可以分为四个类别:访问权限、非访问权限、继承性和抽象性。

以下是每个类别中可用的修饰符权限的详细讨论。

1.访问权限修饰符:- public:public是最高级别的访问权限修饰符,可以被任何类、方法、成员变量和局部变量访问。

当一个类、方法、成员变量或局部变量被声明为public时,它可以被任何类或方法访问。

- protected:protected修饰符只允许同一包中的类访问,并且可以被不同包中的子类访问。

当一个成员变量或方法被声明为protected时,它可以被访问的范围包括同一类、同一包中的类和不同包中的子类。

-默认(默认):如果没有明确指定访问权限修饰符,则默认修饰符将应用。

默认访问级别是包级别访问权限,即同一包中的类可以访问。

但是,在不同包中的类无法访问。

- private:private是最低级别的访问权限修饰符,它仅允许在同一类中访问。

当一个成员变量或方法被声明为private时,它只能在包含它的类中访问。

2.非访问权限修饰符:- final:final修饰符表示一个类、方法、成员变量或局部变量是不可更改的。

当一个类被声明为final时,它不能被继承。

当一个方法被声明为final时,它不能被子类重写。

当一个成员变量被声明为final时,它不能被修改。

当一个局部变量被声明为final时,它不能被重新赋值。

- static:static修饰符表示一个类、方法、成员变量或局部变量是静态的。

当一个成员变量被声明为static时,它成为类级别的变量,所有该类的实例共享相同的变量。

当一个方法被声明为static时,它成为类级别的方法,可以直接从类中调用,无需创建实例。

当一个类被声明为static时,它成为静态内部类,无需创建外部类的实例即可访问。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
创建新的对象。
对于很多的字符串连接,应当使用StringBuffer类,在使用这个类的对象来进行字符串连接时就不会有多余的中间对象生
成,从而优化了效率。
abstract(抽象)修饰符,可以修饰类和方法
1.abstract修饰类,会使这个类成为一个抽象类,这个类将不能生成对象实例,但可以做为对象变量声明的类型,也就是编译时类型,抽象类就像当于一类的半成品,需要子类继承并覆盖其中的抽象方法。
不变模式,对象一旦创建属性就不会改变。用final修饰属性,也用final修饰类(强不变模式),用final修饰属性(弱不变模式)。
不变模式的典型体现:ng.String类,不变模式可以实现对象的共享(可以用一个对象实例赋值给多个对象变量。

池化的思想,把需要共享的数据放在池中(节省空间,共享数据)
注意:static修饰的方法,不直接能访问本类中的非静态(static)成员(包括方法和属性),本类的非静态(static)方
法可以访问本类的静态成员(包括方法和属性),可以调用静态方法。静态方法要慎重使用。在静态方法中不能出现this
关键字。
注意:父类中是静态方法,子类中不能覆盖为非静态方法,在符合覆盖规则的前提下,在父子类中,父类中的静态方法可
是说抽象方法必须在其子类中实现,除非子类本身也是抽象类。
注意:父类是抽象类,其中有抽象方法,那么子类继承父类,并把父类中的所有抽象方法都实现(覆盖)了,子类才有创
建对象的实例的能力,否则子类也必须是抽象类。抽象类中可以有构造方法,是子类在构造子类对象时需要调用的父类(
抽象类)的构造方法。
抽象(abstract)方法代表了某种标准,定义标准,定义功能,在子类中去实现功能(子类继承了父类并需要给出从父类
继承的抽象方法的实现)。
方法一时间想不到怎么被实现,或有意要子类去实现而定义某种标准,这个方法可以被定义为抽象。(abstract)
模板方法模式
用abstract把制订标准和实现标准分开,制定的标准就是模板,实现就是按模板标准来实现,也就是继承模板,实现模板
类在什么时候会被加载,创建对象时会加载类,调用类中静态方法或访问静态属性也是会加载类的。在加载子类时必会先
加载父类,类加载会有延迟加载原则,只有在必须加载时才会加载。
final修饰符,可以修饰变量,方法,类
1.final修饰变量
被fianl修饰的变量就会变成常量(常量应当大写),一旦赋值不能改变,(可以在初始化时直接赋值,也可以在构造方法里也可以赋值,只能在这两种方法里二选一,不能不为常量赋值),fianl的常量不会有默认初始值,对于直接在初始化是赋值时final修饰符常和static修饰符一起使用。
中相应功能的方法。模板中不允许修改的方法可以用fianl来修饰,这个方法不能使抽象方法,为保证安全,封装,把模板中不公开的部分用protected(保护)修饰。
2.final修饰方法,被final修饰的方法将不能被其子类覆盖,保持方法的稳定不能被覆盖。
3.final修饰类,被final修饰的类将不能被继承。final类中的方法也都是final的。
注意:final,不能用来修饰构造方法,在父类中如果有常量属性,在子类中使用常量属性时是不会进行父类的类加载。
所以在类的main方法。所在在类加载时就可以通过main方法入口来运行程序。
3.static修饰初始代码块,这时这个初始代码块就叫做静态初始代码块,这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一个类。
动态初始代码块,写在类体中的“{}”,这个代码块是在生成对象的初始化属性是运行。这种代码块叫动态初始代码块。
final和abstract,private和abstract,static和abstract,这些是不能放在一起的修饰符,因为abstract修饰的方法是
必须在其子类中实现(覆盖),才能以多态方式调用,以上修饰符在修饰方法时期子类都覆盖不了这个方法,final是不可以覆盖,private是不能够继承到子类,所以也就不能覆盖,static是可以覆盖的,但是在调用时会调用编译时类型的方法,因为调用的是父类的方法,而父类的方法又是抽象的方法,又不能够调用,所以上的修饰符不能放在一起。
String类中的intern()方法会将在堆空间中创建的String类对象中的字符串和串池中的比对,如果有相同的串就返回这个
串的串池中的地址。
不变模式在对于对象进行修改,添加操作是使相当麻烦的,他会产生很多的中间垃圾对象。创建和销毁的资源的开销是相
的效率很低,就是因为它所产生的对象的书性是不能够修改的,当连接字符串时也就是只能
类变量,会在加载时自动初始化,初始化规则和实例变量相同。
注意:类中的实例变量是在创建对象时被初始化的,被static修饰的属性,也就是类变量,是在类加载时被创建并进行初
始化,类加载的过程是进行一次。也就是类变量只会被创建一次。
2.static修饰方法(静态方法),会使这个方法成为整个类所公有的方法,可以用类名.方法名访问。
以被子类中的静态方法覆盖,但是没有多态。(在使用对象调用静态方法是其实是调用编译时类型的静态方法)
注意:父子类中,静态方法只能被静态方法覆盖,父子类中,非静态方法只能被非静态方法覆盖。
java中的main方法必须写成static的因为,在类加载时无法创建对象,因为静态方法可以不通过对象调用
java中的修饰符
static 表示静态,它可以修饰属性,方法和代码块。
1.static修饰属性(类变量),那么这个属性就可以用类名.属性名来访问,也就是使这个属性成为本类的类变量,为
本类对象所共有。这个属性就是全类公有。(共有的类变量与对象无关,只和类有关)。
类加载的过程,类本身也是保存在文件中(字节码文件保存着类的信息)的,java会通过I/O流把类的文件(字节码文件)读入JVM(java虚拟机),这个过程成为类的加载。JVM(java虚拟机)会通过类路径(CLASSPATH)来找字节码文件。
2.abstract修饰方法,会使这个方法变成抽象方法,也就是只有声明(定义)而没有实现,实现部分以";"代替。需要子
类继承实现(覆盖)。
注意:有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法,也可以全是具体方法。
abstract修饰符在修饰类时必须放在类名前。
abstract修饰方法就是要求其子类覆盖(实现)这个方法。调用时可以以多态方式调用子类覆盖(实现)后的方法,也就
只有String类可以用“”中的字面值创建对象。在String类中,以字面值创建时,会到Java方法空间的串池空间中去查找
,如果有就返回串池中字符串的地址,并把这个地址付给对象变量。如果没有则会在串池里创建一个字符串对象,并返回
其地址付购对象变量,当另一个以字面值创建对象时则会重复上述过程。
如果是new在堆空间中创建String类的对象,则不会有上述的过程。
相关文档
最新文档