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

java类的访问修饰符总结java的修饰符有：权限修饰符：public、protected、default、private修饰符：abstract、static、finalpublic 使用对象：最广，类、接口、变量、方法protected使用对象：变量、方法注意：不能修饰类（外部类）default 使用对象：类、接口、变量、方法。

（即缺省，什么也不写）private 使用对象：变量、方法注意：不能修饰类（外部类）abstract使用对象：类、接口、方法static 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰内部类）final 使用对象：类、变量、方法transient：告诉编译器，在类对象序列化的时候，此变量不需要持久保存volatile：指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理native：用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C、C++编写的。

synchronized：修饰方法，多线程的支持类分外部类和内部类，他们的访问控制是相同的吗外部类是相对于内部类而言的，内部类是定义在类里面的类。

外部类的修饰符有：default（缺省，不写）：类定义时前面未加任何修饰符，表示同一个包中可见。

public：修饰类时表示该类能被项目中所有类可见abstract：表示是抽象类final：表示类不可以被继承scrictpf:(java关键字) 当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。

严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示内部类又分：成员内部类、局部内部类、静态内部类、匿名内部类成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列局部内部类：定义在外部类的方法体里面的类静态内部类：使用static修饰的内部类匿名内部类：就是没有名字的内部类成员内部类修饰符有：public：protected：private：private不能修饰外部类，abstract：final：static：可以当做普通类使用，而不用先实例化一个外部类。

11.可以用private或protected修饰内部类。

（对）2.非匿名内部类也可以实现接口。

（对）3.编译器会给内部类一个名字。

（对）4.匿名类可以是抽象类。

（错）5.一个方法使用throw关键字声明要产生的若干个异常。

（错）解析：一个方法声明时可以使用throws关键字声明要产生的多个异常，并在该方法体中具体给出产生异常的操作，使用throw关键字只能抛出一个异常。

6.类加载器加载程序运行所需要的所有类，由网络系统导入的指定类总是先被加载。

（错）解析：类加载器加载程序运行所需要的所有类，它通过区分本机文件系统的类和网络系统导入的类增加安全性。

7.调用System.gc()方法不能保证JVM立即进行垃圾收集，而只能是建议。

（对）8.friendly关键字是Java语言的访问控制修饰符。

（错）解析：Java语言的访问控制修饰符关键字为public、protected和private。

9.maxElements是一个成员变量，声明为：“public static final int maxElements=100”。

（对）10.实例变量在使用new Xxxx()创建该类的实例时被创建，而其生存期和该类的实例对象的生存期相同。

（对）11.在构造方法中如调用super()语句，则必须使其成为构造方法中的第一条语句。

（对）12.重写的方法的访问权限不能比被重写的方法的访问权限高。

（错）解析：重写的方法的访问权限不能比被重写的方法的访问权低。

13.类变量在该类被加载时被创建，不能用new Xxxx()创建，所有该类的实例对象共享类变量，其生存期是类的生存期。

（对）14.调用sleep()方法可以使一个线程停止运行。

（对）15.一个新线程启动start()方法，表示线程可为JVM的线程调度而不表示它可以立即运行。

（对）16.垃圾收集器的过程在Java程序的生存期中是自动的，不需要分配和释放内存，也避免了内存泄漏。

面向对象复习1.以下关于抽象类和接口的说法错误的是（）A、接口中的方法都必须加上public关键字。

B、在抽象类中可以没有抽象方法C、实现抽象类和接口的类必须实现其中的所有方法，除非它也是抽象类。

接口中的方法都不能被实现D、接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

2.下列哪一种叙述是正确的（）A．abstract修饰符可修饰字段、方法和类B．抽象方法的body部分必须用一对大括号{ }C．声明抽象方法，大括号可有可无D．声明抽象方法不可写出大括号3下列说法正确的是（）A、JAVA程序的main方法必须写在类里面B、JAVA程序中可以有多个main方法C、JAVA程序中类名必须与文件名一样D、JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来4.Java中，在如下所示的Test类中，共有（2）个构造方法。

