【屌丝学习笔记】第十四天 JAVA基础

/*

接口

*/

/*
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
interface 接口
接口定义时，格式特点：
1，接口中常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符，
常量：public static final
方法：public abstract
接口中的成员都是 public
接口是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。
否则子类是一个抽象类

接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现。
*/
interface Inter
{
public abstract void show();//抽象函数
public static final int X=3; //public静态常量 = 全局常量
//其实只要是 接口类 可以如下写法,会自动补
//但是不建议这么写，可读性低
/*
void show();
int X=3;
*/
}
interface InterA
{
public abstract void method();
}
class Demo
{
public void function(){}
}
class Test extends Demo implements Inter,InterA
{
public void show(){}
public void method(){}
}
interface A
{
void methodA();
}
interface B //extends A
{
void methodB();
}
interface C extends B,A
{
void methodC();
}
class D implements C
{
public void methodA(){}
public void methodB(){}
public void methodC(){}
}
class InterfaceDemo
{
public static void main(String[] args)
{
Test t=new Test();
System.out.println(t.X);
System.out.println(Test.X);
System.out.println(Inter.X);
}
}

/*

多态概念  

instanceof  判断类

*/

/*
多态：可以理解为事物存在的多种体现形态

1,多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
*/
abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨");
}
public void kanJia()
{
System.out.println("看家");
}
}
class Pig extends Animal
{
public void eat()
{
System.out.println("饲料");
}
public void gongDi()
{
System.out.println("拱地");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
/*
Cat c=new Cat();
c.eat();
Dog d=new Dog();
d.eat();
*/
//Animal c=new Cat();
//c.eat();
function(new Dog());
//Animal a=new Cat(); //这样用不到猫的特有方法 catchMouse()
//a.eat();
//Cat c=(Cat)a;
//c.catchMouse();
}
public static void function(Animal a)
{
a.eat();
/*
if(a instanceof Animal) //这是不科学的，因为无论Cat Dog都是Animal的子类
//这条件肯定是满足的，一满足 下面的就不会再执行了
{
System.out.println("haha");
}
*/

if(a instanceof Cat)//判断类
{
Cat c=(Cat)a;
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d=(Dog)a;
d.kanJia();
}
}
/*
public static void function(Cat c)
{
c.eat();
}
public static void function(Dog c)
{
d.eat();
}
public static void function(Pig c)
{
p.eat();
}
*/
}


/*

多态的练习

*/

class DuoTaiDemo2
{
public static void main(String[] args)
{
//BaseStudent bs=new BaseStudent();
//bs.study();
//bs.sleep();
//AdvStudent ad=new AdvStudent();
//ad.study();
//ad.sleep();
DoStudent ds=new DoStudent();
ds.doSomething(new BaseStudent());
}
}
class DoStudent
{
public void doSomething(Student stu)
{
stu.study();
stu.sleep();
}
}
abstract class Student
{
abstract void study();
public void sleep()
{
System.out.println("躺着睡");
}
}
class BaseStudent extends Student
{
public void study()
{
System.out.println("base study");
}
public void sleep()
{
System.out.println("坐着睡");
}
}
class AdvStudent extends Student
{
public void study()
{
System.out.println("adv study");
}
}

/*

 

*/

class DuoTaiDemo3
{
public static void main(String[] args)
{
Fu f=new Zi();
f.method1();  //打印zi 1
f.method2();  //打印fu 2
//f.method3(); 这会报错
/*
在多态中，成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用方法，如果有编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边
变量都看左边
在多态中，静态成员函数的特点：
无论编译和运行，都参考左边
*/
/*
Zi z=new Zi();
z.method1();
z.method2();
z.method3();
*/
}
}
class Fu
{
void method1()
{
System.out.println("fu method1!");
}
void method2()
{
System.out.println("fu method2!");
}
}
class Zi extends Fu
{
void method1()
{
System.out.println("zi method1!");
}
void method3()
{
System.out.println("zi method3!");
}
}

/*

多态的生活小实例

*/

class DuoTaiDemo4
{
public static void main(String[] args)
{
MainBoard mb=new MainBoard();
mb.run();
//mb.useNetCard(new NetCard())
mb.usePCI(null);
mb.usePCI(new NetCard());
}
}
interface PCI //PCI接口类
{
public void open();
public void close();
}
class MainBoard  //主板类
{
public void run()
{
System.out.println("mainboard run");
}
public void usePCI(PCI p)//接口型引用，指向自己的子类对象 ；多态的一种用法
{
if(P!=null)
{
p.open();
p.close();
}
}
}
class NetCard implements PCI //网卡类接口PCI
{
public void open()
{
System.out.println("netcard open!");
}
public void close()
{
System.out.println("netcard close!");
}
}
/*
class MainBoard
{
public void run()
{
System.out.println("MainBoard run!");
}
public void useNetCard(NetCard c)
{
c.open();
c.close();
}
}
class NetCard
{
public void open()
{
System.out.println("netcard open!");
}
public void close()
{
System.out.println("netcard close!");
}
}
*/