oop_day05_package、public、static、final、内部类

oop_day05_package、public、static、final、内部类

--20150813

1.方法的重写:

   1)父子类中，方法签名相同，方法体不同

   2)重写方法被调用时，看对象的类型

   3)遵循"两同两小一大"规则:

      3.1)两同:

                方法名相同，参数列表相同

      3.2)两小:

           子类的返回值类型小于或等于父类-----一般都是等于

              3.2.1)返回类型为void时，必须相同

              3.2.2)返回类型为基本类型时，必须相同

              3.2.3)返回类型为引用类型时，需小于或等于

           子类抛出的异常小于或等于父类

      3.3)一大:

               子类的访问控制权限大于或等于父类

2.重写与重载的区别---常见面试题

   1)重写:父子类中，方法名相同，参数列表相同

               遵循"运行期"绑定，看对象的类型调用方法

   2)重载:一个类中，方法名相同，参数列表不同

               遵循"编译期"绑定，看引用的类型绑定方法

3.package:包

   1)作用:避免类的命名冲突

   2)包名可以有层次结构，类完全限定名: 包名.类名

   3)建议:包名所有字母都小写

   import:声明类/引入类

   1)语法: import 包名.类名

   2)同一包中的类，可以直接访问

   3)不同包中的类，有两种访问方式:

      3.1)完全限定名-----繁琐(不建议)

      3.2)先import声明类，直接用类名-----建议

4.访问控制修饰符:

   1)public:公开的，任何地方

   2)private:私有的，本类

   3)protected:受保护的，本类、子类、同包类

   4)默认的:什么也不写，本类、同包类

   说明:

       1)类的访问控制: public，默认的（其他包中不能使用）

       2)类成员的访问控制: 如上4种都可以

   建议:

       数据(变量)私有化(private)，行为(方法)公开化(public)

5.static:静态的

   1)静态变量:

      1.1)由static修饰

      1.2)属于类的，存在方法区中，只有一份

      1.3)常常通过类名.来访问

      1.4)何时用:所有对象的数据都一样时使用时

   2)修饰方法:静态方法

      2.1)由static修饰

      2.2)没有隐式this传递，不能直接访问实例成员

      2.3)常常通过类名.来访问

      2.4)何时用:方法的操作仅与参数相关而与对象无关时使用

   3)块:静态块

      3.1)类被加载期间自动执行，只执行一次

      3.2)何时用: 初始化静态资源(图片、音频、视频等)

代码示例：

package oo.day05;
//static演示
public class StaticDemo {
	public static void main(String[] args) {
		Joo o1 = new Joo();
		o1.show();  //a=1,b=1
		Joo o2 = new Joo();
		o2.show();  //a=1,b=2
		
		System.out.println(Joo.b); //建议通过类名点来访问
		System.out.println(o1.b);  //不建议
		
		Koo.test(); //静态方法常常通过类名点来访问
		
		Loo o3 = new Loo();
		Loo o4 = new Loo();
		Loo o5 = new Loo();
		
	}
}

class Loo{
	static{ //因为类只被加载一次，所以静态块也只执行一次
		System.out.println("静态块");
	}
	Loo(){
		System.out.println("构造方法");
	}
}

class Koo{
	int a; //实例变量，对象点来访问
	static int b; //静态变量，类名点来访问
	void show(){ //隐式传递this
		this.a = 1;
		b = 2;
	}
	static void test(){ //没有隐式this传递
		//a = 1; //没有this意味着没有对象，没有对象意味着不能访问实例成员，因为实例成员需要由对象点来访问
		b = 2;
	}
}


class Joo{
	int a;        //实例变量:属于对象的，存在堆中，有一个对象就有一份
	static int b; //静态变量:属于类的，存在方法区中，只有一份
	Joo(){
		a++;
		b++;
	}
	void show(){
		System.out.println("a="+a);
		System.out.println("b="+b);
	}
}

6.final:最终的(不可改变)

   1)修饰变量:变量不能被修改

   2)修饰方法:方法不能被重写

   3)修饰类:类不能被继承

代码示例：

package oo.day05;
//final演示
public class FinalDemo {
	public static void main(String[] args) {
	}
}

final class Poo{}
//class Qoo extends Poo{} //编译错误，final的类不能被继承

class Roo{}
final class Soo extends Roo{}



class Noo{
	void show(){}
	final void say(){}
}
class Ooo extends Noo{
	void show(){}
	//void say(){} //编译错误，final的方法不能被重写
}


/*
 * final修饰实例变量，有两种方式初始化:
 *   1)声明同时初始化
 *   2)构造方法中初始化
 * final修饰局部变量，用之前初始化即可
 */
class Moo{
	final int a = 1; //声明同时初始化
	final int b;
	Moo(){
		b = 2; //构造中初始化
	}
	void show(){
		final int c; //用之前初始化即可，不用可以不初始化
		//a = 250; //编译错误，final的变量不能被修改
	}
}

7.内部类: ----此写法了解

   1)类中套类，外面的类叫外部类，里面的类叫内部类

   2)内部类通常只服务于外部类，对外不具备可见性

   3)内部类对象通常只在外部类中创建

   4)内部类中可以直接访问外部类成员(包括私有的)

   5)内部类中隐式的引用指向创建它的外部类对象

      ----------外部类名.this (Mama.this  Outer.this)

代码示例：

package oo.day05;
//内部类演示
public class InnerDemo {
	public static void main(String[] args) {
		Mama m = new Mama();
		//Baby b = new Baby(); //编译错误，内部类对外不具备可见性
	}
}

class Mama{ //外部类
	private String name;
	Baby createBaby(){
		return new Baby();
	}
	class Baby{ //内部类
		void showMamaName(){
			System.out.println(name); //简略写法
			System.out.println(Mama.this.name);
			//System.out.println(this.name); //编译错误
		}
	}
}

8.匿名内部类:----掌握

   1)想创建一个类的对象，并且对象还只创建一次，
      这个类就没有意义了，此时，该类不必命名，
      称之为匿名内部类

代码示例：

package oo.day05;
//匿名内部类
public class NstInnerDemo {
	public static void main(String[] args) {
		//Too o1 = new Too(); //创建Too对象
		
		//1.创建了Too的一个子类，没有名字
		//2.为该子类创建了一个对象，名为o2
		//3.大括号中的为子类的类体
		//Too o2 = new Too(){
			
		//};
		
		//1.创建了Too的一个子类，没有名字
		//2.为该子类创建了一个对象，名为o3
		//3.大括号中的为子类的类体
		
		//o3为Too子类的对象
		//show()为Too子类的方法
		//访问方法为o3.show()
		Too o3 = new Too(){
			public void show(){
				System.out.println(111);
			}
		};
		//o3.show(); //o3为Too子类的对象，show()为Too子类的方法
		             //o3.show()为调用子类的方法
		
	}
}

interface Too{
	void show();
}