JAVA基础篇(3)

java常用引用类型：

名称	简介
类	一般用来封装定义的方法和属性，一般可以通过访问类进行数据操作，以达到面向对象的思想，用class来修饰
接口	是抽象方法的一个集合，本身不能实现方法，只能通过子类来实现方法，且子类必须实现接口的所有方法，接口用interface修饰
数组	一般用来存储对象的元素，其特性长度固定，即刚创建时未定义长度，默认长度为10，且只能存储定义类型相同的数据

1. java类举例：

public class Lei{//类分为内部类和外部类,此为外部类，可以用public或者不用修饰
    static int i=1;//静态成员
    int show=2;
    static int n=3;
    public class Nornlei //内部类分为两种，1.静态内部类；2.非静态内部类，此为非静态内部类
    {
    	int fis=5;
    	System.out.println(Lei.this.show);//访问外部成员并输出，格式为(类.this.成员)
    }
    public static class Jinglei//静态内部类
    {
   	int i=1;
   	System.out.println(Lei.i);//访问外部静态相同成员,静态内部类可以直接访问外部类的静态成员
   	System.out.println(n);//访问外部静态名字不相同成员
   	Lei lei=new Lei();//访问其他成员需要实例化外部类
   	System.out.println(lei.show);
    }//内部类可以有所有的访问权限，且静态内部类可以直接获取其他Class类型
   Nornlei norn=new Nornlei();//外部类不能直接访问内部类需要先实例化
   System.out.println(norn.fis);//再调用输出
}
----------------------------------------------------------------
public class Zhu{
      public static void main(String args[])
      {
      		Lei lei=new lei();//实例化外部类
      		Jinglei jl=new Jintlei();//静态内部类可以直接实例化
      		System.out.println(lei.show);//访问并输出外部类成员
      		System.out.println(jl.i);
      		Lei.Nornlei norn=lei.new Nornlei();//需要通过外部类实例化后再实例化内部类
      		System.out.println(norn.fis);
      }
}    

2. java接口举例:

public interface JieKou{//定义接口,可以使用extends继承多个接口
	public String fangfa1();//定义未实现的方法，接口里面的方法默认为抽象方法
}
public class ShiXian implements JieKou{//子类实现接口，可以实现多个接口，即后面为implements 接口1，接口2
	public String fangfa1()
	{
		return "Myname";
	}
}
-------------------------------------------------------
public class Zhu{
	public static void main(String args[])
	{
		JieKou jiekou=new ShiXian();//实例化时要父类指向子类
		System.out.println(jiekou.fangfa1());//输出
	}
}

3. java数组举例

public class zhu{
	public static void main(String args[])
	{
		int[] shuzu={1,2,3,4,5};//直接定义
		int[] shuzu1=new int[2];//先初始化，再赋值int[]括号中可以定义数组长度
		shuzu1[0]=1;
		shuzu1[1]=2;
		shuzu1[2]=3;
		int[] shuzu2=new shuzu[] {1,3,5};//初始化后马上赋值
		for(int i:shuzu){//foreach遍历循环数组
			System.out.println(i);
		}
		for(int j=0,j<=shuzu.length()-1,j++){//根据数组长度来遍历
			System.out.println(shuzu[j]);
		}
		//还有一些变换位置的方法
		Collections.sort(shuzu);//正向排序
		Collections.reverse(shuzu);//逆序排序
		Collections.shuffle(shuzu);//随机排序
	}
}

抽象类和接口：

区别:

区别点	抽象类	接口
定义	包含了一个抽象方法(抽象类中可以没有抽象方法)	抽象方法与常量的集合(接口中的方法默认是抽象方法)
构成	可以有普通方法，构造方法，抽象方法，常量，变量	只能有抽象方法和常量
使用	子类使用extends来继承	子类使用implements实现接口,不过实现接口的所有方法
常用设计模式	常用作模板模式	常用做工厂模式和代理模式
关系	一个抽象类只能由一个子类继承	一个接口可以继承多个接口，一个子类可以实现多个接口
调用	通过子类来实例化	通过子类来实列化
局限	单继承	多继承(优先使用接口)

例子:

1. 模板设计(抽象类)：

public abstract class Chouxiang{
	private String name;
	private int id;
	public void Chouxiang(String name,int id)
	{
		this.name=name;
		this.id=id;
	}
	public int getid()
	{
		return name;
	}
	public String getname()
	{
		return id;
	}
	public abstract String cf();
	public void putong()
	{
		System.out.println(chis.cf());	
	}	
}
public class Son extends Chouxiang{ //Son实现
	private String say:
	public void Son(int id,String name,String say)
	{
		super(name,id);
		this.say=say;
	}
	public abstract String cf()
	{
		return "姓名："+super.getname()+"身份证："+super.getid+"说话："+this.say;	
	}
}
public class Sun extends Chouxiang{
	private String say:
 	public void Sun(int id,String name,String say)
	 {
	  	super(name,id);
  		this.say=say;
	 }
	 public abstract String cf()
 	{
 		 return "姓名："+super.getname()+"身份证："+super.getid+"说话："+this.say; 
 	}
}
---------------------------------------------------------------------------------
public class Zhu{
	public void main(String args[])
	{
		Chouxiang cx=new Son(1,"lily","吼叫ao!");
		cx.putong();//输出(姓名：lily 身份证：1 说话：吼叫ao)
	}
}

2. 工厂模式设计(接口):

public interface Jiekou{//接口
	public void makefood();
	public void eatfood();
	public void junkfood();	
}
public class Dog implements Jiekou{
	public void makefood()
	{
		System.out.println("Dog正在制作食物");
	}
	public void eatfood()
	{
		System.out.println("Dog正在享受食物");
	}
	public void junkfood()
	{
		System.out.println("Dog发现食物是垃圾食品");
	}
}
public class Cat implements Jiekou{
	public void makefood()
	{
		System.out.println("Cat正在制作食物");
	}
	public void eatfood()
	{
		System.out.println("Cat正在享用食物");
	}
	public void junkfood()
	{
		System.out.println("Cat发现食物都是垃圾");
	}
}
public class Factory{//工厂类判断用哪儿个类实例化接口
	public Jiekou getname(String name)
	{
		Jiekou jiekou=null;
		if(name.equals("Cat"))
		{
			Jiekou jiekou=new Cat();
		}
		if(name.equals("Dog"))
		{
			Jiekou jiekou=new Dog();
		}
		return jiekou;
	}
}
-------------------------------------------------------	
public class Zhu{
	public void main(String args[])
	{
		Factory factory=new Factory();
		Jiekou jiekou=factory.getname("Dog");
		jiekou.makefood();
		jiekou.eatfood();
		jiekou.junkfood();
	}
}

3. 适配器(接口和抽象类):

public interface Jiekou{
	public void fangfa1():
	public void fangfa2();
	public void fangfa3();
}
public abstract Chouxiang implements Jiekou{
	public void fangfa1(){}
	public void fangfa2(){}
	public void fangfa3(){}	
	}
}
public Son extends Chouxiang{//不用实现全部方法
	public void fangfa1()
	{
		System.out.println("实现1个方法");
	}
}
-----------------------------------------------------------
public class Zhu{
	public void main(String args[])
	{
		Jiekou jiekou=new Son();
		jiekou.fangfa1();
	}
}