javaBasic4

####static

修饰变量：类的变量 类名调用
修饰方法：类的方法  类名调用。只能直接访问静态成员
修饰内部类：只能修饰静态内部类
修饰代码块：给静态变量初始化，只执行一次

####final关键字：最终的

final修饰变量：常量，值不能修改
final修饰方法：不能被重写
final修饰类：不能被继承

####abstract关键字：抽象的

抽象类：abstract修饰的类，抽象类中可以有抽象方法，也可以有非抽象方法。
抽象类不能实例化对象。
如果子类继承了抽象类，必须实现抽象类中所有的抽象方法。
抽象方法：abstract修饰的方法，只有方法声明没有方法的实现。抽象方法必须在抽象类中。

思考：

1 抽象类一定是父类吗？ 一定是父类
2 抽象类可以有构造方法吗？有，用于子类对象的初始化
3 有抽象方法的类一定是抽象类吗？一定
4 抽象类中一定有抽象方法吗？不一定
5 抽象方法不可以和哪些关键字同时使用？
	final：抽象类必须有子类，被final修饰的类不能有子类
	static：抽象方法不能被调用，静态方法通过类名调用
	private：抽象方法必须是可以被子类重写的，私有方法不能被重写

####interface 接口

实现接口可以得到该继承体系之外的额外的功能
接口之间可以多继承

interface 接口名{
		抽象方法（public abstract）
		全局常量（public static  final）
	}

	接口：interface 规范
	接口可以解决单继承的问题。接口支持多继承。
	子类实现接口是，必须重写接口中的抽象方法。
	创建子类对象时，调用子类重写的方法。

	接口好处：
		1 规范
		2 提高程序可扩展性
		3 降低类之间的依赖关系

示例

/*
	接口之间可以多继承
*/
interface Ia
{
}
interface Ib
{
}
interface Ic extends   Ia,Ib
{
}

接口是一种标准（规范）

class Demo07 
{
	public static void main(String[] args) 
	{
		IUsb usb = new Computer();
		usb.insert();
		usb.pop();
	}
}

interface IUsb
{
	void insert();
	void pop();
}
class Computer implements IUsb
{
	public void insert(){
		System.out.println("插入usb");
	}
	public void pop(){
		System.out.println("弹出usb");
	}
}

####多态

多态：多种形态
	运行时多态：重写  父类类型引用指向了子类的对象  父类  对象名 = new  子类()；  
    编译时多态：重载

前提条件：继承或者实现


子类  对象名 = new 子类（）；
    可调用的方法：父类继承的方法、子类重写的方法、子类新增的方法
    可执行的方法体：子类重写方法

父类  对象名 = new 子类（）；
    可调用的方法：父类继承的方法、子类重写的方法
    可执行的方法体：子类重写方法

#####类型转换

基本数据类型：
	自动类型转换   小-->大
	强制类型转换  （小类型）变量

引用类型：父类可以看做是大的类型，子类是小的类型

子--（向上转型）--》父--（向下转型）--》子

猫--->动物--->猫
狗--->动物--×-->猫  ：ClassCastException 类型转换异常

注意：

向上转型：父类 对象名 = new 子类（）；
向下转型：子类 对象名 = （子类）父类对象；
	前提条件：向上是向下的前提，需要强转
	可能会抛出异常：.ClassCastException
	  解决：判断  
		if（对象 instanceof  类名）{}

多态中成员的特点：
	成员变量：编译时能访问哪些变量看父类，执行结果看父类
	成员函数：编译时期能访问哪些方法看父类，执行结果看子类（前提子类重写父类的方法,没有重写还是看父类）
	静态成员函数：编译执行都看父类

多态示例：

