java修饰符

‘壹’ java 修饰符有哪几个

1、类的修饰符分为：可访问控制符和非访问控制符两种。

可访问控制符是：公共类修饰符 public

非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final

1 ）公共类修饰符 public ： Java 语言中类的可访问控制符只有一个： public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具供其它类和程序使用的应定义为 public 类。

2 ）抽象类修饰符 abstract ：凡是用 abstract 修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是 Java 语言的 abstract 类。

3 ） 最终类修饰符 final ：当一个类不可能有子类时可用修饰符 final 把它说明为最终类。被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。

4 ）类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。

2 ．域的控制修饰符也分为：可访问控制符和非访问控制符两类。

可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected

非访问控制符有 4 种：静态域修饰符： static ；最终域修饰符： final ；易失 ( 共享 ) 域修饰符： volatile ；暂时性域修饰符： transient

1 ）公共访问控制符 public ：用 public 修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于 public 修饰符会降低运行的安全性和数据的封装性，所以一般应减少 public 域的使用。

2 ）私有访问控制符 private ： 用 private 修饰的成员变量 ( 域 ) 只能被该类自身所访问，而不能被任何其它类 ( 包括子类 ) 所引用。

3 ）保护访问控制符 protected ：用 protected 修饰的成员变量可以被三种类所引用：①该类自身；②与它在同一个包中的其它类；③在其它包中的该类的子类。使用修饰符 protected 的主要作用是允许其它包中它的子类来访问父类的特定属性。

4 ）私有保护访问控制符 private protected ：用修饰符 private protected 修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。

5 ）静态域修饰符 static ：用 static 修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据；任何一个类的对象修改它时 , 也都是对同一个内存单元进行操作。

6 ）最终域修饰符 final ：最终域修饰符 final 是用来定义符号常量的。一个类的域 ( 成员变量 ) 如果被修饰符 final 说明，则它的取值在程序的整个执行过程中都是不变的。

7 ）易失 ( 共享 ) 域修饰符 volatile ：易失 ( 共享 ) 域修饰符 volatile 是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常 volatile 用来修饰接受外部输入的域。

8 ）暂时性域修饰符 transient ：暂时性域修饰符 transient 用来定义一个暂时性变量。其特点是：用修饰符 transient 限定的暂时性变量，将指定 Java 虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能。否则，类中所有变量都是对象的永久状态的一部分，存储对象时必须同时保存这些变量。

3 ．方法的控制修饰符也分为：可访问控制符和非访问控制符两类。

可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected

非访问控制符有 5 种：抽象方法控制符： abstract ；静态方法控制符： static ；最终方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized

1 ）抽象方法控制符 abstract ：用修饰符 abstract 修饰的方法称为抽象方法。抽象方法是一种仅有方法头，没有方法体和操作实现的一种方法。

2 ）静态方法控制符 static ：用修饰符 static 修饰的方法称为静态方法。静态方法是属于整个类的类方法；而不使用 static 修饰、限定的方法是属于某个具体类对象的方法。 由于 static 方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即 static 方法只能处理 static 的域。

3 ）最终方法控制符 final ：用修饰符 final 修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重载。这样，就固定了这个方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被 private 修饰符限定为私有的方法，以及所有包含在 final 类 ( 最终类 ) 中的方法，都被认为是最终方法。

4 ）本地方法控制符 native ：用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符 native 来修饰；

5 ）同步方法控制符 synchronized ：该修饰符主要用于多线程共存的程序中的协调和同步。

本文出自http://hi..com/lifa868/blog/item/d91674ecb346c64779f0557d.html

‘贰’ Java中修饰符怎么用

java修饰符要分清类的修饰符和成员修饰符
类的修饰符有final、abstract、public等（注意的是：一个程序中只能有一个并列的public类）
成员的的修饰符就比较多了 public friendly protected private static final syhncronazed等等.
分不清的话 都先别写修饰符。慢慢理解就好了。

‘叁’ Java内部类的修饰符有哪些

一、内部类可以为四种：

⒈ 静态内部类

⒉ 成员内部类

⒊ 局部内部类

