java基础学习总结——通达信 接口 下单,接口
通达信 接口 下单,接口的概念
JAVA是只支持单继承的，但现实之中存在多重继承这种现象，如“金丝猴是一种动物”，金丝猴从动物这个类继承，同时“金丝猴是一种值钱的东西”，金丝猴从“值钱的东西”这个类继承，同时“金丝猴是一种应该受到保护的东西”，金丝猴从“应该受到保护的东西”这个类继承。这样金丝猴可以同时从“动物类”、“值钱的东西类”、“应该受到保护的东西”这三个类继承，但由于JAVA只支持单继承，因此金丝猴只能从这三个类中的一个来继承，不能同时继承这三个类。因此为了封装现实生活中存在的多重继承现象，为了实现多继承，可以把其中的两个类封装成通达信 接口 下单,接口。使用通达信 接口 下单,接口可以帮助我们实现多重继承。
通达信 接口 下单,接口的本质——通达信 接口 下单,接口是一种特殊的抽象类，这种抽象类里面只包含常量和方法的定义，而没有变量和方法的实现。
抽象类所具有的一些东西通达信 接口 下单,接口可以具有，假如一个抽象类里面所有的方法全都是抽象的，没有任何一个方法需要这个抽象类去实现，并且这个抽象类里面所有的变量都是静态(stati变量，都是不能改变(fina的变量，这时可以把这样的抽象类定义为一个通达信 接口 下单,接口(interfac。把一个类定义成一个通达信 接口 下单,接口的格式是把声明类的关键字class用声明通达信 接口 下单,接口的关键字interface替换掉即可。
1 /**
2 * java中定义通达信 接口 下单,接口
3 */
4 public interface JavaInterfaces {
5
6 }通达信 接口 下单,接口(interfac是一种特殊的抽象类，在这种抽象类里面，所有的方法都是抽象方法，并且这个抽象类的属性都是声明成“publicstaticfinal类型属性名”这样的，默认也是声明成“publicstaticfinal”即里面的成员变量都是公共的、静态的，不能改变的。因此在通达信 接口 下单,接口里面声明常量的时候，可以写成“publicstaticfinal类型常量名=value(值)”这样的形式，也可以直接写成“类型常量名=value(值)”如：“publicstaticfinalintid=10”可以直接写成“intid=10”这样的形式，因为在通达信 接口 下单,接口里面默认的属性声明都是“publicstaticfinal”的，因此“publicstaticfinal”可以省略不写。在通达信 接口 下单,接口里面声明的抽象方法可以不写abstract关键字来标识，因为通达信 接口 下单,接口里面所有的方法都是抽象的，因此这个“abstract”关键字默认都是省略掉的，如在一个通达信 接口 下单,接口里面声明这样的三个方法：“publicvoidstart()”、“publicvoidrun()”、“publicvoidstop()”这三个方法前面都没有使用abstract关键字来标识，可它们就是抽象方法，因为在通达信 接口 下单,接口里面的声明的方法都是抽象方法，因此在通达信 接口 下单,接口里面的抽象方法都会把abstract关键字省略掉，因为默认声明的方法都是抽象的，所以就没有必要再写“abstract”字了，这一点与在抽象类里面声明抽象方法时有所区别，在抽象类里面声明抽象方法是一定要使用“abstract”关键字的，而在通达信 接口 下单,接口里面声明抽象方法可以省略掉“abstract”。注意：在通达信 接口 下单,接口里面声明的抽象方法默认是“public(公共的)”的，也只能是“public(公共的)”之所以要这样声明是为了修正C++里面多重继承的时候容易出现问题的地方，C++的多继承容易出现问题，问题在于多继承的多个父类之间如果他们有相同的成员变量的时候，这个引用起来会相当地麻烦，并且运行的时候会产生各种各样的问题。JAVA为了修正这个问题，把通达信 接口 下单,接口里面所有的成员变量全都改成staticfinal，成员变量是static类型，那么这个成员变量就是属于整个类里面的，而不是专属于某个对象。对于多重继承来说，在一个子类对象里面实际上包含有多个父类对象，而对于单继承来说，子类对象里面就只有一个父类对象。多继承子类对象就有多个父类对象，而这些父类对象之间可能又会存在有重复的成员变量，这就非常容易出现问题，因此在JAVA里面避免了这种问题的出现，采用了通达信 接口 下单,接口这种方式来实现多继承。作为通达信 接口 下单,接口来说，一个类可以从通达信 接口 下单,接口继承，这也是多继承，通达信 接口 下单,接口里面的成员变量不专属于某个对象，都是静态的成员变量，是属于整个类的，因此一个类去实现多个通达信 接口 下单,接口也是无所谓的，不会存在对象之间互相冲突的问题。实现多个通达信 接口 下单,接口，也就实现了多重继承，而且又避免了多重继承容易出现问题的地方，这就是用通达信 接口 下单,接口实现多重继承的好处。
通达信 接口 下单,接口特性
通达信 接口 下单,接口举例
package javastudy.summary;
/**
* 这里定义了通达信 接口 下单,接口：Painter。 在Painter通达信 接口 下单,接口里面定义了paint()和eat()这两个抽象方法。
*
* @author gacl
*
*/
interface Painter {
public void eat();
public void paint();
}
/**
* 这里定义了两个通达信 接口 下单,接口：Singer 在Singer通达信 接口 下单,接口里面定义了sing()和sleep()这两个抽象方法。
*
* @author gacl
*
*/
interface Singer {
public void sing();
public void sleep();
}
/**
* 类Student实现了Singer这个通达信 接口 下单,接口
*
* @author gacl
*
*/
class Student implements Singer {
private String name;
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 实现通达信 接口 下单,接口中定义的sing方法
*/
@Override
public void sing() {
System.out.println('student is singing');
}
/**
* 实现通达信 接口 下单,接口中定义的sleep方法
*/
@Override
public void sleep() {
System.out.println('student is sleeping');
}
public void study() {
System.out.println('Studying...');
}
}
/**
* Teacher这个类实现了两个通达信 接口 下单,接口：Singer和Painter。 这里Teacher这个类通过实现两个不相关的通达信 接口 下单,接口而实现了多重继承。
*
* @author gacl
*
*/
class Teacher implements Singer, Painter {
private String name;
public Teacher(String name) {
this.name = name;
}
/**
* 在Teacher类里面重写了这两个通达信 接口 下单,接口里面的抽象方法，
* 通过重写抽象方法实现了这两个通达信 接口 下单,接口里面的抽象方法。
*/
@Override
public void eat() {
System.out.println('teacher is eating');
}
public String getName() {
return name;
}
@Override
public void paint() {
System.out.println('teacher is painting');
}
public void setName(String name) {
this.name = name;
}
@Override
public void sing() {
System.out.println('teacher is singing');
}
@Override
public void sleep() {
System.out.println('teacher is sleeping');
}
public void teach() {
System.out.println('teaching...');
}
}
public class TestInterfaces {
public static void main(String[] args) {
/**
* 这里定义了一个通达信 接口 下单,接口类型的变量s1
*/
Singer s1 = new Student('le');
s1.sing();
s1.sleep();
Singer s2 = new Teacher('steven');
s2.sing();
s2.sleep();
Painter p1 = (Painter)s2;
p1.paint();
p1.eat();
}
}这里验证了两个规则，“一个类可以实现多个无关的通达信 接口 下单,接口”，Teacher类既实现了Singer通达信 接口 下单,接口，同时也实现了Painter通达信 接口 下单,接口，而Singer通达信 接口 下单,接口和Painter通达信 接口 下单,接口是无关系的两个通达信 接口 下单,接口。“多个无关的类可以实现同一通达信 接口 下单,接口”，Student类和Teacher类都实现了Singer通达信 接口 下单,接口，而Student类和Teacher类并不是关系很密切的两个类，可以说是无关的两个类。
运行结果：
画内存分析体会通达信 接口 下单,接口与实现类之间存在的多态性
首先分析main方法的第一句话
Singers1=newStudent(“le”);
这里首先定义了一个通达信 接口 下单,接口类型的变量s通达信 接口 下单,接口Singer是Student类实现的，即相当于Student类从Singer通达信 接口 下单,接口继承，Singer通达信 接口 下单,接口的本质是一个特殊的抽象类，所以这里Singer通达信 接口 下单,接口就是Student类的父类，因此s1就是父类对象的一个引用，即这里这句话执行完后就是一个父类对象s1的引用指向子类对象Student。所以内存里面的布局应该是这样：栈空间里面有一个父类对象的引用s1,堆空间里面new出了一个Student对象，创造这个Student对象的时候调用了Student类的构造方法Student(Stringnam，其定义如下：
}
通过调用构造方法使得这个Student对象有了一个自己的名字“le”，因此堆内存里面的Student对象的name属性值为“le”。
这个Student对象能够访问位于代码区里面的sleep()方法和sing()方法，因为Student类从父类Sing继承而来，因此自然可以访问到这两个方法，除此之外，还能访问Student类里面自定义的Study()方法。因此代码区里面存放着这三个方法等待着Student类的对象去访问，也就是去调用。一个正常的Student可以直接调用这三个方法。那么怎么找得到位于代码区的这三个方法呢？Student对象里面存在着能找得到这个三个方法的函数指针，引用对象通过这个指针的索引指向就能找到代码区里面的这三个方法。
s1是父类对象的索引，但此时s1指向的却是子类对象，即一个父类对象的索引指向了子类对象。这里很不幸的是，由于这个s1是一个父类对象的引用，站在s1的角度上，它就是只把你这个子类对象Student当成是一个Singer，s1只能看到Student对象里面的sing()和sleep这两个方法的方法指针，因此使用这个s1引用对象只能去访问从父类继承下来的sleep()和sing()这两个方法，但由于这两个方法在子类Student里面被重写了，那么现在就是这种情况了，子类Student从父类Singer继承，在子类里面重写了从父类继承下来的sing()和sleep()这两个方法，父类对象的引用指向了子类对象，这三种情况加在一起就使得多态可以存在了，这样调用位于代码区里面的方法时，会根据new出来的实际对象去调用代码区里面的方法，因此这里在s1眼里虽然是把这个new出的Student当成一个Singer，但这个对象实际上就是一个Student，因此使用父类对象的引用s1调用代码区里面的sleep()和sing()方法时，调用的是在子类里面重写过后的sing()和sleep()方法。
接着分析第二句话
Singers2=newTeacher(“steven”);
Teacher这个类实现了Singer通达信 接口 下单,接口和Painter通达信 接口 下单,接口，即相当于从两个父类继承，一个父类是Singer，另一个父类是Painter。
这里的s2也是父类对象Singer的引用，指向的却是子类对象Teacher，因此也是一个父类对象的引用指向子类对象。
创造这个Teacher对象的时候，调用Teacher(Stringnam构造方法，其定义如下：
}
调用构造方法后，Teacher有了自己的名字steven，所以Teacher的name属性值为steven，由于这个Teacher实现了Painter通达信 接口 下单,接口和Singer通达信 接口 下单,接口，因此也继承这两个通达信 接口 下单,接口里面的方法，因此一个正常的Teacher可以访问的方法有：paint()、eat()和sing()、sleep。前面两个方法是从Painter类继承过来的，后面两个方法是从Singer类继承过来的。除了这四个方法外，还有自己定义的Teach()方法。可是很不幸的是，由于s2是一个Singer类对象的引用，因此站在s2的角度来看，它只把Teacher当成是一个普通的Singer，因此它看到的只是Teacher对象里面的sing()和sleep()这两方法，然后要调用时就通过Teacher对象里面的函数指针找到位于代码区的sleep()和sing()这两个方法。别的方法s2是看不到的，因此也调用不了。
这里把s2强制转换成Painter，s2对象实际是指向Teacher的，把s2强制转换成Painter以后，就可以把Teacher当成Painter来用，所以p1会把Teacher当成Painter来看待，因此p1只能看到Teacher里面的painter()方法和eat()方法，因此能够访问到的也只有这两个方法。所以通达信 接口 下单,接口对于我们实际当中的对象来说，每一个通达信 接口 下单,接口暴露了我们这个实际对象的一部分方法。你使用什么样的通达信 接口 下单,接口，就只能访问这个通达信 接口 下单,接口里面定义的方法，别的通达信 接口 下单,接口定义的方法就没办法访问得到。
通达信 接口 下单,接口可以帮助我们实现多重继承这种逻辑，通达信 接口 下单,接口和它的实现类之间存在多态性。
通过下面这些代码验证通达信 接口 下单,接口更进一步的特性
package javastudy.summary;
/**
* 把“值钱的东西”这个类定义成一个通达信 接口 下单,接口Valuable。在通达信 接口 下单,接口里面定义了一个抽象方法getMoney()
* @author gacl
*
*/
interface Valuable {
public double getMoney();
}
/**
* 把“应该受到保护的东西”这个类定义成一个通达信 接口 下单,接口Protectable。
* 在通达信 接口 下单,接口里面定义了一个抽象方法beProtected();
* @author gacl
*
*/
interface Protectable {
public void beProteced();
}
/**
* 这里是通达信 接口 下单,接口与通达信 接口 下单,接口之间的继承，通达信 接口 下单,接口A继承了通达信 接口 下单,接口Protectable，
* 因此自然而然地继承了通达信 接口 下单,接口Protectable里面的抽象方法beProtected()。
* 因此某一类去实现通达信 接口 下单,接口A时，除了要实现通达信 接口 下单,接口A里面定义的抽象方法m()以外，
* 还要实现通达信 接口 下单,接口A从它的父通达信 接口 下单,接口继承下来的抽象方法beProtected()。
* 只有把这两个抽象方法都实现了才算是实现了通达信 接口 下单,接口A。
* @author gacl
*
*/
interface A extends Protectable {
void m();
}
/**
* 这里定义了一个抽象类Animal。
* @author gacl
*
*/
abstract class Animal {
private String name;
/**
* 在Animal类里面声明了一个抽象方法enjoy()
*/
abstract void enjoy();
}
/**
* 这里是为了实现了我们原来的语义：
* “金丝猴是一种动物”同时“他也是一种值钱的东西”同时“他也是应该受到保护的东西”。而定义的一个类GoldenMonKey。
* 为了实现上面的语义，这里把“值钱的东西”这个类定义成了一个通达信 接口 下单,接口Valuable，
* 把“应该受到保护的东西”这个类也定义成了一个通达信 接口 下单,接口Protectable。这样就可以实现多继承了。
* GoldenMonKey类首先从Animal类继承，然后GoldenMonKey类再去实现Valuable通达信 接口 下单,接口和Protectable通达信 接口 下单,接口，
* 这样就可以实现GoldenMonKey类同时从Animal类，Valuable类，Protectable类继承了，即实现了多重继承，
* 实现了原来的语义。
* @author gacl
*
*/
class GoldenMonKey extends Animal implements Valuable,Protectable {
/**
* 在GoldenMoKey类里面重写了通达信 接口 下单,接口Protectable里面的beProtected()这个抽象方法，
* 实现了通达信 接口 下单,接口Protectable。
*/
@Override
public void beProteced() {
System.out.println('live in the Room');
}
/**
* 在GoldenMoKey类里面重写了通达信 接口 下单,接口Valuable里面的getMoney()这个抽象方法，实现了通达信 接口 下单,接口Valuable。
*/
@Override
public double getMoney() {
return 10000;
}
/**
* 这里重写了从抽象类Animal继承下来的抽象方法enjoy()。
* 实现了这抽象方法，不过这里是空实现，空实现也是一种实现。
*/
@Override
void enjoy() {
}
public static void test() {
/**
* 实际当中在内存里面我们new的是金丝猴，在金丝猴里面有很多的方法，
* 但是通达信 接口 下单,接口的引用对象v能看到的就只有在通达信 接口 下单,接口Valuable里面声明的getMoney()方法，
* 因此可以使用v.getMoney()来调用方法。而别的方法v都看不到，自然也调用不到了。
*/
Valuable v = new GoldenMonKey();
System.out.println(v.getMoney());
/**
* 把v强制转换成p，相当于换了一个窗口，通过这个窗口只能看得到通达信 接口 下单,接口Protectable里面的beProtected()方法
*/
Protectable p = (Protectable)v;
p.beProteced();
}
}
/**
* 这里让Hen类去实现通达信 接口 下单,接口A，通达信 接口 下单,接口A又是从通达信 接口 下单,接口Protectable继承而来，通达信 接口 下单,接口A自己又定义了一个抽象方法m()，
* 所以此时相当于通达信 接口 下单,接口A里面有两个抽象方法：m()和beProtected()。
* 因此Hen类要去实现通达信 接口 下单,接口A，就要重写A里面的两个抽象方法，实现了这两个抽象方法后才算是实现了通达信 接口 下单,接口A。
* @author gacl
*
*/
class Hen implements A {
@Override
public void beProteced() {
}
@Override
public void m() {
}
}
/**
* java中定义通达信 接口 下单,接口
*/
public class JavaInterfacesTest {
public static void main(String[] args) {
GoldenMonKey.test();
}
}通达信 接口 下单,接口总结：通达信 接口 下单,接口和通达信 接口 下单,接口之间可以相互继承，类和类之间可以相互继承，类和通达信 接口 下单,接口之间，只能是类来实现通达信 接口 下单,接口。
文章为作者独立观点，不代表 股票程序化软件自动交易接口观点
相关文章
股民评论