java 关联接口注释 java中接口的关键字

1.接口(interface):接口的地位等同于class,接口中所有的方法都是抽象方法,在接口定义方法的时候，通常可以将abstract省略

举例:

Public interface InterfaceTest

{

Public abstract voidoutput();//接口方法不能带有主体，接口内部的方法都是抽象方法，因为接口明确规定了其是抽象方法所以可以省略abstract

}

2.接口是一种特殊的抽象类，是一种严格的抽象类，抽象类里面既可以有抽象方法，也可以有具体方法。但是接口里面不能有具体的方法，只能具有抽象方法。

3.类可以实现接口。接口实现的关键字是implements表示,代表某个类实现了某个接口

举例:

Public class Test3
{
Public static voidmain(String[] args)
{
MyClass myClass =new MyClass();
}
}
Interface MyInterface
{
Public voidoutput();
}
Class MyClass implements MyInterface
{
Public void output()
{
System.out.println(“output”);
}
}

4.一个类实现了某个接口,那么该类必须要实现接口中声明的所有方法,如果该类是个抽象类,那么就无需实现接口中的方法,抽象类的话,只需要实现部分方法就可以了,某一个类可以同时继承一个类且实现多个接口

5.Java是单继承的,一个类只有一个父类，但是可以实现多个接口

Public class Test3
{
Public static voidmain(String[] args)
{
MyClass myClass =new MyClass();
myClass.output();
myClass.output2();
myClass.output3();
///强制类型转化的时候向上转化不需要加括号，向下必须要加括号，强制转换
BB bb = new BB();
AA aa = bb;
bb.output();
///向下类型转换
AA bb = new BB();
BB b = (BB)aa;
bb.output();
}
}
Interface MyInterface
{
Public voidoutput();
}
Interface MyInterface2
{
Public void output2();
}
Class MyParent
{
Public void output3()
{
System.out.println(“output3”);
}
}
//此类不是抽象类，那要实现接口里的所有的方法
Class MyClass extends MyParent  implements MyInterface, MyInterface2
{
Public void output()
{
System.out.println(“output”);
}
Public void output2()
{
System.out.println(“output2”);
}
}
6.
Public class Test4
{
Publicstatic void main(String[] args)
{
}
}
Interface AA
{
Public voidoutput();
}
Class BB implements AA
{
Publicvoid output()
{
System.out.println(“BB”);
}
}

7.多态；所谓多态,就是父类型的引用指向子类型的对象或者接口类型的引用可以指向实现该接口实例。关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方式完全一样。

8.Static关键字:static可以用在属性,方法和类上【但是使用了static关键字的类是一个特殊的类】

Public class StaticTest
{
Publicstatic void main(String[] args)
{
MyStatic myStatic  =  new       MyStatic();
MyStatic myStatic2 =  new MyStatic();
myStatic.a= 10;
System.out.println(myStatic2.a);

///类名.属性名类名.方法名推荐使用类的名字来访问

MyStatic myStatic = new MyStatic();
MyStatic.a= 10;
System.out.println(myStatic.a);
}
}
Class MyStatic
{
Int a ;
}

9使用Static关键字来修饰方法的时候,static修饰的方法是静态方法,对于静态方法来说可以使用类名.方法名来进行访问

Public class StaticTest2
{
Publicstatic void main(String[] args)
{
//    MyStatic2 test = new MyStatic2();
//            Test.output();
MyStatic2.output();
}
}
Class MyStatic2
{
Publicvoid output()
{
System.out.println(“output”);
}
}

10.

Public class StaticTest3
{
Publicstatic void main(String[] args)
{
Mm = new N();
m.output();
}
}
Class M
{
Publicstatic void output()
{
System.out.println(“M”);
}
}
Class N extends M
{
@ovvride ///写了这句话编译就不能通过所以子类是不能重写父类的静态方法的
Public static void output()  ///这里是子类把父类的方法隐藏了没有重写
{
System.out.println(“N”);
}
}

课后作业：查看java的帮助教程官网上查找java static override

