java学习笔记(四)

ibm公司开发只有eclipse不能开发struts+hibernate+spring+jsp+ajax

myeclipse 插件 eclipseme 手机开发

 

 

3.19~~~继续

多态

所谓多态，就是指一个引用（类型）在不同的情况下的多种状态。

也可以这么理解：多态是指通过指向父类的指针，来调用在不同子类中实现的方法。

/*
 * 功能：演示多态
 */
package com.xiaoyu;
public class Demo5 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		Cat cat=new Cat();
//		cat.cry();
//		Dog dog=new Dog();
//		dog.cry();
//		Animal an = new Cat();
//		an.cry();
//		an=new Dog();
//		an.cry();
		Master master = new Master();
		master.feed(new Dog(),new Bone());
		master.feed(new Cat(),new Fish());
	}
}

class Master
{
	//给动物喂食，使用多态，方法就可以还用一个
	public void feed(Animal an,Food food)
	{
		an.eat();
		food.showName();
	}
	
}

//食物类
class Food
{
	String name;
	public void showName()
	{
		
	}
}
//鱼类
class Fish extends Food
{
	public void showName()
	{
		System.out.println("鱼");
	}
}
//骨头类
class Bone extends Food
{
	public void showName()
	{
		System.out.println("骨头");
	}
}
//动物类Animal
class Animal
{
	private String name;
	private int age;
	//选中上两行数据，右键：source，选generate settor and getter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	//动物叫
	public void cry()
	{
		System.out.println("不知道怎么叫");
	}
	//动物吃
	public void eat()
	{
		System.out.println("不知道吃什么");
	}
}
class Cat extends Animal
{
	//猫叫
	public void cry()
	{
		System.out.println("喵喵叫");
	}
	public void eat()
	{
		System.out.println("猫爱吃鱼");
	}
}
class Dog extends Animal
{
	//狗叫
	public void cry()
	{
		System.out.println("汪汪叫");
	}
	//狗吃东西
	public void eat()
	{
		System.out.println("狗爱吃骨头");
	}
}

注意事项

1. java允许父类的引用变量引用它的子类的实例（对象）Animal animal = new Cat();这种转换是自动的。

 

抽象类、接口、final

 

/*
 * 抽象类的必要性
 */
package com.test;

import com.xiaoyu.Animal;

public class test2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
}

abstract class Animal
{
	String name;
	int age;
	//动物会叫 父类方法的不确定性
	//当父类的方法不能确定时，可以用abstract来修饰
//	public void cry()
//	{
//		System.out.println("不知道怎么叫！");
//	}
	abstract public void cry();
}
//当一个类继承的父类抽象类的话，
//需要我们把抽象类中的所有抽象方法全部实现
class Cat extends Animal
{
	//猫叫
	public void cry()
	{
		System.out.println("喵喵叫");
	}
	public void eat()
	{
		System.out.println("猫爱吃鱼");
	}
}
class Dog extends Animal
{
	//狗叫
	public void cry()
	{
		System.out.println("汪汪叫");
	}
	//狗吃东西
	public void eat()
	{
		System.out.println("狗爱吃骨头");
	}
}

1. 用abstract关键字来修饰一个类时，这个类就是抽象类
2. 用abstract关键字来修饰一个方法时，这个类就是抽象方法
3. 用的不多。。。
4. 抽象类不能被实例化
5. 抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法
6. 一旦类包含了abstract方法，则类必须声明为abstract
7. 抽象方法不能有主体，例如 abstract void aaa(){} //错！

 

接口

usb插槽就是现实中的接口

接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来；

class 类名 implements 接口{
            方法；
        变量；
}

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。

接口体现了程序设计的多态和高内聚低耦合的设计思想。

 

 

package com.test;

interface Usb{
	public void start();
	public void stop();
}

public class test {
	public static void main(String []args)
	{
		Computer computer=new Computer();
		Camera cameral =new Camera();
		Phone phone = new Phone();
		computer.useUsb(cameral);
		computer.useUsb(phone);
	}
}
//编写照相机类，并实现usb接口
//当一个类实现了一个借口，就要求该类把这个接口的所有方法，统统实现
class Camera implements Usb{
	public void start()
	{
		System.out.println("相机开始工作");
	}
	public void stop()
	{
		System.out.println("相机停止工作");
	}
}
//编写手机
class Phone implements Usb{
	public void start()
	{
		System.out.println("手机开始工作");
	}
	public void stop()
	{
		System.out.println("手机停止工作");
	}
}
//计算机类
class Computer{
	//使用usb接口
	public void useUsb(Usb usb)
	{
		usb.start();
		usb.stop();
	}
}

注意事项：

1. 接口不能被实例化
2. 接口中的所有方法都不能有主体，例如：void aaa(){};//错误（抽象类中可以有实现了的方法，接口中不能有被实现的方法；）
3. 一个类可以实现多个接口
4. 接口中可以有变量，但变量不能用private和protected修饰

       a.接口中的变量，本质上都是static的，而且是final，不管你加不加static

       b.在java开发中，我们经常把经常用的变量，定义在接口中，作为全局变量使用。访问形式：接口名.变量名

       5.  一个接口不能继承其它类，但是能继承其它的接口