class Demo10 
{
	/*
		多态：
	*/
	public static void main(String[] args) 
	{
		//父类 对象名 = new 子类（）；
		Animal cat = new Cat();
		cat.eat();  //从父类继承的方法、子类重写的方法
		cat.f(); //调用、执行均看父类

		Animal dog = new Dog();
		dog.eat();

	
		chi(dog);
		System.out.println("------------------");
		
		Animal a1 = new Cat();
		Animal a2 = new Dog();

		if(a1 instanceof Cat){
			Cat c1 = (Cat)a1 ; //父类继承的方法  子类重写的方法  子类新增的方法
			c1.eat();
			c1.catchMouse();
			System.out.println("恭喜你，成功变回猫");
		}else{
			System.out.println("你本不是一只猫");
		}

		System.out.println("------------------");
		if(a2 instanceof Cat){
			System.out.println("恭喜你，成功变回猫");
			Cat c2 = (Cat)a2;  //狗不能转成猫
			c2.eat();
			c2.catchMouse();
		}
		else{
			System.out.println("你本不是一只猫");
		}
		System.out.println("------------------");
		if(a2 instanceof Dog){
			((Dog)a2).eat();
			((Dog)a2).watchHome();
			System.out.println("终于变回狗了");
		}
   	}
/*
	public static void chi(Cat c){
		c.eat();
	}
	public static void chi(Dog d){
		d.eat();
	}*/
	public static void chi(Animal a){
		a.eat();
	}
}
abstract class Animal
{
	public abstract void eat();
	public static void f(){
		System.out.println("Animal static ");
	}
}
class Cat extends Animal
{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void catchMouse(){
	
		System.out.println("猫抓老鼠");
	}
	public static void f(){
		System.out.println("Cat static ");
	}
}
class Dog extends Animal
{
		public void eat(){
			System.out.println("狗吃骨头");
		}
		public void watchHome(){
			System.out.println("狗看家");
		}
}

---

####内部类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

特点：

内部类可以直接访问外部类成员
外部类要访问内部类的成员，必须建立内部类的对象

作用：

1 隐藏部分信息 2 可以访问外部类的私有成员 3 弥补了单继承的局限性 4 解决问题：如果要描述一个事物中还包括另一个事物,同时这个事物要访问被描述的事物

生成字节码文件：外部类$内部类.class

#####成员内部类 成员内部类处在了外部类成员的位置上，所以内部类可以直接访问外部类的成员

代码示例：

[public/default]class 外部类{
	属性
	方法
	内部类：
	[访问修饰符] class 内部类{ //public private default protected
		属性
		方法
	}
}

说明：

1 内部类可以直接调用外部类的成员，包括private
2 如果内部类与外部类的属性或者方法同名时，则内部类默认调用内部类自己的。
	如果想调用外部类的
		外部类.this.成员
3 创建内部类对象
	1)
		外部类 外部类对象 = new 外部类（）；
		外部类.内部类 内部类对象 = 外部类对象.new 内部类（）；
	2)
		外部类.内部类 内部类对象 = new 外部类（）.new 内部类（）;
4 如果外部类想调用内部类成员，需要通过创建内部类对象来调用。
5 编译之后生成的内部类字节码文件为：外部类$内部类.class

示例：

class  Demo13
{
	public static void main(String[] args) 
	{
		Outer1 out = new Outer1();
		out.test();
		System.out.println("通过创建内部类对象访问内部类成员");
		Outer1.Inner1 inner = new Outer1().new Inner1();
		inner.show();
	}
}

class Outer1
{
	private int num = 5;
	class Inner1  //成员内部类
	{
		int num = 500;
		public void show(){
			System.out.println("inner-->num="+num);
			System.out.println("outer-->num="+Outer1.this.num);
		}
	}

	public void test(){  //外部类的方法
		Inner1 in = new Inner1();//外部类访问内部类成员，需要通过对象访问
		in.show();
	}
}

#####静态内部类 静态内部类:相当于外部类，因为static修饰在初始化外部类时就已经被加载到内存中了

写法示例：

[public|default] class 外部类{
	属性
	方法
	//静态内部类
	[访问修饰符] static class 内部类{
		属性
		方法
	}
}

注意：

1 不能调用外部类非静态成员
2 允许定义非静态的变量和方法
3 内部类中不能使用 外部类.this
4 静态内部类使用的格式（不依赖于外部类对象）
  外部类.内部类 内部类对象 = new 外部类.内部类（）

示例：

