java学习第五课

/**
 * 继承：从已有的类创建新类；
 * 继承一个父类，只能继承非私有的属性和方法
 * 在父类中用protected修饰的属性和方法可以被子类继承
 * 
 * 一个对象直接使用另一个对象的属性和方法；
 * 代码重用
 * 为什么创建子类对象时父类的构造方法也会被调用？
 * 因为子类要使用到父类的数据，通过父类的构造方法初始化数据
 * 如果创造子类对象时使用默认的构造方法，那么父类的默认构造方法也会被调用
 * 
 */
package class4;

public class Test2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HomeDog hd = new HomeDog("旺财");
		hd.eat();
		hd.print();
		HuskyDog hu = new HuskyDog("二哈");
		hu.eat();
		hu.show();
	}

}
class Dog{
	protected String name;
	private String sex;
	public Dog() {
		super();
		System.out.println("我是Dog的构造方法");
	}
	public void eat() {
		System.out.println("吃饭");
	}
}
class HomeDog extends Dog{
	public HomeDog(String name) {
		this.name = name;
		System.out.println("我是HomeDog的构造方法");
	}
	public void print() {
		System.out.println(name+"我是一只家狗");
	}
}
class HuskyDog extends Dog{
	public HuskyDog(String name) {
		this.name = name;
		System.out.println("我是HuskyDog的构造方法");
	}
	public void show() {
		System.out.println(name+"我是HuskyDog");
	}
}

面试题：overloading与overriding的区别？
overloading：方法的重载，发生在同一个类中，方法名相同，参数列表不同，返回值无关；
overriding：方法的重写，发生在子父类中，方法名相同，参数列表相同，返回值相同；
访问修饰符：子类>=父类；
异常声明：子类<=父类；
如果方法被private，static，final修饰，那么不能被重写

package class4;

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			/*CosmeticManager cm = new CosmeticManager();
			cm.add(new Cosmetic("香奈儿","进口",1000));
			cm.add(new Cosmetic("圣罗兰","进口",800));
			cm.add(new Cosmetic("大宝","国产",20));
			cm.add(new Cosmetic("万紫千红","国产",15));
			cm.printInfo();
			*/
		ImportCosmeticManager scm = new ImportCosmeticManager();
			scm.add(new Cosmetic("香奈儿","进口",1000));
			scm.add(new Cosmetic("圣罗兰","进口",800));
			scm.add(new Cosmetic("大宝","国产",20));
			scm.add(new Cosmetic("万紫千红","国产",15));
			scm.printInfo();
			
	}

}

class ImportCosmeticManager extends CosmeticManager{
	
	public void printInfo() {
		//比较两个字符串的值是否相等，不能使用==，使用equals()
		for(int i = 0;i<count;i++) {
			if("进口".equalsIgnoreCase(cs[i].getType())) {
				System.out.println(cs[i].getInfo());
			}
		}
	}
}
//按单价排序
class SortCosmeticManager extends CosmeticManager{
	public void printInfo() {
		Cosmetic[] temp = java.util.Arrays.copyOf(cs, count);
		Cosmetic c = null;
		for(int i = 0;i<temp.length-1;i++) {
			for(int j =0;j<temp.length-i-1;j++) {
				if(temp[j].getPrice()>temp[j+1].getPrice()) {
					c = temp[j];
					temp[j] = temp[j+1];
					temp[j+1] = c;
					
				}
			}
		}
		for(Cosmetic cosmetic:temp) {
			System.out.println(cosmetic.getInfo());
		}
	}
}
//化妆品管理类
class CosmeticManager{
	protected Cosmetic[] cs = new Cosmetic[4];
	protected int count = 0;
	
	public void add(Cosmetic c) {
		int size = cs.length;
		if(count>=size) {
			int newLen = size*2;
			cs = java.util.Arrays.copyOf(cs, newLen);
		}
		cs[count] = c;
		count++;
	}
	public void printInfo() {
		for(int i = 0;i<count;i++) {
			System.out.println(cs[i].getInfo());
		}
	}
	
}

