java第5天的代码

/*****************Animal.java begin ***********************/

 public class Animal{
 
 public void jj(){
  
 }
 
 public static void main(String args[]){
  //编译时类型       //运行时类型
  Animal animal=new Dog();//animal对象被声明为Animal类型，引用Dog对象
  Dog dog=(Dog) new Animal();
  Animal animal1=new Cat();
  System.out.println(animal instanceof Animal );//true
  System.out.println(animal instanceof Dog );//true
  System.out.println(animal instanceof Cat );//false
  
  Animal animal2=new Cat();//animal对象被声明为Animal类型，引用cat对象
  System.out.println(animal1 instanceof Animal );
  System.out.println(animal1 instanceof Dog );
  System.out.println(animal1 instanceof Cat );
  
//  Dog dog=new Dog();
  System.out.println(dog instanceof Dog );//true
  System.out.println(dog instanceof Animal );//true
  System.out.println(dog instanceof Object );//true
  
  //Dog类与Cat类之间没有直接或间接地继承关系
//  System.out.println(Dog instanceof Cat);
 }
}
class Dog extends Animal{
 String name;
 public void jj(String name){
  
 }
 
}
class Cat extends Animal{
 
}
/*****************Animal.java end ***********************/

 

 

/*****************TestDuoTai.java begin ***********************/

public class TestDuoTai{
 
 public static void main(String args[]){
  //引用的是Cat1对象(调用有方法覆盖的方法)
  Animal1 a=new Cat1();
  a.show();
  a.eat();
//  a.a();
  
 }

}
class Animal1{
 public void a( ){}
 
 public void eat(){
  System.out.println("Animal1 eat...");
 }
 
 public void show(){
  System.out.println("Animal1 show...");
 }
 
}
class Cat1 extends Animal1{
 
 public void eat(){
  System.out.println("Cat eat...");
 }
 
    public void show(){
  System.out.println("Cat show..");
 }
 
}

/*****************TestDuoTai.java end ***********************/

 

 

/*****************TestFinal.java begin ***********************/

class TestFinal {
 
 public static void main(String args[]){
  huhu h=new wowo();
//  h.show();
 }

 
}
class huhu{
 private static final String name="张三";
 static{
//  name="";//在静态代码块中可以属性赋值
 }
 
 /**
  * private类型的方法都默认认为是final方法，因而不能被子类的方法覆盖
  */
    private final void show(){//
     System.out.println("父类方法");
 }
}
class wowo extends huhu{
 private int age;
 
 private void show(){
  System.out.println("子类方法");
 }
 
}

 

/*****************TestFinal.java  end ***********************/

 

 

 

/*****************TestOverload.java begin ***********************/

public class TestOverload {
  public void amethod(int i, String s){}

  //加入其他方法
  //下面哪些方法可以加入到Sample类中，并且保证编译正确呢？

//  public void amethod(String s, int i){} （可以）
//  public int amethod(int i, String s){return 0;} （不可以）
//  private void amethod(int i, String mystring){} （不可以）
//  public void Amethod(int i, String s) {} (可以)
//  abstract void amethod(int i); （不可以）
}
/**
 * 抽象类Sample （abstract public class Sample）
 * @author Administrator
 *
 */
abstract class Sample{
 public static void main( String[] s){}

 //加入其他方法
 //下面哪些方法可以加入到Sample类中，并且保证编译正确呢？

// abstract public void main(String s, int i);
// public final static int main(String[] s){return 0;}
// private void main(int i, String mystring){} （可以）
// public void main( String s) throws Exception{} （可以）

}

/*****************TestOverload.java  end ***********************/

 

/*****************TestOverride .java begin ***********************/

public class TestOverride {
 
 public TestOverride method()throws RuntimeException{
  return null;
 }

}
class override extends TestOverride{
 
 private String name;
 private String password;
 
 public override method(){
  return null;
 }//覆盖父类方法
// private void method(){}//不能缩小父类的修饰符范围
    public  void method(String name,String password){}//重载父类中的方法
}
/**
 * 异常实例代码
 */
//class Sub1 extends TestOverride{
// public void method()throws NullPointerException{}
//}
//class Sub2 extends TestOverride{
// public void method()throws RuntimeException{}
//}
//class Sub3 extends TestOverride{
// public void method()throws Exception{}
//}
//class Sub4 extends TestOverride{
// public void method()throws classnotfoundException ,nullpointerException{}
//}

 

/*****************TestOverride .java  end ***********************/

 

/*****************TestSuper .java begin ***********************/

 

public class TestSuper {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  B b=new B();
  b.show();
 }

}
class A {
 public int n=10;
}
class B extends A {
 public int n=100;
 
 public void show (){
     int n=1000;
  System.out.println(n);//调用方法内部中的属性
  System.out.println(this.n);//调用本类中的属性
  System.out.println(super.n);//调用父类中的属性
  
 }
 
 
}

 

/*****************TestSuper .java  end ***********************/

 

 

 

/*****************TestSuper1 .java begin ***********************/

public class TestSuper1 {
 
 public static void main(String args[]){
  Test test=new Test(1);
//  Test test1=new Test(1);
 }
}

class Test{
 
 static
 {
  //静态代码块
  System.out.println("static code.....");
 }
// 
 {
  //实例代码块（创建对象的时候调用）
  System.out.println("code......");
 }

 public Test(){
  System.out.println("A....");
 }
 public Test(int n){
  System.out.println("A int n.....");
 }
}

/*****************TestSuper1 .java  end ***********************/

 

 

/*****************TestSuper2 .java begin ***********************/

public class TestSuper2 {
 
 public static void main(String args[]){
  Test1 test=new Test2();
 }
}

class Test1 {
 
 public static void show(){}
 //类加载的时候去调用
 static {
  System.out.println("static Test1 code....1");
 }
 
 //创建一个对象的时候调用
 {
  System.out.println("Test1 code.... 3");
 }
 
 public Test1() {
  System.out.println("Test1.... 4");
 }

}

class Test2 extends Test1 {
 private static final String name ;
 public void show(String name){}
 //类加载的时候去调用
 static {
  name="mingkun ";
  System.out.println("static Test2 code....2 ");
 }
 //创建一个对象的时候调用
 {
  System.out.println("Test2 code....5 ");
 }
 
 public Test2() {
  System.out.println("Test2....6");
 }

}

 

/*****************TestSuper2 .java  end ***********************/