java中类的各种定义

final类型的类

package leilianxi;
/*
 * 1、当把类定义成final 类时讲不能在继承子类。
 * 2、当把类方法定义为final型时将不能进行重写
 * 3、当把类变量定义为一个final类型时，变量将成为一个常量，不能对其进行修改
 * 4、引用类时定义为final类型将不能在继续引用其他类
 */
public class FinalLei {
	
	final void Add()
	{
		
	}
          public static void main(String[] args)
          {
        	  /*the wrong ways 4.
        	  final PP pp=new PP();
        	  pp.number=2;
        	  pp=new PP();
        	  */
          }
}
/*
 * the wrong way 2.
 */
final class nextLei extends FinalLei{
	/*void Add()
	{
		
	}*/
	
	
	final double pi=3.1415926;
	/*
	 * the wrong way 3.
	 */
	//private void Nihao()
	//{
		//this.pi=2.1444;
	//}
}



class PP{
	int number;
	
}

static类 静态类的使用方法

package leilianxi;

public class LeiDeLianxi {

	public static void main(String[] args)
	{
		System.out.println("count.cont="+count.cont);
		count Tom=new count();
		//count John=new count();
		System.out.println("Tom.cnt="+Tom.cnt);
		System.out.println("count.cont="+count.cont);
		count John=new count();
		System.out.println("John.cnt="+John.cnt);
		System.out.println("New count.cont="+count.cont);
	}
	
}
class count{
	 int cnt;
	static int cont=0;/*
	                    静态变量用法：当在构造函数中使用静态变量时静态变量会一直记录，
	                    不会初始化。//相当于c++中的全局变量
	                    */
	public count(){
		cont++;
		cnt=cont;
	}
}

package leilianxi;

public class LeiDeLianxi {

	public static void main(String[] args)
	{
		System.out.println("count.cont="+count.cont);
		count Tom=new count();
		//count John=new count();
		System.out.println("Tom.cnt="+Tom.cnt);
		System.out.println("count.cont="+count.cont);
		count John=new count();
		System.out.println("John.cnt="+John.cnt);
		System.out.println("New count.cont="+count.cont);
	}
	
}
class count{
	 int cnt;
	static int cont=0;/*
	                    静态变量用法：当在构造函数中使用静态变量时静态变量会一直记录，
	                    不会初始化。//相当于c++中的全局变量
	                    */
	public count(){
		cont++;
		cnt=cont;
	}
}

<pre name="code" class="java">package Class;

public class InnerClass {
	public static void main(String[] args)
	{
		Example1 example1=new Example1();
		Example1.Example2 example2=new Example1.Example2();
		example2.show();	
		example1.show1();
	}
     
}


class Example1{
	private static  int num1=20;
	private static String name="liming";
	/*
	 * 静态内部类只能调用外部的静态成员/方法。
	 * 通过建内部类对象的方法可以调用内部类的任意成员/方法
	 * 外部类可以通过内部类名.方法名/成员 直接调用。
	 * */
	public void show1()
	{
		System.out.println(num1);
		System.out.println(name);
		Example2 example2=new Example2();
		System.out.println(Example2.name2);
		example2.show();
		System.out.println(example2.num2);
		System.out.println();
		System.out.println(example2.name2);
	}
	public static class Example2{ 
		/*
		 * 静态内部类可以调用内部的任一个成员/方法
		 * */
		private static String name2="xiaohong";
		private static int num2=30;
		public void show()
		{
			System.out.println(num2);
			System.out.println(Example1.num1);
			System.out.println(Example1.name);
			
		}
	}
	
}

abstract类：抽象类的使用方法

package leilianxi;


public class abstractLei {


	public static void main(String[] args) {
		
	}

}

/*
 * abstract类：当在此类中需要创建方法但是不知道具体此方法做什么时就定义为抽象类
 * 然后在其子类中重写方法
 */

abstract class Aiyo{
	int objectNum=0;
	