class Cosmetic{
	private String name;
	private String type;
	private int price;
	
	public Cosmetic() {
		super();
	}
	public Cosmetic(String name, String type, int price) {
		super();
		this.name = name;
		this.type = type;
		this.price = price;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	public String getInfo() {
		return "name="+name+",type="+type+",price"+price;
	}
}

/**
 * 抽象类：用abstract关键字声明的类
 * 很多具有相同特征和行为的对象 可以抽象为一个类
 * 很多具有相同特征和行为的类	 可以抽象为一个抽象类
 */
package class4;

public class Test3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Man man = new Man();
		man.move();
		man.eat();
		
		Woman w = new Woman();
		w.eat();
		w.move();
	}

}
abstract class Animal{
	public abstract void move();
	//方法的声明，抽象方法只有声明，没有实现
}
abstract class Person extends Animal{
	public abstract void eat();
}
//继承抽象类的具体类必须实现所有抽象方法
class Man extends Person{
	@Override
	public void eat() {
		System.out.println("我是男人，我爱吃肉");
	}
	@Override
	public void move() {
		System.out.println("我是男人，我爱跑步");
	}
}
class Woman extends Person{

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("我是女人，我爱吃香蕉");
	}

	@Override
	public void move() {
		// TODO Auto-generated method stub
		System.out.println("我是女人，我爱游泳");
	}
	
}

/**
 * 接口
 */
package class4;

public class Test4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Girl g = new Girl("李莉");
		g.eat1();
		g.sleep();
		g.run();
		g.print();
	}

}
interface IEat{
	public abstract void eat1();//接口中只能定义抽象方法
	void eat2();//public abstract 可以省略
	public static final int NUM = 10;//在接口中定义一个常量
	int NUM2 = 12;
	//JDK1.8后新特性，可以被所有实现类继承
	public default void print() {
		System.out.println("eat");
	}
}
interface IRun{
	void run();
}
//接口之间可以继承（类只能单继承）
interface ISleep extends IEat,IRun{
	void sleep();
}
class Girl implements ISleep,IEat{
	private String name;
	public Girl() {
		super();
	}
	public Girl(String name) {
		super();
		this.name = name;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("爱好跑步");
	}
	@Override
	public void eat1() {
		// TODO Auto-generated method stub
		System.out.println("我是"+name+"，我爱吃猪蹄");
	}
	@Override
	public void eat2() {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("爱好睡觉");
	}
}

/**
 * 摸板方法模式：定义一个算法骨架，将一些可变部分的实现延迟到子类中
 */
package class4;

public class Test5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		UserManager um = new UserManager();
		um.action("admin", "add");
		um.action("test", "add");
	}

}

abstract class BaseManager{//算法骨架
	
	public void action(String name,String method) {
		if("admin".equals(name)) {
			execute(method);//execute全程参与但是在子类中实现
		}else {
			System.out.println("你不是管理员，你没有操作权限");
		}
	}
	public abstract void execute(String method);
}

class UserManager extends BaseManager{
	
	//用户登陆后才可以执行以下操作，验证是否登录
	public void execute(String method) {//实现execute
		if("add".equals(method)) {
			System.out.println("添加");
		}else if("del".equals(method)) {
			System.out.println("删除");
		}
	}
}

/**
 * 接口应用-策略模式:定义一系列算法，将每种算法封装起来并可以相互替换
 * 把可变的行为抽象出来，好处是这些行为在使用时可以相互替换
 */
package class4;

public class Test6 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BaseService user = new UserService();
		user.setiSave(new FileSave());
		user.add("userData");
		
		user.setiSave(new NetSave());
		user.add("userData2");
		
	}

}
interface ISave{
	public void save(String data);
}
class FileSave implements ISave{
	@Override
	public void save(String data) {
		// TODO Auto-generated method stub
		System.out.println("把数据保存到文件中。。。"+data);
	}
}
class NetSave implements ISave{
	@Override
	public void save(String data) {
		// TODO Auto-generated method stub
		System.out.println("把数据保存到网络上"+data);
	}
}
abstract class BaseService{
	private ISave iSave;
	public void setiSave(ISave iSave) {
		this.iSave = iSave;
	}
	public void add(String data) {
		System.out.println("检查数据合法性。。。");
		iSave.save(data);
		System.out.println("数据保存完毕。");
	}
}
class UserService extends BaseService{
	
}

