java访问权限修饰符
java访问权限修饰符public protected default
private用法总结
首先声明:java中,default这个修饰符并没有显式的声明,在成员变量和方法前什么修饰符也不用,默认的就是default。为了条理清晰,分三种不同情况来总结。
一访问权限修饰符修饰成员变量和方法
public:表明该成员变量和方法是共有的,能在任何情况下被访问。
protected:必须在同一包中才能被访问。(说的比较简单,看个例子就明白了) eg:class A
{
protected int weight;
protected int f( int a,int b )
{
// 方法体
}
}
假设B与A在同一个包中,则
class B
{
void g()
{
A a=new A();
A.weight=100;//合法
A.f(3,4); //合法
}
}
特别说明:什么是在同一个包中?
答:用package打包在一起的class ,叫在同一个包中。(不明白,举个例子) eg:在JDK的src\java\io中,你会看到许多java类,第一句源代码都是package java.io;
没有使用package打包的,在同一目录下的类也会被视做同一个包。
default:在这种情况下中,同protected。区别在第二和第三种情况中。
eg: class A
{
int weight ;
int f( int a,int b )
{
// 方法体
}
}
假设B与A在同一个包中,则
class B
{
void g()
{
A a=new A();
A.weight=100;//合法
A.f(3,4); //合法
}
}
private:只能在本类中访问。
eg: class Test
{
private int money;
Test()
{
money=2000;
}
private int getMoney()
{
return money;
}
public static void main(String args[])
{
Test te=new Test();
te.money=3000; //合法
int m=te.getMoney(); //合法
System.out.println("money="+m);
}
}
PS:实际上,把重要的数据修饰为private,然后写一个public的函数访问它,正好体现了OOP的封装特性,是OOP安全性的体现。
二访问权限修饰符修饰类
1,不能用protected和private修饰类。
2,用default修饰的类叫友好类,在另外一个类中使用友好类创建对象时,要保证它们在同一包中。
三访问权限修饰符与继承
这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况:
1,子类与父类在同一包中
此时只有声明为private的变量与方法不能被继承(访问)。
eg:
class Father
{
private int money ;
int weight=100;
}
class Son extends Father
{
viod f()
{
money=10000;// 非法
weight=100; // 合法
}
}
2,子类与父类不在同一包中
此时private与default均不能被继承(访问),protected与public可以。eg:
Father.java
package com.aaa
public class Father
{
int height ;
protected int money=120;
public int weight;
protected int getMoney()
{
return money;
}
void setMoney(int newMoney)
{
money=newMoney;
}
}
Son.java
package com.bbb
import com.aaa.Father;
public class Son extends Father
{
void f()
{
money=10000;//合法
//height=170;//非法,height为default修饰的变量
System.out.println(money);//输出结果是10000
//setMoney(300); //非法
int number=getMoney(); //合法
System.out.println(number);//输出结果是10000
}
public static void main(String args[])
{
Son sss=new Son();
sss.f();
}
}
所以,访问权限修饰符权限从高到低排列是public ,protected ,default, private。
Java中的abstract,static,final修饰符
abstract修饰符
abstract使用对象:类、接口、方法
介绍:类中包括没有实现的方法,不能被实例化。如果是一个abstract方法,则方法体为空,该方法的实现在子类中被定义,并且包含一个abstract方法的类必须是一个abstract
类
abstract修饰符表示所修饰的类没有完全实现,还不能实例化。如果在类的方法声明中使用abstract修饰符,表明该方法是一个抽象方法,它需要在子类实现。
在下面的情况下,类必须是抽象类:
1.类中包含一个明确声明的抽象方法;
2.类的任何一个父类包含一个没有实现的抽象方法;
3.类的直接父接口声明或者继承了一个抽象方法,并且该类没有声明或者实现该抽象方法。
如下例所示:
abstract class A1
{
public int v1;
abstract void test();
}
abstract class A2 extends A1
{
public int v2;
}
class Sample extends A2
{
void test() { }
}
因为包含一个抽象方法test,类A1必须被声明为抽象类。它的子类A2继承了抽象方法test,但没有实现它,所以它也必须声明为抽象类。然而,A2的子类Sample因为实现了test,所以它不必声明为抽象的。
注意:
如果试图创建一个抽象类的实例就会产生编译错误;
如果一个类是非抽象类却包含一个抽象方法,就会产生编译错误;
构造函数和静态函数以及Final修饰的函数不能使用abstract修饰符;
接口缺省为abstract。
Static修饰符
static使用对象:类、方法、变量、初始化函数
通常,在创建类的实例时,每个实例都会创建自己实例变量。但是在变量的声明中可以使用Static修饰符,它表明该成员变量属于类本身,独立于类产生的任何对象。这种成员变量称为静态变量(静态属性)。方法的声明中也可以使用static修饰符,表明该方法从属于类本身。
静态属性和静态方法不需要创建实例就可以使用。
典型的例子是https://www.360docs.net/doc/3015261367.html,ng包中的System类中的方法和变量。我们常用
System.out.println(“message”);
输出信息,并没有创建System的实例,是因为println方法声明为System类的静态方法,它不需创建实例就可以使用。
下面的例子会帮助你更深刻的理解Static修饰符。注意各个代码块的加载次序。
class Sample
{
static int s1=3;
static int s2;
static void display()
{
System.out.println("s1="+s1);
System.out.println("s2="+s2);
}
static
{
System.out.println("static block");
s2=s1+1;
}
public static void main(String args[])
{
Sample.display();
}
}
一旦这个类被调用,所有的静态变量都被初始化,s1被赋为3,然后运行static块,这将打印出一段消息,并且把s2赋为s1+1,即4。然后解释器调用main成员函数,它调用了成员函数display,该函数输出s1和s2的信息。运行结果如下:
C:\>java Sample
static block
s1=3
s2=4
通过上面的例子还可以看出,一个静态成员函数可以通过它所属的类名来调用。
注意:
在静态成员函数中只能直接调用其它的静态成员函数或引用静态属性,否则会造成编译错误。静态成员函数中也不能使用this或者super,因为它们是和类的对象相关联的。
final修饰符
final使用对象:类、方法、变量
介绍:被定义成final的类不允许出现子类,不能被覆盖,字段值不允许被修改。
如果一个类是完全实现的,并且不再需要继承子类,则它可以声明为Final类。如果final 类的名字出现在另一个类声明的extends字句的后面就会产生编译错误。这表明final类不能有任何的子类。类不能同时被声明为abstract和final,因为abstract类中的abstract方法永远没有机会被实现。
在缺省情况下,所有的成员函数和实例变量都可以被覆盖。如果你希望你的变量或成员函数不再被子类覆盖,可以把它们声明为final。
例如:
class FinalSample{
final int MAX_VALUE = 100;
public static void main(String args[])
{ FinalSample a =new FinalSample();
System.out.print(a.MAX_VALUE);
}
}
表示,MAX_VALUE的值为100,并且不能再更改。final变量用大写标识符是一个一般的约定。
JAVA笔试题--基础很全有答案
第一组 1.下列不可作为java语言修饰符的是(D) A) a1 B) $1 C) _1 D) 11 2.有一段java 应用程序,它的主类名是a1,那么保存它的源文件名可以是(A) A) a1.java B) a1.class C) a1 D) 都对 3.整型数据类型中,需要内存空间最少的是(D) A) short B) long C) int D) byte 4. Java 类可以作为(C) A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5.在创建对象时必须(C) A) 先声明对象,然后才能使用对象 B) 先声明对象,为对象分配内存空间,然后才能使用对象 C) 先声明对象,为对象分配内存空间,对对象初始化,然后才能使用对象 D) 上述说法都对 6.在调用方法时,若要使方法改变实参的值,可以(B) A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中(C) A) 一个子类可以有多个父类,一个父类也可以有多个子类 B) 一个子类可以有多个父类,但一个父类只可以有一个子类 C) 一个子类可以有一个父类,但一个父类可以有多个子类 D) 上述说法都不对 8.Java语言具有许多优点和特点,哪个反映了Java程序并行机制的特点?(B) A) 安全性B) 多线性C) 跨平台D) 可移植 9. Character流与Byte流的区别是(C) A) 每次读入的字节数不同B) 前者带有缓冲,后者没有 C) 前者是字符读写,后者是字节读写D) 二者没有区别,可以互换使用
10.以下声明合法的是( D ) A、default String s; B、public final static native int w( ) C、abstract double d; D、abstract final double hyperbolicCosine( ) 11.关于以下application的说明,正确的是( C ) 1.class StaticStuff 2.{ 3.static int x=10; 4.static { x+=5;} 5.public static void main(String args[ ]) 6.{ 7.System.out.println(“x=”+ x); 8.} 9.static { x/=3;} 10. } A、4行与9行不能通过编译,因为缺少方法名和返回类型 B、9行不能通过编译,因为只能有一个静态初始化器 C、编译通过,执行结果为:x=5 D、编译通过,执行结果为:x=3 12.关于以下程序代码的说明正确的是( D ) 1.class HasStatic{ 2.private static int x=100; 3.public static void main(String args[ ]){ 4.HasStatic hs1=new HasStatic( ); 5.hs1.x++; 6.HasStatic hs2=new HasStatic( ); 7.hs2.x++; 8.hs1=new HasStatic( ); 9.hs1.x++; 10.HasStatic.x- -; 11.System.out.println(“x=”+x); 12.} 13.} A、5行不能通过编译,因为引用了私有静态变量 B、10行不能通过编译,因为x是私有静态变量 C、程序通过编译,输出结果为:x=103 D、程序通过编译,输出结果为:x=102 13.以下选项中循环结构合法的是( C ) A、while (int i<7) { i++;
C++类成员的访问权限
前面我们在定义类时多次使用到了public 关键字,表示类的成员具有“公开”的访问权限,这节我们就来详细讲解。 C++通过public、protected、private 三个关键字来控制成员变量和成员函数的访问权限,它们分别表示公有的、受保护的、私有的,被称为成员访问限定符。所谓访问权限,就是你能不能使用该类中的成员。 Java、C# 程序员注意,C++ 中的public、private、protected 只能修 饰类的成员,不能修饰类,C++中的类没有共有私有之分。 在类的内部(定义类的代码内部),无论成员被声明为public、protected 还是private,都是可以互相访问的,没有访问权限的限制。 在类的外部(定义类的代码之外),只能通过对象访问成员,并且通过对象只能访问public 属性的成员,不能访问 private、protected 属性的成员。 本节重点讲解public 和private,protected 将在继承中讲解。 下面通过一个Student 类来演示成员的访问权限: 1.#include
10. 11.public://共有的 12.void setname(char*name); 13.void setage(int age); 14.void setscore(float score); 15.void show(); 16.}; 17. 18.//成员函数的定义 19.void Student::setname(char*name){ 20.m_name = name; 21.} 22.void Student::setage(int age){ 23.m_age = age; 24.} 25.void Student::setscore(float score){ 26.m_score = score; 27.} 28.void Student::show(){ 29.cout<
JAVA语言中的final修饰符
final关键字可用于修饰类,变量和方法,final关键字有点类似c#里的sealed关键字(如果大家学过C#就知道),它用于表示它修饰的类,方法和变量不可改变。 final变量 final修饰变量时,表示该变量一旦获得了初始值就不可改变,final既可修饰成员变量(包括类变量和实例变量),也可以修饰局部变量,形参。严格来说final修饰的变量不要被改变,一旦获得初始值之后,该final变量的值就不能被重新赋值。 因为final变量获得初始值之后不能被重新赋,因此final修饰成员变量和修饰局部变量时有一定的不同:下面我将会写到有哪些方面的不同,还有就是为什么会不同。 final修饰成员变量 成员变量是随类初始化或对象初始化而初始化的。当类初始化时,系统会为该类属性分配内存,并分配默认值;当创建对象时,系统会为该对象的实例属性分配内存,并分配默认值。也就是说,当执行静态初始化块时可以对类属性赋初始值,当执行普通初始块,构造器时可对实例属性赋初始值。因此,成员变量的初始值可以在定义该变量时指定默认值,可以在初始化块,构造器中指定初始值,否则,成员变量的初始值将是由系统自动分配的初始值。 对于final修饰的成员变量而言,一旦有了初始值之后,就不能重新赋值,因此不可以在普通方法中对成员变量重新赋值。成员变量只能在定义该成员变量时指定默认值,或者在静态初始化块,初始化块,构造器中为成员变量指定初始值,如果既没有在定义成员变量时指定初始值,也没有在初始化块,构造器中为成员变量指定初始值,那么这些成员变量的值将一直是0,\u0000,false null这些成员变量也就失去了存在的意义。 因此当使用final修饰成员变量的时候,要么在定义成员变量时候指定初始值,要么
java中的类修饰符
java中的类修饰符、成员变量修饰符、方法修饰符。 类修饰符: public(访问控制符),将一个类声明为公共类,他可以被任何对象访问,一个程序的主类必须是公共类。 abstract,将一个类声明为抽象类,没有实现的方法,需要子类提供方法实现。 final,将一个类生命为最终(即非继承类),表示他不能被其他类继承。 friendly,默认的修饰符,只有在相同包中的对象才能使用这样的类。 成员变量修饰符: public(公共访问控制符),指定该变量为公共的,他可以被任何对象的方法访问。 private(私有访问控制符)指定该变量只允许自己的类的方法访问,其他任何类(包括子类)中的方法均不能访问。 protected (保护访问控制符)指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。 friendly ,在统一报中的类可以访问,其他包中的类不能访问。 final,最终修饰符,指定此变量的值不能变。 static(静态修饰符)指定变量被所有对象共享,即所有实例都可以使用该变量。
transient(过度修饰符)指定该变量是系统保留,暂无特别作用的临时性变量。 volatile(易失修饰符)指定该变量可以同时被几个线程控制和修改。 方法修饰符: public(公共控制符) private(私有控制符)指定此方法只能有自己类等方法访问,其他的类不能访问(包括子类) protected(保护访问控制符)指定该方法可以被它的类和子类进行访问。 final,指定该方法不能被重载。 static,指定不需要实例化就可以激活的一个方法。 synchronize,同步修饰符,在多个线程中,该修饰符用于在运行前,对他所属的方法加锁,以防止其他线程的访问,运行结束后解锁。 native,本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。