11.静态方法只能继承,不能重写(override)

12.final关键字:final可以修饰类,方法和类：当一个类被final修饰时,表示该类是一个终态类,不能被继承

Public class FinalTest
{
Publicstatic void main(String[] args)
{
F f= new F();
}
}
Final class E //该类不能被继承
{
}
Class F extends E
{
H h = newH();
h.output();
}
Public class FinalTest2
{
}
Class G
{
Public void output() ///若是此处代码这么写就有问题public final void output()因为要实现多态机制的话子类要重写父类的方法，但是加了final的方法是不能被重写的，所以此处编译就会出错的
{
System.out.println(“G”);
}
}
Class H extends G
{
Publicvoid output()
{
System.out.println(“H”);
}
}
13.final修饰:当一个方法被final修饰，表示这个方法是终态方法，不能被override，不能被overload
14.final属性；当一个属性被final修饰的时候,则这个属性是一个常量，不能被改写
Public class finalTest3
{
Public static voidmain(String[] args)
{
People people = new People();
//People.age = 20;
///       People.address = new Address();//无法为最终变量指定错误
People.address.name = “shanghai”;///编译可以通过
}
}
Class People
{
///  int age=10; //若此处改成final int age=10 ;则这个值是不能被改变的不能被赋新值
FinalAddress address = new Address(); ///引用类型加一个final表示该对象所指向的地址不能改变
}
Class Address
{
String name = “beijing”;
}
当一个final修饰的原生数据类型时,表示该原生数据类型的值不会发生变化(比如说不能从10变到20)如果final修饰一个引用类型的时,表示该引用类型不能再指向其他对象了,但该引用所指向的对象的内容是可以发生改变的
Static和Final使用注意事项和陷阱
15.对于final类型的成员变量,一般来说有两种赋初始值的方式;
A)在声明final类型的成员变量的时候就赋值
b)在声明final类型的成员变量时不赋初值,但在类的所有构造方法中都为其赋初值
Public class FinalTest4
{
///Finalint a ;///对于final变量来说一开始一定要赋初始值
Finalint  a ;
PublicFinalTest4()
{
a = 0 ;
}
}
16.放在类本身里面用static静态代码块{而且静态代码区先执行，然后再执行构造方法}
先是将static代码区加载到虚拟机上，构造方法执行的时候是new对象的时候才执行的，当在new对象的时候静态代码块还是执行一次
Publicclass StaticTest4
{
Public static void main(String[] args)
{
P p = new P();
}
}
ClassP
｛
Static
{
System.out.println(“static block”);
}
Public P()
{
System.out.println(“P constructor”);
}
｝
ClassQ extends P
{
Static
{
System.out.println(“Q static block”);
}
Public Q()
{
System.out.println(“Q constructor”);
}
}
ClassS extends Q
{
Static
{
System.out.println(“S static block”);
}
Pulic void S()
{
System.out.println(“S constrator”);
}
}
///测试代码:查看输出结果
{1}New S();
{2}New S(); New S();
17.类的静态代码块只会执行一次,是在类被加载的时候执行的，因为每加载一次，所以静态代码也只会被执行一次,而构造方法则不然，每次生成一个对象的时候都会调用类的构造方法,所以new一次就会调用构造方法一次
18.如果继承体系中既有构造方法，又有静态代码块，那么首先先执行最顶层的类的静态代码块，一直执行到最底层的静态代码块，然后再去执行最顶层类的构造方法，一直执行到最底层的构造方法，注意；静态代码块只执行一次。
18例子:
Public class StaticTest5
{
Public static void main(String[] args)
{
W.change();
    }
}
Class W
{
Static  Int  a = 10 ;
Public static void change() //不能在一个静态的方法里访问一个非静态的成员变量
{
a++;
}

}

19不能在静态方法中访问非静态的成员变量，可以在静态方法中访问静态的成员变量，可以在非静态方法中访问静态的成员变量。总结；静态的只能访问静态的，非静态的可以访问一切。

20不能在静态方法中使用this关键字