⑴ 在Java中用什么关键字修饰的方法可以直接
在java中用static修饰的方法可以直接用（类名.方法名）的方式访问，因为静态成员变量和方法是在类加载的时候初始化的，而且只初始化一次，是共享的。只与类相关，与对象无关。
⑵ 怎么理解这些个关键字啊，public;private;protect;final;static;const;我感觉这些
public: 公有属性或方法
在子类中可以通过self::var 或self::method 来调用,可以通过parent::method来调用父类中的方法,但不能调用公有属性.
在实例中可以通过$obj->var或self::method 来调用
protected: 受保护类型
在子类中可以通过self::var 或self::method调用,可以通过parent::method来调用父类中的方法
在实例中不能通过$obj->var 来调用 protected类型的方法或属性
private: 私有类型
该类型的属性或方法只能在该类中使用，在该类的实例、子类中、子类的实例中都不能调用私有类型的属性和方法
再来说说final
1.final不能用来修饰成员属性
2.final只能修饰类和方法
作用：被修饰的类不能被子类所继承；被修饰的方法不能被子类的方法覆盖。
然后来说说static
1.static用来修饰成员属性和成员方法，但不能用来修饰类
2.用static修饰的成员属性可以被同一个类的所有对象共享
3.静态的数据是存在 内存中的 数据段中（初始化静态段）
4.静态的数据是在类在第一次加载时，分配到内存中的
5.什么是类被加载？只要在程序中使用到这个类（有这个类名出现）
6.静态的成员属性都要用类名去访问，不用创建对象，不用对象去访问；在类里边可以用self代表本类（$this）
7.静态方法，不能访问非静态的成员属性（但是，在非静态方法却能访问静态的成员属性），非静态的成员属性，必须用对象访问，在内部访问非静态成员属性，用$this.
8.如果你确定一个方法中不需使用到非静态的成员属性，则可以将这个方法声明为静态方法，不需实例化对象，就可以访问
最后来说说const
1.它只能用来修饰成员属性
2.在类中声明常量必须使用const
3.访问方式和访问静态成员属性一样（类外使用 类名::成员属性，类里边则使用self::成员属性）
4.常量一定要在声明的时候就给初始值
⑶ java接口，抽象类，ststic关键字，修饰符得运用。求全解。
Abstract(抽象)可以修饰类、方法
如果将一个类设置为abstract，则此类必须被继承使用。此类不可生成对象，必须被继承使用。
Abstract可以将子类的共性最大限度的抽取出来，放在父类中，以提高程序的简洁性。
Abstract虽然不能生成对象，但是可以声明，作为编译时类型，但不能作为运行时类型。
Final和abstract永远不会同时出现。
Abstract和static不能放在一起，否则便会出现错误。（这是因为static不可被覆盖，而abstract为了生效必须被覆盖。）
当abstract用于修饰方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。
JAVA的核心概念：接口（interface）
接口与类属于同一层次，实际上，接口是一种特殊的抽象类。
如:
interface IA{
}
private void print(){}；此语句表示方法的空实现。
Abstract void print()； 此语句表示方法的抽象，无实现。
public interface：公开接口
与类相似，一个文件只能有一个public接口，且与文件名相同。
在一个文件中不可同时定义一个public接口和一个public类。
一个接口中，所有方法为公开、抽象方法；所有的属性都是公开、静态、常量。
一个类实现一个接口的格式：
class IAImple implements IA{
};
类必须实现接口中的方法，否则其为抽象类。
接口中可不写public，但在子类中实现接口的过程中public不可省。
① 一个类除继承另外一个类，还可以实现接口；
变相的多继承。
② 一个类只能继承另外一个类，但是它可以实现多个接口，中间用逗，地隔开。
Implements IA,IB
所谓实现一个接口，就是指实现接口中的方法。
③ 接口和接口之间可以定义继承关系，并且接口之间允许实现多继承。
面向对象高级： 修饰符：
static:①可修饰变量（属性）；②可修饰方法；③可修饰代码块。
Static int data语句说明data为类变量，为一个类的共享变量，属于整个类。
Int data为实例变量。
例：
static int data;
m1.data=0;
m1.data++的结果为1,此时m2.data的结果也为1。
Static定义的是一块为整个类共有的一块存储区域，其发生变化时访问到的数据都时经过变化的。
其变量可以通过类名去访问：类名.变量名。与通过访问对象的编译时类型访问类变量为等价的。
Public static void printData(){}
表明此类方法为类方法（静态方法）
静态方法不需要有对象，可以使用类名调用。
静态方法中不允许访问类的非静态成员，包括成员的变量和方法，因为此时是通过类调用的，没有对象的概念。This.data是不可用的。
一般情况下，主方法是静态方法，所以可调用静态方法，主方法为静态方法是因为它是整个软件系统的入口，而进入入口时系统中没有任何对象，只能使用类调用。
覆盖不适用于静态方法。
静态方法不可被覆盖。（允许在子类中定义同名静态方法，但是没有多态，严格的讲，方法间没有多态就不能称为覆盖）
当static修饰代码块时（注：此代码块要在此类的任何一个方法之外），那么这个代码块在代码被装载进虚拟机生成对象的时候可被装载一次，以后再也不执行了。
一般静态代码块被用来初始化静态成员。
⑷ 关于java的static我很晕
首先你得理解什么是类属性和对象属性，加static修饰的属性是类属性的充分必要条件，因此不加static的属性就是对象属性。
那区别是什么呢？
静态变量分配空间是在程序开始运行的时候自动完成的，因此你可以使用类名直接访问，如：Math.PI。
非静态变量（对象变量）是在对象初始化以后才分配空间，以后才能使用。如：Testt=newT()；t.shuxing;这个之后shuxing就有内存空间啦，你就可以访问了。
给你说说图片上的错误你就明白啦
1.22行错误时因为主方法里面访问的a是对象属性，此时a还没有分配空间，因此会有错误，只有new之后才能用对象访问它。但是23行就不会有错误啦，因为b是static的，此时已经有了内存空间
2.25行错误是因为在f_4()里面访问了非静态属相a，此时a还是没有分配空间，所以就出错啦，这也是楼主遇到的问题。
3.即使方法里面都是静态属性，也不可以直接调用，如：24行所示。这是Java的语法规定，可能是为了简化语法才这样做的。
⑸ java类中的方法用那些修饰符修饰可以直接使用类名调用
static，静态函数可以直接用类名调用
⑹ java 问题
静态的方法可以直接使用类名.方法名的方式直接调用，但是非静态的方法必须要先有这个类的对象才可以调用，即dalek d=new dalek();然后d.speak();有时候某些方法我们希望不需要对象就可以调用时，就使用静态方法，比如工具类，我们在使用工具类的时候，通常将里面的方法写成静态的，那么调用这些方法的时候就不需要先创建工具类对象了；静态方法在加载到内存中也与非静态的方法不一样，静态方法在类加载时，就一起加载到内存的静态方法区中，而非静态的方法，是在拥有对象调用以后才加进堆内存中。
⑺ java 类中的public属性修饰
我觉得你想知道的并不仅仅是public修饰符的问题,对于继承也很模糊可能,继承的时候为什么可以引用被继承类或者说基础类中的public方法?难道真的是只要继承就可以,而另一个非继承的类想用的时候就要先创建对象（在这里不讨论方法是static情况）？其实继承的时候是一样的,只不过这个过程被隐藏掉了,一旦继承,必然会在子类中创建一个父类的对象做为子类的成员,必然会调用父类的构造函数,这时你才可以调用super.method()的,这在《think in java》第6章有详细的解释和代码示例可以看一下。
⑻ 在Java中用什么关键字修饰的方法可以直接通过类名来调用
答应该是:A.static B.final C.private D.void
⑼ 在java中，所有的属性和方法只能通过对象.来调用
不对，静态的属性可以直接通过类调用
⑽ Java中的关键字static和final的作用
final
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
1、final类
final类不能被继承，因此final类的成员方法没有机会被覆盖
，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2、final方法
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
例如：
publicclassTest1{
publicstaticvoidmain(String[]args){
//TODO自动生成方法存根
}
publicvoidf1(){
System.out.println("f1");
}
//无法被子类覆盖的方法
publicfinalvoidf2(){
System.out.println("f2");
}
publicvoidf3(){
System.out.println("f3");
}
privatevoidf4(){
System.out.println("f4");
}
}
publicclassTest2extendsTest1{
publicvoidf1(){
System.out.println("Test1父类方法f1被覆盖!");
}
publicstaticvoidmain(String[]args){
Test2t=newTest2();
t.f1();
t.f2();//调用从父类继承过来的final方法
t.f3();//调用从父类继承过来的方法
//t.f4();//调用失败，无法从父类继承获得
}
}3、final变量（常量）
用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
packageorg.leimin;
publicclassTest3{
privatefinalStringS="final实例变量S";
privatefinalintA=100;
publicfinalintB=90;
publicstaticfinalintC=80;
privatestaticfinalintD=70;
publicfinalintE;//final空白,必须在初始化对象的时候赋初值
publicTest3(intx){
E=x;
}
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
Test3t=newTest3(2);
//t.A=101;//出错,final变量的值一旦给定就无法改变
//t.B=91;//出错,final变量的值一旦给定就无法改变
//t.C=81;//出错,final变量的值一旦给定就无法改变
//t.D=71;//出错,final变量的值一旦给定就无法改变
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C);//不推荐用对象方式访问静态字段
System.out.println(t.D);//不推荐用对象方式访问静态字段
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E);//出错,因为E为final空白,依据不同对象值有所不同.
System.out.println(t.E);
Test3t1=newTest3(3);
System.out.println(t1.E);//final空白变量E依据对象的不同而不同
}
privatevoidtest(){
System.out.println(newTest3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
publicvoidtest2(){
finalinta;//final空白,在需要的时候才赋值
finalintb=4;//局部常量--final用于局部变量的情形
finalintc;//final空白,一直没有给赋值.
a=3;
//a=4;出错,已经给赋过值了.
//b=2;出错,已经给赋过值了.
}
}
4、final参数
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
publicclassTest4{
publicstaticvoidmain(String[]args){
newTest4().f1(2);
}
publicvoidf1(finalinti){
//i++;//i是final类型的,值不允许改变的.
System.out.print(i);
}
}
二、static
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。
static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名
用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。
1、static变量
按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
2、静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
3、static代码块
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：
publicclassTest5{
privatestaticinta;
privateintb;
static{
Test5.a=3;
System.out.println(a);
Test5t=newTest5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
publicstaticvoidmain(String[]args){
//TODO自动生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
publicvoidf(){
System.out.println("hhahhahah");
}
}
运行结果：
3
hhahhahah
1000
4
5利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。
4、static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。
特别要注意一个问题：
对于被static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象，这一点在编程中用到很多。
也许说了这么多，反倒把你搞晕了，还是看个例子吧：
publicclassTestStaticFinal{
="aaa";
=null;
privatefinalStringstrFinalVar=null;
=0;
=newInteger(8);
privatestaticfinalArrayList<String>alStaticFinalVar=newArrayList<String>();
privatevoidtest(){
System.out.println("-------------值处理前----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
//strStaticFinalVar="哈哈哈哈";//错误，final表示终态,不可以改变变量本身.
strStaticVar="哈哈哈哈";//正确，static表示类变量,值可以改变.
//strFinalVar="呵呵呵呵";//错误,final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//intStaticFinalVar=2;//错误,final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//integerStaticFinalVar=newInteger(8);//错误,final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
alStaticFinalVar.add("aaa");//正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
alStaticFinalVar.add("bbb");//正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
System.out.println("-------------值处理后----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
}
publicstaticvoidmain(Stringargs[]){
newTestStaticFinal().test();
}
}看了上面这个例子，就清楚很多了，但必须明白：通过static final修饰的容器类型变量中所“装”的对象是可改变的。这是和一般基本类型和类类型变量差别很大的地方。