java中接口的相关知识点

abstract class Person{
private String name;
public String getName(){
return this.name;
} 
public void setName(String name){
this.name=name;
}
public abstract void getPersonInfo();
}
class Student extends Person{
public void getPersonInfo(){
System.out.println("I am a student");
}
}
public class Jiekou{
public static void main(String[] args){
          Person per=new Student();
          per.getPersonInfo();
} 

}
abstract class Person{
private String name;
public Person(){
System.out.println("**************");
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
public abstract void getPersonInfo();
}
class Student extends Person{
public Student(){
System.out.println("#########");
}
public void getPersonInfo(){


}
}
public class Jiekou{
 public static void main(String[] args) {
new Student();
}
}




方法的覆写：如果子类定义了与父类相同的方法或属性的时候，这种操作就叫做覆写。
1.明确你当前使用的类是通过那个类new的。
2.当调用某个方法时，如果该方法已经被子类覆写了，那么调用的一定是被覆写过的方法。
3.被覆写不能比父类有更为严格的访问权限。
4.如果现在父类使用了private定义，那么就表示该方法只能被父亲使用，子类无法使用。
class Person{
public void print(){
System.out.println("1.Person类的使用方法");
}
}
class Student extends Person{
public void print(){
System.out.println("2.Student类的使用方法");
}
}
public class Jiekou{
public static void main (String[] args){
new Student().print();
}
}
向上强转
class Person{
public void print(){
System.out.println("1.我是爸爸");
}
}


class Student extends Person{
public void print(){
System.out.println("2.我是儿子");
}
public void fun(){
System.out.println("只有儿子有");
}
}
public class Jiekou{
public static void main(String[] args){
Person per=new Student();//向上强转
per.print();
Student stu=(Student)per;
stu.fun();
}
}


抽象类：只是在普通类的基础上扩充了一些抽象方法，抽象方法指的是只声明而未实现的方法（即没有方法体），因此抽象类不能产生实例化对象。
1.所有的抽象类必须有子类。
2.抽象类的子类必须覆写抽象类的所有抽象方法，但子类不是抽象类，权限都尽量用public.
3.抽象类的对象可以通过对象多态性利用子类为其实例化。
4.private与abstract不能同时使用。
5.抽象类中也允许提供构造法方法，并且子类也照样遵循对象实例化流程。实例化子类时一定要先调用父类构造方法。
6.抽象类一定不能使用final声明，因为使用final声明的类不允许有子类；而抽象类必须有子类；相应的抽象方法也不能使用private定义，因为抽象方法必须
被覆写。
abstract class Person{
private String name;
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
public abstract void getPersonInfo();//抽象方法
}
class Student extends Person{
public void getPersonInfo(){
System.out.println("I am a student");
}
}
public class Jiekou{
public static void main(String[] args){
Person per=new Student();
per.getPersonInfo();
}
}
abstract class Person{
private String name;
public Person(){
System.out.println("********");
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
public abstract void getPersonInfo();
}
class Student extends Person{
public Student(){
System.out.println("##########");
}
public void getPersonInfo(){


}
}
public class Jiekou{
public static void main(String[] args){
new Student();
}
}
如果父类没有无参构造，那么子类构造必须使用super明确指出使用了父类哪个构造方法。
abstract class A{
public A(){//3.调用父类构造
this.print();//4.调用被子类覆写的方法
}
public abstract void print();
}
class B extends A{
private int num=100;
public B(int num){//2。调用子类实例化对象
super();//3.隐含一行语句，实际要先调用父类构造
this.num=num;
}
public void print(){//5.此时子类对象的属性还没有被初始化
System.out.println(this.num);//对应其数据的默认值
}
}
public class Jiekou{
 public static void main(String[] args) {


new B(30);//1.实例化子类对象
}
}
1.接口：一个抽象方法和全局常量的集合。加I
2.子类使用implements关键字来实现接口，可以使用接口来实现多继承的概念。
5.一个抽象类可以使用implements实现多个接口，但是接口不能继承抽象类。
3.对于接口的子类，它不是抽象类，它必须覆写接口的全部抽象方法，随后可以利用子类的向上转型通过实例化子类来得到接口的实例化对像。
4.真正new的子类才有意义。
6.一个接口可以使用extends继承多个父接口。
7.接口可以定义一系列的内部结构，包括：内部普通类，内部接口。其中，使用static定义的内部接口就相当于一个外部接口。
8.当一个子类既需要实现接口又需要继承抽象类的时候，请先使用extends继承一个抽象类，而后使用implement实现多个接口。
interface IMessage{
public static final String MSG="I am a biter";
public abstract void print();
}  
interface INews{
public abstract String getNews();    
}
class MessagesImpl implements IMessage,INews{
public void print(){
System.out.println(IMessage.MSG);
}
public String getNews(){
return IMessage.MSG;
}
}
public class Jiekou{
public static void main(String[] args){
IMessage m=new MessagesImpl();
m.print();
INews n=(INews) m;
System.out.println(n.getNews());
}
}
子类继承抽象类和实现接口。
interface IMessage{
public void print();
}
abstract class News{
public abstract void getNews();
}
class MessageImpl extends News implements IMessage{
public void print(){
System.out.println("I am a biter");
}
public void getNews(){
System.out.println("I am News");
}
}
public class Jiekou{
public static void main(String[] args){
IMessage m=new MessageImpl();
m.print();
News news=(News) m;
news.getNews();
}
}
抽象类实现接口
interface IMessage{
public void print();
}
abstract class News implements IMessage{//News为抽象类，可以不实现Imessage中的抽象方法
public abstract void getNews();
}
class MessageImpl extends News{
public void print(){
System.out.println("I am a biter");
}
public void getNews(){
System.out.println("I am News");
}


}
public class Jiekou{
public static void main(String[] args){
IMessage m=new MessageImpl();
m.print();
//MessageImpl是抽象类和接口的共同子类
News news=(News)m;
news.getNews();
}
继承：子类（派生类） 父类（超类）Super Class
子类对象在进行实例化前一定会首先实例化父类对象。默认父类的构造方法后再调用子类构造方法进行子类对象初始化
class Person{
public Person(){
System.out.println("******Person类对象产生***");
}
}//没有任何一条语句调用父类构造方法。因此，子类对象实例化之前一定先实例化父类对象
class Student extends Person{
public Student(){
super();//此语句在无参时写与不写一样
System.out.println("****Student类对象产生");
}
}
public class Jiekou{
public static void main(String[] args){
new Student();
}
}
实际在子类的构造方法中，相当于隐含了一个语句super();系统调用父类的无参构造
同时需要注意的是，如果父类里没有提供无参构造，那么这个时候就必须使用super()明确指明你要调用的父类构造方法