public class Test{private int x;public Test(){x=35;}public void Test(double f){This.x=(int)f;}public Test(String s){}}5 变量命名规范说法正确的是（F）E、变量由字母、下划线、数字、$符号随意组成；F、变量不能以数字作为开头；G、A和a在java中是同一个变量；H、不同类型的变量，可以起相同的名字；6为一个boolean类型变量赋值时，可以使用(I)方式I、boolean = 1;J、boolean a = (9 >= 10);K、boolean a="真";L、boolean a = = false;7以下(O)不是合法的标识符M、STRINGN、x3x;O、v oidP、de$f2、表达式(11+3*8)/4%3的值是(D)A、31B、0C、1D、23、（A）表达式不可以作为循环条件A、i++;B、i>5;C、bEqual = str.equals("q");D、count = = i;4、运算符优先级别排序正确的是（C）A、由高向低分别是：()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符；B、由高向低分别是：()、关系运算符、算术运算符、赋值运算符、!、逻辑运算符；C、由高向低分别是：()、算术运算符、逻辑运算符、关系运算符、!、赋值运算符；D、由高向低分别是：()、!、关系运算符、赋值运算符、算术运算符、逻辑运算符；5、以下程序的运行结果是：(B)public class Increment{public static void main(String args[]) {int a;a = 6;System.out.print(a);System.out.print(a++);System.out.print(a);}}A.666B.667C.677D.6766、下列值不为true的表达式有（C）。

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面向对象（50个）易：1.对象是由一组属性和对这组属性进行（操作）的一组服务组成的。

2.对象是指（具体）的事物,而类是指一类具有某种共性的事物。

3.由类来确定具体对象的过程称为类的（实例化）。

4.一个类由类声明和（类体）两部分组成。

5.当一个类的类修饰符为（ final ）时,说明该类不能被继承,即不能有子类。

6.Java程序在extends之后只能有一个父类,即extends只能实现（单）继承。

7.在Java中只能实现单继承,但可通过（接口）实现多重继承。

8.一个类可实现多个接口,各接口名是以（，）分隔。

9.在类体中声明的变量称为（成员）。

10.在方法中声明的变量称为（局部变量）。

11.在Java程序中，使用关键字（this）来引用当前对象。

12.一个方法的定义是由方法声明和（方法体）两部分组成。

13.方法声明包括（方法名）、返回类型和形式参数。

14.构造方法的方法名要求与（类名）相同,而且无返回值。

15.面向对象的三个特性是：封装性、继承性和（多态性）。

16.在Java中，通过对象的（封装），实现了模块化和信息隐藏。

17.两个方法具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同，则称为方法的（重写）。

18.Java中通过关键字（super）来实现对父类成员的访问。

19.Java用（ extends）关键字指明继承关系。

20.在Java中，用关键字（abstract）来修饰一个类，则该类为抽象类。

21.若某个类包含了抽象方法，则该类必须被定义为（抽象）类。

22.接口的定义，需使用关键字（interface）来声明。

23.声明父类时，需使用关键字（extends）来实现。

24.java语言中接口是特殊的类，其中包含常量和（抽象）方法。

25.当要引用包中所有的类时，类名可以用通配符（* ）号代替。

26.一个类要从另一个类继承变量和方法，必须使用关键字（extends）。

27.（抽象）类不能被实例化,它不具备实际功能,只用于衍生子类。

一丶封装1 权限修饰符可以用来修饰成员变量和成员方法，对于类的权限修饰只可以用public和缺省default。

被public修饰的类可以在任意地方被访问；default类只可以被同一个包内部的类访问。

权限由大到小：public protected default(不写) private被private修饰的成员只能在本类中访问，外界不能访问2 set()/get()方法（1）this关键字a.可以用来调用变量，方法，构造方法；b.this.xx 理解为调用当前类的xx。

（2）成员变量和局部变量1）在类中的位置不同a:成员变量:在类中,方法外b:局部变量:在方法声明上（形式参数）,或者是在方法定义中2）在内存中的位置不同a:成员变量:在堆内存b:局部变量:在栈内存3）生命周期不同a:成员变量:随着对象的创建而存在,随着对象的消失而消失b:局部变量:随着方法调用而存在,随着方法的调用结束而消失4）初始化值不同a:成员变量:有默认值b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化) （3）set()/get()方法当成员变量被private修饰时，不在本类中无法直接访问，便需要set()/get()方法来解决这个问题3 封装性封装：是面向对象的第一大特性，所谓封装，就是值对外部不可见（一般而言被private修饰），外部只能通过对象提供的接口（如set()/get()方法）来访问。

封装的好处：a.良好的封装能够减少耦合；b.类内部的结构可以自己修改，对外部影响不大；c.可以对成员进行更精准的控制（防止出现与事实不符的情况）；d.影藏实现细节。

注意：在开发中，类的成员变量全部要进行封装，封装之后通过set()/get()方法访问。

二丶继承extends1 实现：通过 class Zi extends Fu{} 实现类的继承（1）子类继承父类，父类中声明的属性，方法，子类都可以获取到；当父类中有私有的属性方法时，子类同样可以获取到，由于封装性的设计，使得子类不能直接调用访问。

