4.4.txt

java学习的点滴

1.类型转换
public class A1
{
	public static void main(String [] args)
	{
	    int i=1;
	    long lo=1L;
	    lo=i;        //自动转换
	    i=(int) lo;  //强制转换（可能数据丢失，不建议使用）
	}
}


2.继承extends

(1)格式：修饰符 class 子类名 extends 父类

例：public class OldCat {          //创建一个类，它有一个方法
    
        	public void catchMouse() {           
        
        	System.out.println("捉到一只老鼠");
    	}
        }
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class LittleCat extends OldCat {       //创建一个类，它继承了OldCat类

}

我们可以做一个测试类，创建一个LittleCat对象，它可以调用父类中的方法，也就是说在父类中的成员或方法，子类可以直接使用.


(2)修饰符在继承中的使用范围

但也有例外，下面我通过例子来测试一下有哪些情况下不能使用。

在同个包中：
public class Father {                           //创建一个类
    
    public int money = 10000;              //定义了一个public 的数据成员
    
    protected int friends = 5；              //定义了一个protected 的数据成员
    
    String pet    = "Dog";                     //定义了一个default  的数据成员
    
    private  int shoes = 2;                    //定义了一个private 的数据成员
    

}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class Child  extends Father{          //定义一个类Child，它继承于Father
	

    public void fun() {
        /**
         * 在同一个包中的子类，可以访问超类中 public 、protected 、默认 的 数据成员和方法
         * 
         * 不能访问私有的 数据成员和方法
         */
        int m = money;
        int f = friends;
        String p = pet;
        //int s = shoes;         //这条语句不能使用
                
    }

}


不在同一个包里：

public class OtherChild extends Father{          //定义一个类OtherChild，它继承于Father
	
    public void fun() {
        /**
         * 不在同一个包中的子类，可以访问超类中 public protected  数据成员和方法
         * 
         * 不能访问默认的和 private 数据成员和方法
         * 
         */
 
        int m = money;
        int f = friends;
        //String p = pet;       
        //int s = shoes;
        fun();
    }
}

总结：通过以上的例子，我们发现，子类继承父类，在同一个包里只有private不能使用，不在同一个包里的，只有            public 、protected可以使用。 

(3)关于抽象类的继承:
     
    抽象类：是由abstract关键字实现的，格式为      修饰符  abstract class 类名.
    注：抽象类中至少有一个抽象方法。抽象类不能创建对象，它的方法只能由子类完成，子类如果不是抽象类,它 至少要有一个方法实现抽象方法，修饰符不能比父类更严格，类型、方法名以及有无参数要与父类相同,抛出的异常也不能比父类多。

例：public abstract class Animal {                //定义一个抽象类
    
    	public abstract void eat();              //定义一个抽象方法

    	public void fun() {                        //定义一个方法
    	
      	}
       }
－－－－－－－－－－－－－－－－－－－－－－－－－
public class Monkey extends Animal {

     public void eat() {                  //通过此方法，实现抽象方法
     System.out.println(" 猴子正在吃   吃的是苹果");

    }

}

(4)方法重写：当父类和子类有相同的方法，可以串改方法，叫方法重写。

例：public  class  JiCheng1 {                  //定义一个类，它有四个实例变量，分别有四种类型，有一个方法method()
	
	public int a=1;
	protected int b=2;
	int c=3;
	private int d=4;
	
	public void say()
	{
		System.out.println("aaaaaaaa");
	}
	
	public void method ()
	{
		System.out.println("主类中的方法");
	}

}
－－－－－－－－－－－－－－－－－－－－－－－－－
public class JiCheng2 extends JiCheng1{            //定义一个类JiCheng2，继承父类JiCheng1
	
	public void fun()                    //在子类中可以跟据需要定义父类中所没有的方法
	{
		int i=a+b+c;         //将a,b,c的和赋给i
		//int k=d;
		System.out.println(i);
	}

	public void method()           //定义一个方法，与父类中方法的相同，输出的内容不同
	{
		System.out.println("子类中JiCheng2的方法");
	}
}

－－－－－－－－－－－－－－－－－－－－－－－－－

public class Test {　                             //定义一个测试类

	public static void main(String[] args) {           //程序入口
		
		JiCheng1 cc=new JiCheng2();
		cc.say();

		JiCheng1 aa=new JiCheng1();       //创建一个父类的对象
		aa.method();                               //调用父类中的方法
		
		JiCheng2 bb=new JiCheng2();     //创建一个子类的对象
		bb.method();                               //调用子类中的方法
		
		//以下两条语句实现的功能是方法重写
		aa=bb;         //将父类指向子类                                       
		aa.method();   //实际上调用的是子类的方法
	}
}

总结：子类只能有一个父类，父类有多个子类，子类可以定义父类中没有的，子类可以代替父类，父类可以指向子类，子类可以访问父类中的。继承可以使程序更灵活。