/**
 * 工厂模式
 */
package class4;

public class Teast7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用者和被使用者两者之间耦合产生了依赖，当被使用者改变时，会影响使用者
		//使用工厂模式降低两者之间的依赖
		//Product phone = new Phone();
		//phone.work();
		Product phone = ProductFactory.getProduct("phone");
		if(null!=phone) {
			phone.work();
		}
	}

}
class ProductFactory{
	public static Product getProduct(String name) {
		if("phone".equals(name)) {
			return new Phone();
		}else if("computer".equals(name)) {
			return new Computer();
		}else {
			return null;
		}
	}
}
interface Product{
	public void work() ;
}
class Phone implements Product{

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("手机开始工作。。。");
	}
	
}
class Computer implements Product{

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("电脑开始工作。。。");
	}
	
}

/**
 * 代理模式
 */
package class4;

public class Test7 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Action userAction = new UserAction();
		ActionProxy proxy = new ActionProxy(userAction);
		proxy.doAction();
	}

}
class ActionProxy implements Action{
	private Action target;//被代理的对象
	
	public ActionProxy(Action target) {
		super();
		this.target = target;
	}

	@Override
	public void doAction() {
		// TODO Auto-generated method stub
		long startTime = System.currentTimeMillis();
		target.doAction();//执行真正的业务
		long endTime = System.currentTimeMillis();
		System.out.println("共耗时："+(endTime-startTime));
	}
	
}
interface Action{
	public void doAction();
}
class UserAction implements Action{

	@Override
	public void doAction() {
		// TODO Auto-generated method stub
		for(int i =0;i<100;i++) {
			System.out.println("用户开始工作。。。");
		}
	}
	
}

/**
 * 适配器模式:将一个类的接口转换成客户希望的另外一个接口
 * 适配器使得原本由于接口不兼容而不能一起工作的那些类可以一起工作
 */
package class4;

public class Test9 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PowerA powerA = new PowerAImpl();
		work(powerA);
		PowerB powerB = new PowerBImpl();
		//work(powerB);接口不兼容，插不进去
		Adapter adapter = new Adapter(powerB);
		work(adapter);
	}
	public static void work(PowerA a) {
		System.out.println("正在连接。。。");
		a.insert();
		System.out.println("工作结束。。。");
	}
}
class Adapter implements PowerA{
	//适配器，有了这个类就能把PowerB传进去
	private PowerB powerB;
	public Adapter(PowerB powerB) {
		super();
		this.powerB = powerB;
	}
	@Override
	public void insert() {
		// TODO Auto-generated method stub
		powerB.connet();
	}
	
}
interface PowerB{
	public void connet();
}
class PowerBImpl implements PowerB{

	@Override
	public void connet() {
		// TODO Auto-generated method stub
		System.out.println("电源B开始工作。。。");
	}
	
}
interface PowerA{
	public void insert();
}
class PowerAImpl implements PowerA{

	@Override
	public void insert() {
		// TODO Auto-generated method stub
		System.out.println("电源A开始工作。。。");
	}
	
}

/**
 * 适配器模式2
 */
package class4;
public class Test10 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AnimalFunction a = new Dog1();
		a.run();
	}
}
interface Animal1{
	public void sing();
	public void cry();
	public void run();
	public void swim();
}
//适配器类
abstract class AnimalFunction{
	public void sing() {}
	public void cry() {}
	public void run() {}
	public void swim() {}
}
//Dog想要实现接口Animal就必须要实现那四个
//现在想要只实现run（）方法，需要用AnimalFunction
class Dog1 extends AnimalFunction{
	public void run() {
		System.out.println("跑");
	}
}

/**
 * 内部类
 */
package class4;

