(java)面向对象 ---- final、static、匿名对象、内部类、权限修饰符、代码块

（1）关键字final

     1）final 修饰类  ：最终类   不能被继承    但是使用方式没有变化，可以创建对象，调用方法。

     2）final修饰方法    ：父类中被final修饰的方法，在子类中不能被重写，但可以继承使用。

     3）final修饰局部变量   ： 

                                final  int  i = 11;// 被final修饰，一次赋值，终身不变

                                final修饰引用变量，变量保存内存地址，终身不变

    4）final修饰成员变量   ： 

/*
 *final修饰成员变量 固定的不是内存的默认值，固定的是手动赋值
 *

 * 成员变量的两种赋值方式：
 * （1）定义的时候直接赋值   
 * （2）采用构造方法赋值  （成员变量需要在创建对象前赋值，构造方法是创建对象中的事情）
 * 
 * 被 final 修饰的成员变量，只能被赋值一次
 */
public class Person {
// 1.直接赋值
	final int i= 10; 
// 2.构造方法赋值
//	final int age; 
//	public Person(int age){
//		this.age = age;
//	}
}

（2）关键字static

/*
 *   定义Person类
 *   定义对象的特有数据，和对象的共享数据
 *   
 *   对象的特有数据（非静态数据）    调用者只能是  new 对象
 *   对象的共享数据（静态数据）  调用者可以是new 对象，也可以是类名
 */
public class Person {
	
	String name;
	static int i = 100;
	
}

public class Test {

	public static void main(String[] args) {
		
		Person p1 = new Person();
		Person p2 = new Person();
		
		p1.name = "luo";
		p2.name = "zhang";
		p1.i = p1.i - 20;
		
		System.out.println(p1.name);     // luo
		System.out.println(p1.i);        // 80
		System.out.println(Person.i);    // 静态变量直接使用    类名.  调用 
		
		System.out.println(p2.name);	 // zhang
		System.out.println(p2.i);        // 80

	}

}

【static的内存图】

static注意事项：

  成员变量属于对象的，静态变量属于自己的类的

1）静态不能调用非静态（因为生命周期，静态优先于非静态存储于内存中）

2）静态不能写this 、super

3）静态常量声明：public  static  final  String/int......变量名（大写）

4）static 修饰成员变量，成员方法

5）静态属于类，不属于对象（对象的多态性）

 

【匿名对象】

public static void main(String[] args) {
		
		// 有名字的对象，引用类型变量，可以反复使用
		Fu fu = new Fu();
		fu.fun1();
		
		// 1.匿名对象，没有引用类型变量，只能使用一次
		new Fu().fun1();
		
		// 2.匿名对象可以当做参数
		method(new Fu());
		
		// 3.Fu类型可以当做返回值类型
		Fu p = method();
		p.fun1();
	}
	// 方法返回值类型是Fu类型
	// 方法return 的是这个类型的对象
	public static Fu method(){
		return new Fu();
//		Fu p = new Fu();
//		return p;
	}
	
	public static void method(Fu fu){
		fu.fun1();
	}

【内部类的调用】

/*
 *  将内部类定义在了外部类的    【成员位置】
 *  外部类Outer  内部类Iner
 *  
 *  成员内类，可以使用成员修饰符 public static...
 *  也是个类 ，可以继承，实现接口
 */
public class Outer {
	int i = 1;
	private int a = 1;
	
	/*
	 *  定义内部类
	 *  调用规则：
	 *    内部类  可以使用  外部类  成员，包括私有
	 *    外部类  使用  内部类成员，必须建立内部类对象
	 */
	 class Iner{
		 int i = 2;
		 public void inner(){
			 int i = 3;
			 /* 
			  * 成员 内部类 的同名变量调用 
			  *  System.out.println("内部类"+ Outer.this.i); //打印的是   ：内部类1  访问的是Outer类的成员变量
			  *  System.out.println("内部类"+ this.i);       //打印的是   ：内部类2   访问的是Iner类的成员变量
			  */
			 System.out.println("内部类"+ i);               //打印的是   ：内部类3
		 }	
	}
}

/*
 * 成员内部类测试
 */
public class Test {