⒋
匿名内部类几种内部类的共性：

A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。

B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

1、静态嵌套类：从技术上讲，静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部，因此也被称为顶级嵌套类。静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类不能访问外部类的成员和方法。 class Outer{ static class Inner{} } class Test { public static void main(String[] args){ Outer.Inner n = new Outer.Inner(); } }

2、成员内部类：形式如下
class Outer { class Inner{} }
编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。成员内部类内不允许有任何静态声明！下面代码不能通过编译。
class Inner{ static int a = 10;
}能够访问成员内部类的唯一途径就是通过外部类的对象！

A、从外部类的非静态方法中实例化内部类对象。 class Outer { private
int i = 10; public void makeInner(){ Inner in = new Inner();
in.seeOuter(); } class Inner{ public void seeOuter(){
System.out.print(i); } }
}表面上，我们并没有创建外部类的对象就实例化了内部类对象，和上面的话矛盾。事实上，如果不创建外部类对象也就不可能调用makeInner()方法，所以到头来还是要创建外部类对象的。可能试图把makeInner()方法修饰为静态方法，即static
public void
makeInner()。这样不创建外部类就可以实例化外部类了！但是在一个静态方法里能访问非静态成员和方法吗？显然不能。它没有this引用。没能跳出那条规则！但是如果在这个静态方法中实例化一个外部类对象，再用这个对象实例化外部类完全可以！也就是下一条的内容。

B、从外部类的静态方法中实例化内部类对象。
class Outer { private int i = 10; class Inner{ public void seeOuter(){
System.out.print(i);
} } public static void main(String[] args) { Outer out = new Outer();
Outer.Inner in = out.new Inner(); //Outer.Inner in = new Outer().new
Inner(); in.seeOuter(); }
}被注释掉的那行是它上面两行的合并形式，一条简洁的语句。对比一下：在外部类的非静态方法中实例化内部类对象是普通的new方式：Inner in =
new Inner();在外部类的静态方法中实例化内部类对象，必须先创建外部类对象：Outer.Inner
in = new Outer().new
Inner();

C、内部类的this引用。普通的类可以用this引用当前的对象，内部类也是如此。但是假若内部类想引用外部类当前的对象呢？用“外部类名”.this；的形式,如下例的Outer.this。
class Outer { class Inner{ public void seeOuter(){
System.out.println(this); System.out.println(Outer.this); } }
}

D、成员内部类的修饰符。对于普通的类，可用的修饰符有final、abstract、strictfp、public和默认的包访问。但是成员内部类更像一个成员变量和方法。可用的修饰符有：final、abstract、public、private、protected、strictfp和static。一旦用static修饰内部类，它就变成静态内部类了。

3、方法内部类：顾名思义，把类放在方法内。
class Outer { public void doSomething(){ class Inner{ public void
seeOuter(){ } } }
}

A、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

B、方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。下面是完整的例子：
class Outer { public void doSomething(){ final int a =10; class Inner{
public void seeOuter(){ System.out.println(a); } } Inner in = new
Inner(); in.seeOuter(); } public static void main(String[] args) { Outer
out = new Outer(); out.doSomething(); }
}

C、方法内部类的修饰符。与成员内部类不同，方法内部类更像一个局部变量。可以用于修饰方法内部类的只有final和abstract。

D、静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员。

4、匿名内部类：顾名思义，没有名字的内部类。表面上看起来似乎有名字，实际那不是名字。

A、继承式的匿名内部类。
class Car { public void drive(){ System.out.println("Driving a car!"); }
} class Test{ public static void main(String[] args) { Car car = new
Car(){ public void drive(){ System.out.println("Driving another car!"); }
}; car.drive(); } }结果输出了：Driving another
car!
Car引用变量不是引用Car对象，而是Car匿名子类的对象。建立匿名内部类的关键点是重写父类的一个或多个方法。再强调一下，是重写父类的方法，而不是创建新的方法。因为用父类的引用不可能调用父类本身没有的方法！创建新的方法是多余的。简言之，参考多态。B、接口式的匿名内部类。
interface Vehicle { public void drive(); } class Test{ public static
void main(String[] args) { Vehicle v = new Vehicle(){
public void drive(){ System.out.println("Driving a car!"); } };
v.drive(); }
}上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。

