张效详java就业培训教程学习笔记（二)

lesson3(a上):
    "=="和"equals"的区别:
    用来比较对象的引用变量的值是否相等用"=="
    用来比较对象的内容是否相等用"equals"

    private修饰的成员变量只能被当前类的成员所访问,不能被外部类访问.
    public static void main()不是类的成员,但如果在当前类中定义,也可以访问当前类的用private修饰的成员变量.

    构造方法是创建一个对象时编译器自动调用的方法,用来给对象初始化的.
    如果在类中没有定义构造方法,编译器自动创建一个空的构造方法.
    构造方法也可以重载.

    在方法中用this代表当前方法所属的对象即调用该方法的对象.因为在设计一个方法时并不知道调用这个方法的对象名,所以用this,当然this也可省略.

		class Container{
			Component com;
			public void addComponent(){
				com=new Component(this);
			}
		}
		
		class Component{
			Container c;
			public Component(Container c){
				this.c=c;
			}
		}

    在一个构造方法中调用另一个构造方法时用this,因为构造方法不能直接调用,只能在对象被创建时被编译器调用,在构造方法重载时要调用别的构造方法用this(参数)


lesson3(b下):
    在静态方法里只能直接调用同类中其它的静态成员(包括变量和方法),而不能直接访问类中的非静态成员.这是因为,对于非静态的方法和变量,需要先创建类的实例对象后才能使用,而静态方法在使用前不用创建任何对象.

    静态方法在使用前不能以任何方式引用this和super关键字.与上面的道理一样,因为静态方法在使用前不用创建任何实例对象,当静态方法被调用时,this所引用的对象根本就没有产生.

    main()方法是静态的,因此JVM在执行main()方法时不创建main方法所在的类的实例对象,因而在main()方法中,我们不能直接访问该类中的非静态成员,必须创建该类中的一个实例对象后,才能通过这个对象去访问该类中的非静态成员.

    静态代码块:

	static{

	}

    用来给静态成员变量初始化的,当一个类被装载时只调用一次.

    所谓类的单态设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法.如果我们要让类在一个虚拟机上只能产生一个对象,我们首先将类的构造方法的访问权限设为private,这样就不能用new操作符在类的外部产生类的对象了,但在类的内部仍能够产生类的对象.因为在类的外部开始还无法得类的对象,只能调用该类的某个静态方法以返回类内部创建的对象,静态方法只能访问类中的静态成员变量,所以,指向类内部产生的该类对象的变量也必须定义成静态的.

		
		class Chinese{
			static Chinese objRef=new Chinese();
			private static int count=0;
			private static String country="中国";
			static{
				count=2;
				System.out.println("Static code");
			}
			String name;
			int age;
			public static Chinese getInstance(){
				return objRef;
			}
	
			private Chinese(){
				System.out.println(++count);
			}
			static void sing(){
				System.out.println("啊");
			}
			void singOurCountry(){
				System.out.println("country");
				sing();
			}
	
		}

		class TestChinese{
			public static void main(String args[]){
				Chinese obj1=Chinese.getInstance();
				Chinese obj2=Chinese.getInstance();
				System.out.println(obj1==obj2);
			}
		}

    内部类:----在类中直接定义的内部类

    嵌套类可以直接访问嵌套它的类的成员,包括private成员,但是,嵌套类的成员却不能被嵌套它的类直接访问.

    在内部类对象中保存了一个对外部类对象的引用,当内部类的成员方法中访问某一个变量时,如果在该方法中和内部类中都没有定义过这个变量,内部类中对this的引用会被传递给那个外部类对象的引用.

		class Outer{
			int outer_i=100;
			void test(){
				Inner in=new Inner();
				in.display();
			}
			class Inner{
				void display(){
				System.out.println("Outer_i="+outer_i);
			}
		}
			public static void main(String args[]){
				Outer outer=new Outer();
				outer.test();
			}
		}

    如果用static修饰一个内部类,这个类就相当于是一个外部定义的类,所以static的内部类中可声明static成员,但是,非static的内部类中的成员是不能声明为static的.static的内部类不能再使用外层封装类的非static的成员变量,这个道理不难想象!所以static嵌套类很少使用.

    内部类如何被外部类引用

		class Outer{
			private int size=10;
	
			public class Inner{
				public void doStuff(){
				System.out.println(++size);
				}
		
			}
		}		

		public class TestInner{
			public static void main(String args[]){
				Outer outer=new Outer();
				Outer.Inner inner=outer.new Inner();
				inner.doStuff();
			}
		}

   
    在方法中定义的内部类要访问方法中的局部变量时必须加final修饰该变量.