面向对象编程基本知识练习一、判断题1.不需要定义类，就能创建对象。

（）2.构造方法用于给类的private 实例变量赋值。

（）3.对象一经声明就可以立即使用。

（）4.在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。

（）5.Java 程序中的参数传递都是把参数值传递给方法定义中的参数。

（）6.在类定义中，成员访问权限修饰符不能多次出现。

（）7.new 操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。

（）8.类的方法通常设为public，而类的实例变量一般也设为public。

（）9.构造方法在创建对象时被调用。

（）10.通过点运算符与类对象的引用相连，可以访问此类的成员。

（）11.声明为protected 的类成员只能被此类中的方法访问。

（）12.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。

（）13.类的成员变量可以放在类体的任意位置。

（）14.声明为protected 的类成员可以被此类作用域中的任何对象访问。

（）15.没有返回值的方法可以用void 来表示，也可以不加。

（）二、选择题1. 下面对对象概念描述错误的是：( )A 操作是对象的动态属性B 任何对象都必须有继承性C 对象间的通讯靠消息传递D 对象是属性和方法的封装体2．编译并运行下面的程序，运行结果为：( )public class A{public static void main(String[] args){A a=new A()；a.method(8)；}void method(int i){System.out.println(“int：“+i)；}void method(long i){System.out.println(“long：“+i)；}}A 程序可以编译运行，输出结果为int：8B 程序可以编译运行，输出结果为long：8C 程序有编译错误，因为两个method()方法必须定义为静态(static)的D 程序可以编译运行，但没有输出3．下面关于类的说法不正确的是：（）A 类是Java 语言中的一种复合数据类型B 类中不包含数据变量和方法C 类是对所有具有一定共性的对象的抽象D Java 语言的类只支持单继承4．能作为类及其成员的修饰符是：（）A interfaceB classC protectedD public5．设x、y 均为已定义的类名，下列声明对象x1 的语句不可能正确的是：（）A public x xl=new y();B public y xl=new x();C x xl=new x();D x xl=x();6．面向对象程序设计技术的特点是：（）A 可重用性B 可维护性C 表示方法的一致性D 可重用性、可维护性、表示方法的一致性7．下列方法定义中，方法头不正确的是：（）A public static x(double a){…}B public static int x(double y){…}C void x(double d)D public int x(){…}8．设已声明了一个类A 的两个对象al、a2，为了初始化a1 和a2，下面语句正确的是：（）A al=new(); a2=new();B al=A new(); a2=A new();C al,a2=new A();D al=new A(); a2=new A();9．构造方法何时被调用?（）A 类定义时B 使用对象的变量时C 调用对象方法时D 创建对象时10．下列哪个类声明是正确的?（）A public abstract class Car{…}B abstract private move(){…}C protected private number;D abstra ct final class Hl{…}11．下列不属于面向对象程序设计的基本特征的是：（）B 封装C 继承D 静态12．请看下面的程序段class Person {String name,department;int age;public Person(String n) { name = n; }public Person(String n,int a) { name = n; age = a; }public Person(String n,String d,int a) {//doing the same as two arguments version of constructer//including assignment name=n,age=a}}下面那一选项可以添加到“//doing the same……”处：（）A Person(n,a)B this(Person(n,a))C this(n,a)D this(name.age)13．（）是一个特殊的方法，用于对类的实例变量进行初始化。

JAVA篇：修饰符与接⼝、类、⽅法、成员变量、局部变量、⽅法块或许这是⼀个⽐较轻松简单的知识点，因为只是简单地做⼀个总览对⽐⽽已。

这周⽐较忙，祝我⾃⼰好运。

有关接⼝(interface)的修饰符，其实⼀般⽤public，也可以不加修饰词（default），或者是使⽤private修饰的声明在类的内部的内部接⼝。

不存在protected修饰的接⼝。

⽽接⼝内部可以有⽤public static final修饰的静态常量，除此之外只存在public修饰的⽅法（接⼝中⽆修饰词的⽅法也默认是public）了。

⽆论是接⼝还是接⼝中的⽅法的abstract修饰词都是隐含的，不必显式地修饰在接⼝或者⽅法前⾯。

类的访问限制修饰词与接⼝⼀样，但是还可以有⾮访问限制修饰词abstract(抽象类)和final(不可继承的类)。

类的成员变量可以被四种访问修饰词修饰，同时也可以被static(静态变量),final(常量),transtient(有关序列化特殊标识变量,具体还需要进⾏了解), volatie(线程共享变量)。

类⽅法除了访问限制修饰符，还可使⽤static（静态⽅法）,final(不可改变的⽅法),abstract(抽象的),native(⾮java实现的),synchronized(线程同步),类构造⽅法只可使⽤访问限制修饰符修饰，局部变量只能使⽤final定义常量,⽅法块可以使⽤static定义静态⽅法块和使⽤synchronized 定义线程同步的⽅法块。

java的接⼝、类1、接⼝(interface) 在java中，接⼝是⼀个抽象类型，是抽象⽅法的集合，接⼝通常以interface来声明，接⼝只能包含抽象⽅法和以static\final修饰的变量，⼀个接⼝可以继承（extends）另⼀个接⼝。

接⼝只包含要实现的⽅法，⽽类描述对象的属性和⽅法，两者实现类似但是概念不同。

java提供了类和接⼝之间的实现机制，接⼝不可被实例化，只能被实现（implements），实现接⼝的类必须实现接⼝中全部的抽象⽅法，否则该类必须使⽤abstract声明为抽象类。

Java解剖面向对象编程（二）1 .2 . 1 继承继承关系：两个类之间是“is-a”的关系。

继承的特点：子类继承了超类（父类）的所有属性和方法（但是不包括构造方法），并且可以为自己增添的属性和方法。

继承可提高代码的重用性，使用extends关键字来实现。

Java只支持单继承：即一个子类只能有一个超类。

但一个基类可以派生出多个子类。

1 .2 . 2 【super关键字】调用子类构造方法构造对象时：先调用超类方法对超类的属性进行初始化，然后才调用自己构造方法自己的属性都进行初始化。

如果子类构造方法没有显示调用超类构造方法，那么会调用超类的默认构造方法。

如果超类没有默认的构造方法，而且子类构造方法又没有显示调用其它的超类方法，那么编译将报错。

若要在子类构造方法中调用超类构造方法，则在子类构造方法的第一条语句用关键字super来调用。

语法：super() 或super(参数列表);Super调用超类中的普通方法。

语法：super.方法名（参数列表）。

1 .2 .3 访问控制Java权限修饰符public protected private 置于类的成员定义前，用来限定其它对象对该类成员的访问权限。

这些修饰符可以修饰类、成员变量、方法。

private : 本类可见，默认：本类、本包可见。

protected : 对本类、本包可见。

对于类的访问修饰，只可以是public 或默认的。

1 .2 . 4 方法的重新在子类中可以根据需要对从超类中继承的方法进行重写。

重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。

重写方法不能使用比重写方法更严格的访问权限在类中可以根据需要对从基类中继承来的方法进行重写。

1 .2 . 5 Object类ng.Object类是所有Java类的根类，如果在类的声明中未使用extends关键字指定父类，则默认为继承自Object类toString() : 返回代表该对象值得字符串。

final关键字：⽤来修饰类，⽅法，成员变量，局部变量final 关键字：⽤来修饰类，⽅法，成员变量，局部变量
表⽰最终的不可变的
1、final修饰⼀个类
表⽰当前的类不能有⼦类，也就是不能将⼀个类作为⽗类
格式：
public final class 类名称 {
class body
}
⼀个类如果是final的，那么其中所有成员⽅法都不能被覆盖重写（因为没有⼦类），但是该类可以有⽗类
2、final关键字修饰成员⽅法
这个⽅法就是最终⽅法，也就是该类的⼦类不能覆盖重写这个⽅法
对于类、⽅法来说abstract、final不能同时使⽤，因为他们是⽭盾的，abstract的⽅法必须覆盖重写，但是final的⽅法不能覆盖重写3、final修饰局部变量
⼀旦使⽤final修饰局部变量，就不能改变，也就是⼀旦赋值不能更改，⽽且只能赋值⼀次，哪怕第⼆次赋值是⼀样的也不⾏
对于引⽤类型来说，使⽤关键字final修饰，不可变的含义就是地址值不能改变，但是该地址指向的对象的内容是可以改变的
4、final关键字修饰成员变量
对于成员变量来说，⼀旦使⽤final关键字，也是⼀样不能改变
a、和局部变量的不同点在于，成员变量有默认值，因此必须⼿动赋值
b、final的成员变量可以定义的时候直接赋值，或者使⽤构造⽅法在构造⽅法体⾥⾯赋值，但是只能⼆者选其⼀
c、如果没有直接赋值，那就必须保证所有重载的构造⽅法最终都会对final的成员变量进⾏了赋值。