	Object str[]=new Object[100];
	
	abstract void put(Object o);
	
	abstract Object get();
}


class Niyo extends Aiyo{
	private int cnt=0;
	public void put(Object o)
	{
		str[cnt++]=o;
		objectNum++;
	}
	public Object get()
	{
		objectNum--;
		return str[--cnt];
	}
	
}

interface类：接口类，完全的抽象类

package leilianxi;


public class abstractLei {


	public static void main(String[] args) {
		
	}

}

/*
 * abstract类：当在此类中需要创建方法但是不知道具体此方法做什么时就定义为抽象类
 * 然后在其子类中重写方法
 */

abstract class Aiyo{
	int objectNum=0;
	
	Object str[]=new Object[100];
	
	abstract void put(Object o);
	
	abstract Object get();
}


class Niyo extends Aiyo{
	private int cnt=0;
	public void put(Object o)
	{
		str[cnt++]=o;
		objectNum++;
	}
	public Object get()
	{
		objectNum--;
		return str[--cnt];
	}
	
}

匿名内部类的使用

package NimingleibuClass;

public class NimingClass {

	/*
	 *1. 匿名内部类中不能定义静态的方法或者成员。
	 *2.匿名内部类必须继承其他类(抽象/非抽象)，如果父类是抽象类必须将抽象类中的方法全部重载。
	 *3.匿名内部类是没有名称的内部类，没办法引用他们，必须在创建时，作为new语句的一部分声明并创建他们的实例
	 *4.匿名内部类可以定义代码块，但不能定义静态代码块。
	 */
	public static void main(String[] args)
	{
		Person person=new Person();
		person.feed(new Animal(){//Animal 不是父类，而是继承父类的一个扩展，相当于继承了一个父类的新类。
			public String name;
			{
				name="xiaoming";
			}
			public void eat()
			{
				System.out.println("啃骨头");
			}
			public void show()
			{
				System.out.println("Nihao");
			}
		});
		/*new Animal()//如果想调研那个匿名类中的方法只能通过这种方式进行调用。
		{
			public String name="HaHa";
			public void eat()
			{
				System.out.println("吃屎");
			}
			public void show()
			{
				System.out.println(name);
			}
		}.show();*/
		Animal dog=new Animal()
		{
			public void eat()
			{
				System.out.println("吃屎");
			}
		};
		person.feed(dog);
	}
}


abstract class Animal{
	public abstract void eat();
}

class Person{
	public void feed(Animal animal)
	{
		animal.eat();
	}
}

接口类/抽象类实现多态（神器，优化代码）

package Animal;

public class AnimousClass {

	/*
	 * 多态的实现，优化代码。
	 */
	public static void main(String[] args) {
		
		Person person=new Person();
		Animal dog=new Dog();
		person.feed(dog);
	}

}

class Person{
	public void feed(Animal animal)
	{
		animal.eat();
	}
}


abstract class Animal{
	abstract void eat();
}

class Dog extends Animal{
	public void eat()
	{
		System.out.println("啃骨头");
	}
}

局部内部类：

package NimingleibuClass;

public class LocalInnerClass {

	public static void main(String[] args) {
           
		Outer outer=new Outer();
		outer.showOuter();
	}

}
/*
 * 局部内部类是声明在类方法中的类。如果想调用这个类中的方法/成员,只能通过调用外部类.方法的方式进行调用。
 */

class Outer{
	public String num1="10";
	public static int num2=20;
	public void showOuter()
	{
		final int num3=30;//局部内部类访问方法中的成员必须声明为final类型。我的eclipse有bug，竟然不用定义final类型就能调用
		class Inner{
			private int num3=30;
			private int num4=40;
			public void showInner()
			{
				System.out.println(num3);
				System.out.println(num4);
				System.out.println(Outer.this.num1);
				System.out.println(Outer.num2);
				System.out.println(num3);
			}
		}
		Inner inner=new Inner();
		inner.showInner();
	}
}