class Demo14 
{
	public static void main(String[] args) 
	{
		Outer2 out = new Outer2();
		out.test();
		System.out.println("直接访问内部类方法");
		//调用静态内部类中的非静态方法
		Outer2.Inner2 in = new Outer2.Inner2();
		in.show();
		System.out.println("-------------");
		//调用静态内部类中的静态方法
		Outer2.Inner2.show();
	}
}
class Outer2
{
	static int num = 10;
	static class Inner2  //静态内部类
	{
		public static void show(){
			System.out.println("num="+num);
		}

	}

	public void test(){
		//Inner2.show();
		Inner2 in = new Inner2();
		in.show();
	}
}

#####局部内部类 局部内部类：定义在方法的内部

写法示例：

[public|default] class  外部类{
	属性
	方法（）{
		class 内部类{
		
		}
	}
}

应用：多线程、网络下载

注意：

• 1 局部内部类或者局部方法的访问修饰符只能是default的
• 2 局部内部类可以访问外部类成员
• 3 局部内部类如果想使用所在方法的局部变量时，该变量必须是final的（因为final存在于方法区，生命周期较长，不影响局部内部类的使用）
• 4 局部内部类定义在方法中，适用范围仅在方法内

示例代码：

class Demo16 
{
	public static void main(String[] args) 
	{
		Outer3 out = new Outer3();
		out.test();
	}
}
class Outer3
{
	int a = 5;
	void test(){
		final int b = 100;
		class Inner3
		{
				public void show(){
					System.out.println("外部类成员a="+a);
					System.out.println("方法中的成员b="+b);
				}
		}//end class
		Inner3 in = new Inner3();
		in.show();
	}//end test()
}

匿名内部类

匿名内部类：

内部类的简写，没有类名。只使用一次对象时，才会定义匿名内部类

前提：

匿名内部类必须继承或者实现一个外部类或者接口

应用：

应用于抽象类和接口，增加程序的灵活性

语法：

类名  对象名 = new 类名(){  //抽象类或者接口的名字
	将抽象类或者接口的方法实现
};

示例代码一：

class Demo18 
{
	/*
	匿名内部类没有类名
	*/
	class Inner5 implements IUsb
	{
		public void insert(){
				System.out.println("插入");
			}
			public void pop(){
				System.out.println("弹出");
			}
	}

	public static void main(String[] args) 
	{
		Demo18.Inner5 i = new Demo18().new Inner5();
		i.insert();
		i.pop();

		IUsb computer = new IUsb(){
			public void insert(){
				System.out.println("插入");
			}
			public void pop(){
				System.out.println("弹出");
			}
		};
		computer.insert();
		computer.pop();

		new IUsb(){
			public void insert(){
				System.out.println("插入1");
			}
			public void pop(){
				System.out.println("弹出1");
			}
		}.insert();
	}
}

interface IUsb
{
		void insert();
		void pop();
}

示例代码二：

class Demo19 
{
	public static void main(String[] args) 
	{
		Person p = new Person(){
			public void run(){
				System.out.println("人跑步");
			}	
		};
		p.run();

		Person p1 = new Person(){
			public void run(){
				System.out.println("人飞奔");
			}	
		};
		p1.run();


		 new Person(){
			public void run(){
				System.out.println("散步");
			}	
		}.run();

	}
}
abstract class Person{
	public abstract void run();
}

示例代码三（点击事件监听器的应用）：

class Demo20 
{
	public static void main(String[] args) 
	{
		MyButton myBtn = new MyButton();
		myBtn.isClick = true;
		myBtn.setOnClickListener(new OnClickListener(){
			public void onClick(){
				System.out.println("点击了，可以登录！！");
			}
		});

		MyButton myBtn1 = new MyButton();
		myBtn1.isClick = false;
		myBtn1.setOnClickListener(new OnClickListener(){
			public void onClick(){
				System.out.println("点击了，找回密码");
			}
		});
	}
}
interface OnClickListener
{
		void onClick();
}
class MyButton
{
	boolean isClick;  //模拟点击
		public void setOnClickListener(OnClickListener ocl){
			if(isClick){
				ocl.onClick();
			}else{
				System.out.println("没有点击");
			}
		}
}