	public static void main(String[] args) {
		/*
		 *  调用外部类中 内部类的 inner方法
		 *  格式：
		 *  外部类名.内部类名  变量 = new 外部类对象(). new 内部类对象();
		 *  变量.内部方法();
		 */
		Outer.Iner oi = new Outer().new Iner();
		oi.inner();
	}
}

【局部 内部类】

public class Outer {
	
	public  void  out(){
		// 局部 内部类
		class Iner{
			public void iner(){
				System.out.println("局部内部类 方法");
			}
		}
	    
		Iner in = new Iner();
		in.iner();
	}

}

public class Test {

	public static void main(String[] args) {
		// 调用局部内部类的方法
		new Outer().out(); // 打印结果：局部内部类 方法  
		
	}

}

【匿名内部类】

匿名内部类，简化问题：定义实现类，重写方法，建立实现对象，合为一步完成。

public interface Smoking {
	public abstract  void smoking();

}
/*
 *   接口 实现类
 *   public  class  XXX implements Smoking{
 *   	// 重写抽象方法
 *   	public void  smoking(){ 
 *      }
 *   }
 * 
 *  // 创建XXX对象
 *   XXX  s = new XXX();
 *   s.smoking();
 *  // 多态
 *   Smoking s1 = new XXX();
 *   s1.smoking();
 */

public class Test {
	/*
	 *  匿名内部类
	 *    定义实现类，重写方法，建立实现对象，合为一步完成。
	 *  格式：
	 *    new 接口或父类(){
	 *    	重写抽象方法
	 *    };
	 *   从new 到分号结束   这部分代码相当于  创建了实现接口类的对象
	 */
	public static void main(String[] args) {
		
		new Smoking(){
			public void smoking(){
				System.out.println("人在吸烟");
			}
		}.smoking();

        //		Smoking s = new Smoking(){
//			public void smoking(){
//				System.out.println("人在吸烟");
//			}
//		};
//		s.smoking();
    }
}

【权限修饰符】

 

注意：protected权限第三种使用方法：有A、B两个类分别在不同的包（package），B继承A，A中protected的方法，只能在B里面使用（B类对象不能调用）。

权限修饰符：公共访问public、受保护访问protected、默认访问default、私有访问private

静态修饰符static、最终修饰符final、抽象修饰符abstract

权限修饰符一般放于所有修饰符之前     abstract与private、static、final不能同时使用

【修饰类能够使用的修饰符】

修饰类只能使用public、protected、final、abstract    其中public使用最多

*   1.修饰类的修饰符
	 *    public class Demo1{} // 最常用的方式
	 *    class Demo2{}

	 *    public final class Demo3{}
	 *    public abstract class Demo4{}

【修饰成员变量能使用的修饰符】

public、protected、default、private、final、static     其中private使用最多

*   2.修饰成员变量
	 *   public int count1 = 100;
	 *   protected int count2 = 100;
	 *   int count3 = 100;
	 *   private int count4 = 100;   // 最常用的方式
	 *   
	 *   public final int count5 = 100;
	 *   public static int count6 = 100;

【修饰构造方法能够使用的修饰符】

public、protected、default、private   其中public使用最多

 3.修饰构造方法的修饰符
	 *   public Demo(){}// 最常用的方式
	 *   protect Demo(){}
	 *   Demo(){}
	 *   private Demo(){}

【修饰成员方法使用的修饰符】

public、protected、default、private、final、static、abstract     其中public使用最多

 *   4.修饰成员方法的修饰符
	 *   public void method1(){}  // 最常用的方式
	 *   protect void method2(){}
	 *   void method3(){}
	 *   private void method4(){}
	 *   
	 *   public final void method5(){}
	 *   public static void method6(){}     // 最常用的方式
	 *   public abstract void method7(){}    // 最常用的方式

总结

常用来修饰类、方法、变量的修饰符如下：

1. public 权限修饰符，公共访问, 类,方法,成员变量
2. protected 权限修饰符，受保护访问, 方法,成员变量
3. 默认什么也不写 也是一种权限修饰符，默认访问, 类,方法,成员变量
4. private 权限修饰符，私有访问, 方法,成员变量
5. static 静态修饰符  方法,成员变量
6. final 最终修饰符   类,方法,成员变量,局部变量
7. abstract 抽象修饰符  类 ,方法

 

【代码块】

静态代码块，只执行一次

构造代码块，new一次，就执行一次，优先于构造方法

构造方法，new一次，就执行一次