Java基础学习笔记1

一边看codingke的视频，一边敲的代码，编辑于下，方便复习看之

从继承到多态（花了大半天的时间，主要是还没有进入状态，感觉好像还有很多很多东西等着学，20160108）

【扣丁学堂】

Test11主要是对super（）的理解，父类中有带参的构造函数时，子类继承父类时要使用super（）

package practice05;
/*
 * 继承
 * 允许多继承，父类，子类，子类的子类
 * 在子类进行实例化时，首先实例化父类（调用父类的构造方法），再实例化子类
 */
public class Test11 {
	public static void main(String[] args){
		Dog dog1=new Dog("dog");
		dog1.print();
		dog1.desc();
	}
}
//父类
class Animal{
	//如果属性需要被子类继承,那么可以使用protected关键字声明
	public Animal(String name){
		System.out.println("animal");
	}
	protected String name;
	protected void desc(){
		System.out.println("animal name is "+name);
	}
}
//子类
/*
 * extends在java中是单继承
 */
class Dog extends Animal{
	//构造方法
	public Dog(String name){
		/*
		 * 当父类中没有无参的构造函数是，子类中要使用super
		 */
		super(name);//显示的调用父类的构造方法，在构造方法的第一行
		System.out.println("dog");
		this.name=name;
	}
	public void print(){
		System.out.println("my name is "+name);
	}
	//重写
	public void desc(){
		super.desc();//调用父类的方法，调用属性也相同
		System.out.println("dog name is "+name);
	}
}

Test12写了一个关于管理商品的例子

里面有一个关于数组扩充的函数（这一点在c中好像只能用malloc实现了），还有一条语句{cosme[count]=cos;}，便于对栈和堆的理解，相当于c中的指针