C、参数式的匿名内部类。class
Bar{ void doStuff(Foo f){}}interface Foo{ void foo();}class Test{
static void go(){ Bar b = new Bar();
b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); }
});
}}

二、权限修饰符：public、protected、default、private。

修饰符：abstract、static、final。

public 使用对象：最广，类、接口、变量、方法。

protected使用对象：变量、方法 注意：不能修饰类（外部类）。

default 使用对象：类、接口、变量、方法。（即缺省，什么也不写）。

private 使用对象：变量、方法 注意：不能修饰类（外部类）。

abstract使用对象：类、接口、方法。

static 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰 内部类 ）。

final 使用对象：类、变量、方法。

transient：告诉编译器，在类对象序列化的时候，此变量不需要持久保存

volatile：指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理。

native：用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C、C++编写的。

synchronized：修饰方法，多线程的支持。

‘肆’ 在java中一个类的修饰符有哪些

一：访问修饰符：
1.省略访问修饰符
具有默认的访问特性，即具有包访问特性，只能被同一个包中的类使用。
2.public访问修饰符
用于说明类和类的成员的访问权限。这种类叫公有类。在一个文件中只能有一个public类型的类。
例如：Rect和UseImport两个类，分别在两个不同的包中。顺便回顾一下不同类要用import导入。（哎，一直就没记住）
//Rect.java
pacakage my;
public class Rect
{
private int a,b;
public void init(int len,int width)
{
a=len;
b=width;
}
public int area()
{
return a*b;
}
}
//UseImport.java
import.my.*;//导入my 包的所有类
public class UseImport
{
public static void main(string[] args)
{
Rect x=new Rect();
x.init(2,3);
System.out.println("矩形面积为："+x.area());
}
}
3.private
用private修饰的类成员成为私有成员，只能在声明该成员的类中使用，不能在类外使用。一般通过本类中公有方法进行访问。
4.protected
protected修饰的类成员为保护成员，可以被三种类使用，分别是该类本身，该类的所有子类，该类同包的其他类，该类的子类。
5.private protected
私有保护成员。可被两种类使用。分别是：该类本身和该类的所有子类。
二：特征修饰符
1.abstract：抽象
修饰类为抽象类，修饰方法为抽象方法。只要类中有抽象方法，就必须定义为抽象类。抽象方法只能声明，不能实现。但是可以在其子类中对抽象方法进行实现。抽象类中也可以包含非抽象方法。
2.final：最终
修饰的类为终止类，不能有子类。修饰变量为终止变量，只可赋值一次。修饰方法为终止方法，不能在子类中更改。如Socket、ServerSocket等都是final类，防止黑客派生子类进行破坏。同时，final与abstract是相互矛盾的。
3.static：静态
静态成员无需通过对象调用，可以直接通过类名直接调用。
public class RectArea//输出6 和 12
{
public static void main(String[] args)
{
System.out.println(area(2,3));
System.out.println(area(3,4));
}
static void area(int a,int b)

‘伍’ java默认方法的修饰符是什么

默认什么都不加，就是default（不用把default写出来）。
意思就是只能由跟这个类在同一个包中的类来访问，比private限制更少，但比protected限制更多。'
Java访问修饰符包括private，default，protected和public。含义分别表示私有的，默认的，受保护的和公有的访问修饰符。这些访问修饰符既可以修饰类中的属性，又可以修饰类中的方法，而public和default还可以修饰类。在同一个java文件里，公有类有且仅有一个，并且该文件命名为类名.java。
Java访问修饰符就是确定类中属性或方法的访问权限，换句话说，就是这些属性和方法所起的作用范围。
private，私有的访问权限，也是最严格的访问权限，仅只能在设置了该权限的类中访问，利用这个访问权限，表现出封装思想。
default，默认的访问权限，也是可以省略的访问权限，它不仅能在设置了该权限的类中访问，也可以在同一包中的类或子类中访问。
protected，受保护的访问权限，它除了具有default的访问权限外，还可以在不同包中所继承的子类访问。
public，公有的访问权限，也是最宽松的访问权限，不仅可以是同一个类或子类，还是同一个包中的类或子类，又还是不同包中的类或子类，都可以访问。
要想更深入地理解这些访问权限，一方面需要明白各自的作用域，另一方面更是要弄清楚各自所体现出来的编程思想，比方说，prvite表现的封装思想，public表现的面向接口编程的思想等。
在面向对象设计和编程的过程中，归根结底就是类的设计。而要设计出不仅满足当前需求同时也能符合未来需求的类，就很有必要对类中属性和行为设置合适的访问
权限。那些应该为私有的，那些又应该为公有的，还有那些又应该为受保护的等，都应该给予合理的规划和布局，一来保证程序的功能要求，二来要体现程序的扩展
性能，三来要呈现程序友好性质。总之，程序应该更好地服务用户。而访问权限在这样宏伟目标里扮演着重要角色。

‘陆’ java中类修饰符有哪些

java的修饰符有：权限修饰符：public、protected、default、private

修饰符：abstract、static、final

public 使用对象：最广，类、接口、变量、方法

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：可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）

strictfp：（java关键字） 即 strict float point (精确浮点)。（可修饰类、接口、方法）

(6)java修饰符扩展阅读：

java中的类修饰符、成员变量修饰符、方法修饰符。

类修饰符：

public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。

abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。

final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。

friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。

成员变量修饰符：

public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。

private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。

protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。

friendly ，在同一个包中的类可以访问，其他包中的类不能访问。

final，最终修饰符，指定此变量的值不能变。

static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。

transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。

volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。

方法修饰符：

public（公共控制符）

private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）

protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。

final，指定该方法不能被重载。

static，指定不需要实例化就可以激活的一个方法。

synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。

native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

‘柒’ java 三种访问修饰符各如何使用

public 在任何地方都可访问 protected同包之间可以访问非同包子类可以访问 默认友好类:同包可以访问 private本类可以访问
下面是三大修饰符,你也顺便看看吧

如果一个类中如果有抽象方法,那么这个类必须是抽象类 , 抽象类中未必有抽象方法
抽象类抽象方法 抽象类中可以有抽象方法,也可以有实例方法 抽象方法只能声明,不能实现后面用 ; 结尾
抽象类的子类如果不希望成为抽象类,那么它就必须去实现父类中所有的抽象方法
抽象类允许定义构造方法
抽象类 只能声明引用 , 不能创建对象
抽象方法不能与static 一起使用 , abstract 类中的方法必须在子类中重写 ,并实现多态
Static 只能继承并重写父类中方法 , 但是不能实现多态 .
抽象方法不能与final 一起使用 , final 修饰的方法不能够在子类中覆盖,而抽象方法是必须要求要在子类中覆盖的.
抽象类不能与private一起使用,抽象类中的方法都必须要在子类中重写后实现,而private修饰的方法不能继承,更谈不上重写覆盖
Static

静态的 . 可修饰 : 方法, 成员变量(属性)
静态属性全类共有,由类名调用
静态方法中只能访问非静态的成员(属性+方法);
静态方法可以被覆盖,但是没有多态

静态初始化代码块
在类加载的时候,执行一次

类加载: 1 . 需要的话,先加载父类(可能父类已经加载过 ,这时候就可以不用加载父类了)
2 . 为静态属性分配空间并初始化
3 . 按顺序执行静态初始化代码块
Final

可修饰: 变量(局部变量和成员变量) : 赋值后不能再发生改变
方法 : final 修饰后的方法不能被覆盖 ,但可以继承
类 : final类不能被子类继承
Final修饰属性时候 , 属性此时没有默认值. 此时可以初始化属性值,或者构造方法中赋值
一般情况下常量为 public static , 常量名全部大写

这是我学习时候的笔记,希望对你有所帮助

‘捌’ java中有几种修饰符

java中的修饰符分为类修饰符，字段修饰符，方法修饰符。根据功能的不同，主要分为以下五种。

1、权限访问修饰符

public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。

(8)java修饰符扩展阅读：

修饰符的特点：

static是一个修饰符，用于修饰成员(成员变量和成员函数)

静态成员随着类的加载而加载。静态成员优先于对象存在。静态成员被所有对象所共享静态成员多了一个中调用方式，可以被类名直接调用。

使用的注意事项：

静态方法只能访问静态成员, 非静态方法既可以访问静态又可以访问非静态。静态方法中不可以定义this，super关键字。因为this代表是对象。而静态存在时，有可能没有对象。所以静态方法运行时，this是没有任何对象代表的。

简单说，先进内存的数据不可以访问后进内存的数据，可是后进内存数据可以访问先进内存的数据。主函数是静态的。

‘玖’ java 的访问修饰符是什么

Java中的访问修饰符

Java面向对象的基本思想之一是封装细节并且公开接口。Java语言采用访问控制修饰符来控制类及类的方法和变量的访问权限，从而向使用者暴露接口，但隐藏实现细节。访问控制分为四种级别：

（1）public： 用public修饰的类、类属变量及方法，包内及包外的任何类（包括子类和普通类）均可以访问；

（2）protected： 用protected修饰的类、类属变量及方法，包内的任何类及包外那些继承了该类的子类才能访问（此处稍后解释），protected重点突出继承；

（3）default： 如果一个类、类属变量及方法没有用任何修饰符（即没有用public、protected及private中任何一种修饰），则其访问权限为default（默认访问权限）。默

认访问权限的类、类属变量及方法，包内的任何类（包括继承了此类的子类）都可以访问它，而对于包外的任何类都不能访问它（包括包外继承了此类的子类）。default重点突出包；

（4）private： 用private修饰的类、类属变量及方法，只有本类可以访问，而包内包外的任何类均不能访问它。

网上一些资料及一些书上用表格对java访问修饰符做了清楚的总结，如下表所示：

重要总结：通过上面的分析，我们可以看到：

1.public、private和protected对我们来说没有任何异议。

2. 顶层类只能用public访问修饰符和default（默认）访问修饰符修饰，其中用默认修饰符修饰的类（及没有任何修饰符的类，如class B{}）不能被其他包中的类继承，这也说明了default（默认）访问修饰符突出的是包权限

3. protected：本人做了一次实验，发现在不同包的子类中，new一个父类对象，并用该父类对象去访问父类中的用protected修饰的类属变量和方法时不能访问，而new一个子类对象时，子类对象可以访问（说明protected修饰的类可以被其他包中的类继承）。也可以在子类重写父类的方法中使用super关键字调用。这岂不是和上面表格中的总结（红色对勾）冲突了？本人也是百思不得其解。最后在网上找到了一个相对比较认可的解释，如下：

protected修饰符的修饰的成员变量和方法也称为受保护的成员变量和方法， 受保护的成员变量和方法可以在本类或同一个包中的其它类（包括子类）中通过类的实例进行访问，也可以被同一个包中的类或不同包中的类继承，但是不能在不同包中的其它类（包括子类）中通过类的实例进行访问。

4. 如果一个类使用public修饰，那该类的类名必须与他所在的源文件名相同。一个.java源文件中有且只有一个public类，顶层类只能用public和默认修饰符（即无修饰符）修饰；

5.final修饰的类不能被继承，没有子类。

6.abstract修饰的类不能被实例化，必须被子类继承。类只要有一个抽象方法就必定是抽象类，但抽象类不一定要有抽象方法。

最终总结，就一句话：protected修饰符所修饰的类（这句话中指父类）属成员变量和方法，只可以被子类访问，而不管子类是不是和父类位于同一个包中。default修饰符所修饰的类属成员变量和方法，只可被同一个包中的其他类访问，而不管其他类是不是该类的子类。protected属于子类限制修饰符，而default属于包限制修饰符。

‘拾’ java中修饰符是什么用来干什么的

public 是访问修饰符 就是访问级别的设置

Public
所有包所有地方都可以访问

Protected
同包以及子类可以访问

Friendly(default)
同包可以访问

Private
除了当前类任何地方都不可以访问

static 修饰的话就是静态块、只会执行一次