public class Test11 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Outer outer = new Outer();
		//在外部创建成员内部类的实例,因为成员内部类需要依赖外部类的对象
		Outer.Inner inner = outer.new Inner();
		inner.print();
		
		outer.innerPrint();
		
	}

}


class  Outer{
	private String name;
	//建议在外部类中定义一个方法，对外提供访问的接口
	public void innerPrint() {
		Inner inner = new Inner();
		inner.print();
	}
	//成员内部类
	class Inner{
		public void print() {
			System.out.println("inner");
		}
	}
}

package class4;

public class Test13 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NodeManager nm = new NodeManager();
		System.out.println("------------------add---------------------");
		nm.add(5);
		nm.add(4);
		nm.add(3);
		nm.add(2);
		nm.add(1);
		nm.print();
		System.out.println("------------------del---------------------");
		nm.del(3);
		nm.print();
		System.out.println("------------------find---------------------");
		System.out.println(nm.find(1));
		System.out.println("------------------update---------------------");
		nm.update(1, 10);
		nm.print();
		System.out.println("------------------insert---------------------");
		nm.insert(1, 20);//在1的位置上插入20
		nm.print();
	}

}
class NodeManager{
	private Node root;//根节点
	private int currentIndex = 0;//节点的序号，每次操作从0开始
	public void add(int data) {
		if(root == null) {
			root = new Node(data);
		}else {
			root.addNode(data);
		}
	}
	public void del(int data) {
		if(root.getData()==data) {
			root = root.next;
			
		}else {
			root.delNode(data);
		}
		
	}
	public void print() {
		if(root!=null) {
			System.out.print(root.getData()+"->");
			root.printNode();
			System.out.println();
		}
	}
	public boolean find(int data) {
		if(root==null) {
			return false;
		}
		if(root.getData()==data) {
			return true;
		}else {
			return root.findNode(data);
		}
	}
	//更新
	public boolean update(int oldData,int newData) {
		if(root==null) return false;
		if(root.getData()==oldData) {
			root.setData(newData);
			return true;
		}else {
			return root.update(oldData,newData);
		}
	}
	//向索引之前插入
	public void insert(int index,int data) {
		if(index<0) return;
		if(index==currentIndex) {
			Node newNode = new Node(data);
			root.next = newNode;
			newNode.next = root;
			root = newNode;
		}else {
			root.insertNode(index,data);
		}
	}
	
	
	private class Node{
		private int data;
		private Node next;
		public Node(int data) {
			super();
			this.data = data;
		}
		//插入节点
		public void insertNode(int index, int data) {
			// TODO Auto-generated method stub
			currentIndex++;
			if(index==currentIndex) {
				Node newNode = new Node(data);
				newNode.next = this.next;
				this.next = newNode;
			
			}else {
				this.next.insertNode(index, data);
			}
		}
		//修改
		public boolean update(int oldData, int newData) {
			// TODO Auto-generated method stub
			if(this.next!=null ){
				if(this.next.data==oldData) {
					this.next.data = newData;
					return true;
				}else {
					return this.next.update(oldData, newData);
				}
			}
			return false;
		}
		//查找节点是否存在
		public boolean findNode(int data) {
			// TODO Auto-generated method stub
				if(this.next!=null) {
					if(this.next.data==data) {
						return true;
					}else {
						return this.next.findNode(data);
					}
				}
			return false;
		}
		public int getData() {
			return data;
		}
		public void setData(int data) {
			this.data = data;
		}
		//添加节点
		public void addNode(int data) {
			if(this.next==null) {
				this.next = new Node(data);
			}else {
				this.next.addNode(data);
			}
		}
		//删除
		public void delNode(int data) {
			if(this.next!=null) {
				if(this.next.data==data) {
					this.next = this.next.next;
				}else{
					this.next.delNode(data);
				}
			}
		}
		//输出所有
		public void printNode() {
			if(this.next!=null) {
				System.out.print(this.next.data+"->");
				this.next.printNode();
			}
		}
		
	}
}

==比较的是地址
equals比较的是真实的值