JNOTE

变量
类成员变量声明时若没有赋值 会有默认的初始值 而局部变量则没 必须初始化

 

访问权限
private  类本身
default  类本身 同一个包
protected 类本身 同一个包 不同包的子类
public  类本身 同一个包 不同包的子类 不同包的非子类

private  类本身
default  同一个包
protected 不同包的子类
public  全部

如果一个类的构造器声明为 private 则其他类不能生成此类的实例
private 成员的访问 可通过存取器方法 set/getXX

 

构造器
用来初始化 创建对象 与类同名 没有返回值
当没有定义构造器时 虚拟机默认的构造器将被调用
构造器被调用顺序：构造器按照派生顺序 由超类到子类被调用
因为在子类的构造器中必须将super()作为第一个执行语句 因此 不管是否使用super()这个顺序都是一样的

 

对象
即类的实例 通过 new 运算符调用构造器创建

ClassTest ct = new ClassTest();

ct 一个句柄变量
new ClassTest() 返回一个对象的引用 而此引用存储在变量ct中

ClassTest ct;
ct = new ClassTest();

 

 

方法

return
	void methodA()
	{
		if(???) return;
		.....
	}

	int methodB()
	{
		return 5;
	}

 

参数传递：参数是调用方法时传递给它的值 而自变量是接收参数值的由方法定义的变量
    简单数据类型按值传递 自变量的改变不影响原参数值 如果是引用型 则会改变

class Test
{
	void noChange(int i, int j)
		{
			i += j;
			j += 1;
		}
}

class ValueTest
{
	public static void main(String[] args)
		{
			int a = 4, b = 5;
			Test t = new Test();

			System.out.pritnln("a and b : " + a + " " + b);
			t.noChange(a,b);
			System.out.println("call method a&b : " + a + " " + b);
		}
}


class Test
{
	int a, b;

	Test(int i, int j)
		{
			a = i;
			b = j;
		}
	
	void isChange(Test t)
		{
			t.a += t.b;
			t.b += 1;
		}
}

class Value
{
	public static void main(String[] args)
		{
			Test t = new Test(4,5);

			System.out.println("a and b : " + t.a + " " + t.b);

			t.isChange(t);
			System.out.println("call method a&b : " + t.a + " " + t.b);
		}
}

 

方法重载(多态)
方法名字相同 自变量列表不同(自变量个数不同 或者 自变量类型不同) 重载不受返回类型影响
自动类型转换：参数与自变量列表没有直接匹配时

class Test
{
	void methodA(int a)
		{
			a += 1;
			System.out.println("method arg type is int");
		}
	
	double methodA(double b)
		{
			return b++;
			System.out.println("method arg type is double");
		}
}

class OverloadTest
{
	public static void main(String[] args)
		{
			Test t = new Test();

			short s = 4;
			float f = 10.4F;

			t.methodA(s); //methodA(int)
			t.methodA(f); //methodA(double)
		}
}

 

构造器重载：以不同的方式构造对象 利用重载构造器可以使用一个对象初始化另一个 

class Test
{
	int sum;

	Test(int a)
		{
			for(int i=0; i<a; i++)
				{
					sum += i;
				}
		}

	Test(Test t)
		{
			sum = t.sum;
		}
}

class ConTest
{
	public static void main(String[] args)
		{
			Test s = new Test(100);
			Test t = new Test(s);

			System.out.println(s.sum);
			System.out.println();
			System.out.println(t.sum);
		}
}

 

方法覆盖
方法的签名=方法名+自变量列表 //签名不包括返回类型
类层次中 子类中的方法与超类中的方法有相同的方法签名以及相同的返回类型
子方法的名称以及子方法参数的顺序必须与父类中的方法的名称以及参数的顺序相同
覆盖规则：相同的返回类型 不能比它所覆盖的方法访问性差 不能比它所覆盖的方法抛出更多的异常
对于超类中被覆盖的方法可以使用 super.XX(); 访问

虚拟方法调用：得到与变量的运行时类型(即变量所引用的对象的类型)相关的行为 而不是与变量的编译时类型相关的行为
(注意区分于超类句柄&子类对象)

class ParentB
{
	void methodA()
		{
			System.out.println("methodA in parent");
		}
}

class ChildB extends ParentB
{
	void methodB()
		{
			System.out.println("methodB in Child");
		}

	public static void main(String[] args)
		{
			ParentB p = new ChildB();
			p.methodA();
		}
}



class Employee {

  String name;

  int salary;

  public String getDetails() {

	  System.out.println("in Employee");

    return " Name: " + name + " \n " +

       "Salary: " + salary;
  }

}

public class Manager extends Employee {

  String department = "虚拟方法调用测试";

  public String getDetails() {

	  System.out.println("in Manager");
	  System.out.println(department);

    return " Name: " + name + " \n " +

         " Manager of " + department;

  }

  public static void main(String[] args)
	  {
		Employee e = new Manager();
		e.getDetails();
	}
}




 class ParentD{

   void method() {
		System.out.println("method in Parent");
  }

}

 class ChildD extends ParentD {

   public void method() {
		System.out.println("method in Child");
  }

}

public class UseBoth {

  public static void main(String[] args) {

    ParentD p1 = new ParentD();

    ParentD p2 = new ChildD();

    p1.method();

    p2.method();

  }

}

 动态方法调度：实现运行期多态

 

final
final 变量(常量)值不可以被改变 方法不可以被覆盖 类不可被继承
如果将引用类型（即任何类的类型）的变量标记为final 那么该变量不能指向任何其它对象。但可能改变对象的内容，因为只有引用本身是final

 

 

static
static 成员变量：无需创建类实例即可通过类名直接访问 所有类实例共享一个 static 成员变量
static 方法：只能调用其他 static 方法 只能访问 static 数据 没有 this 及 super 关键字  成员方法对 static & 非static都可访问
static 块：初始化 当类第一次被加载时 static 块被执行

 

super
super 两种格式：A.调用超类构造器 super(); (必须是子类构造器中第一个执行语句) B.访问超类成员 super.member; (该成员被子类隐藏)

 

超类句柄&&子类对象
一个超类的句柄变量可以赋给从该超类派生出来的任何子类的句柄 仅此之外 不能将类型不同的一对象赋给一个句柄变量
当一个子类对象的句柄被赋给一个超类句柄变量时 只能访问超类定义的那部分对象
句柄变量的类型决定了可以访问的成员 而不是 它所指向的对象的类型

class Parent
{
	void methodA()
		{
			System.out.println("methodA in parent");
		}
}

class Child extends Parent
{
	void methodB()
		{
			System.out.println("methodB in Child");
		}

	public static void main(String[] args)
		{
			Parent p = new Child();
			p.methodA();
		}
}