package practice05;
import java.util.Arrays;
public class Test12 {
	public static void main(String[] args){
		//
	}
}
class Cosmetic{
	private double money;
	private String name;
	public Cosmetic(double money,String name){
		this.money=money;
		this.name=name;
	}
	public double getMoney(){
		return money;
	}
	public void setMoney(double money){
		this.money=money;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public String infor(){
		return name+" :"+money;
	}
}
class CosmeticManager{
	Cosmetic []cosme=new Cosmetic[3];
	int count=0;
	public void adding(Cosmetic cos){
		if(count==cosme.length){
			int len=cosme.length*3/2+1;
			cosme=Arrays.copyOf(cosme, len);
		}
		cosme[count]=cos;//注意着调语句
//		cosme[count].setMoney(cos.getMoney());
//		cosme[count].setName(cos.getName());
		count++;
	}
	public void printInfor(){
		for(int i=0;i<count;i++){
			System.out.println(cosme[i].infor());
		}
	}
}
class SortCosmeticManager extends CosmeticManager{
		//
}

Test13是讲final（只是了解大概）

package practice05;
/*
 * final声明的类不能被继承
 * final声明的方法不能被重写
 * final声明的属性可以有两种赋值
 */
public class Test13 {
	public static void main(String[] args){
		//
	}
}
class ParentClass{
	private final int num=10;
	private final int count;
	public ParentClass(){
		count=100;
	}
	public final void method(){
		//
	}
}
class SubClass extends ParentClass{
	//
}

Test14开始讲abstract ，给我的感觉和继承一样

package practice05;

public class Test14 {
	public static void main(String[] args){
		Man m=new Man();
		m.eat();
		Woman y=new Woman();
		y.eat();
	}
}
/*
 * 具体类继承抽象类必须要实现抽象方法
 */
class Man extends Person{
	public void eat(){
		System.out.println("eating with quick");
	}
}
class Woman extends Person{
	public void eat(){
		System.out.println("eating with slowly");
	}
}
/*
 * 有抽象方法的一定是抽象类，是抽象类不一定是抽象方法
 * 抽象方法不能被实例化
 * 抽象类似不能被用final，因为就是要被继承的
 */
abstract class Person{
	private String name;
	public abstract void eat();//没有实现，抽象方法
}

Test15讲的是interface

package practice05;
/*
 * 接口（是一种行为）
 * 接口是一组行为的规范，定义，没有实现
 * 使用接口，可以让我们的程序更加利于变化
 * 接口可以继承多个接口（例子？？）
 * 一个类可以实现多个接口
 * 抽象类实现接口可以不实现方法
 * 接口中的所有方法的访问权限都是public
 * 接口中定义的属性都是常量
 */
public class Test15 {
	public static void main(String[] args){
		//
	}
}
class Girl implements Hit{
	public void cry(){
		System.out.println("crying");
	}
	public void eat(){
		System.out.println("eating continually");
	}
}
interface Eat extends Hit{
	public void eat();
	//下面的default不懂？？
	public default void print(){
		//
	}
}
interface Hit{
	String info="";//public static final (定义常量的通常方法？？） 属性就是常量
	void cry();//在接口中的方法默认为public
}

Test16讲多态

用abstract来说明，不过这个例子的重要之处在于父类引用子类对象（似乎像是父类获得了子类的一切方法）

最后提了一下instanceof来判断强制转换是否可以

package practice05;
/*
 * 多态（有点不懂？？？）
 * 父类可以代表子类，但是子类不能代表父类（向上转化）
 */
public class Test16 {
	public static void main(String[] args){
		HomeCat hoc=new HomeCat();
		hoc.eat();
		YeCat yec=new YeCat();
		yec.eat();
		/*
		 * 用父类的引用指向子类对象,便于扩展
		 * 父类一般用接口或者是抽象类（越抽象越好）
		 */
		Cat cat=new HomeCat();
		/*
		 * 向下转型（大转小，父类转子类）
		 * 容易有异常
		 * 例
		 * Cat cat=new YeCat();
		 * HomeCat hoc=(HomeCat)cat;
		 * 本身是YeCat
		 */
		/*
		 * instanceof判断类型是否可以转，可以就转，不可以就不转
		 *
		 * if(cat instanceof HomeCat){
			HomeCat hc=(HomeCat)cat;
		}
		 */
		
//		HomeCat hc=(HomeCat)cat;
		print(cat);
	}
	//多态
	public static void print(Cat cat){
		cat.eat();
	}
}
class HomeCat extends Cat{
	public void eat(){
		System.out.println("family cat eating with slowly");
	}
}
class YeCat extends Cat{
	public void eat(){
		System.out.println("outdoor cat eating with quickly");
	}
}
abstract class Cat{
	public String name;
	public abstract void eat();
}

Test17 讲模板，不过觉得还是多态

package practice05;
//多态，模板
public class Test17 {
	public static void main(String[] args){
		//
	}
}
class Girl2 extends Games{
	public boolean putHand(){
		//一种写法
		java.util.Random r=new java.util.Random();
		return r.nextBoolean();
	}
}
class ModelGirl extends Games{
	public boolean putHand(){
		return false;
	}
}
abstract class Games{
	public void play(){
		System.out.println("play");
		System.out.println("outcome :");
		if(putHand()){
			System.out.println("accepted");
		}else{
			System.out.println("play again");
		}
	}
	public abstract boolean putHand();
}

Test18 大综合，用接口来实现抽象类属性的多态

package practice05;
/*
 * 接口应用-策略模式
 * OO设计原则：
 * 1.面向接口编程（面向抽象编程）
 * 2.封装变化
 * 3.多用组合，少用继承
 * 
 */
public class Test18 {
	public static void main(String[] args){
		Duck black=new BlackDuck("xiaohei");
		black.setFly(new FlyImpl());
		black.fly();
		
		Duck model=new ModelDuck("wanju");
		model.setFly(new NoFlyImpl());
		model.fly();
	}
}
interface Flyable{
	public void fly();
}
class FlyImpl implements Flyable{
	public void fly(){
		System.out.println("I can fly");
	}
}
class NoFlyImpl implements Flyable{
	public void fly(){
		System.out.println("I cann't fly");
	}
}
abstract class Duck{
	private String name;
	private Flyable flyy;
	public void setFly(Flyable flyy){
		this.flyy=flyy;
	}
	public Duck(String name){
		this.name=name;
	}
	public void fly(){
		System.out.println("我的名字是"+name);
		flyy.fly();
	//	System.out.println("I'm a Duck flying very hightly");
	}
}
//真鸭子
class BlackDuck extends Duck{
	public BlackDuck(String name){
		super(name);
	}
}
//玩具鸭子
class ModelDuck extends Duck{
	public ModelDuck(String name){
		super(name);
	}
/*	public void fly(){
		System.out.println("I'm a Duck with unable to fly");
	}*/
}