Java 学习笔记三

大型软件系统中包含很多的类，Java中引入包（package）机制，是为了解决命名冲突的问题，提供类的多重类命名空间。

package语句放在Java语句的第一条语句，、

package pk1;

为了使用定义在不同包中的类，需要使用import语句，

import  pk1.Test; 或 import  pk1.*;

如：包hua2 用到包hua1中的Test类

import   hua1.Test;

Test  t=new  Test();

1、如果一个类没有声明为public，则其只能在所在的包中被引用，在其他的包中使用import语句无法引入它。

2、可以不在源文件的开头使用import语句导入要使用的包中的类，而是在使用的时候给出完整的包层次，例如：

public  class  TestPackage{

  public static void main(String  [ ] args){

    p1.Test  t=  new  p1.Test();//   给出包的层次

t.f(10);

    } 

}

3、一个类可以有一个package 语句，包的名字是小写。但是可以有一个到多个的import语句，可以使用很多的类。

如果用package，使用命令行编译class： javac   -d    .     ***.java

4、JDK中主要的包：

一、java.lang  包含了java语言程序设计的基础类。

二、java.awt    包含了用于创建图形用户界面和绘制图形图像的相关类， abstract windows toolkit

三、java.util  包含集合、日期、国际化和各种使用工具类   utility

四、java.io 包含课提供数据输入输出相关功能的类

五、java.net 提供用于实现java网络编程的相关功能类

六、 java .sql  提供数据库操作相关功能类 structed   query   language 

5、使用java.lang中的类，可以不用使用import引入

6、继承：extends

Java 是单继承，extends只能跟一个类，一个父类可以派生出多个子类。

默认的父类是Object类，public class  Person {}  等价  public  class Person  extends  Objects{}

7、类的访问控制

public类可以在任意场合被使用，但是非public类只能在所在的包中被使用，

顶级类只能为public或者缺省。

类中成员的访问控制如下：属性和方法

8、重写的方法和被重写的方法具有相同的方法名称、参数列表和返回值类型，

重写方法不能使用比被重写方法更严格的访问权限

重写方法不能声明抛出比被重写方法范围更大的异常类型

9、关键字super，在存在命名冲突的情况下，子类中的代码将自动使用子类中同名的属性和放法，也可以在子类中引用super使用父类中的方法，

访问父类中定义的属性：  

super    属性名

调用父类中定义的成员方法    super      方法名（参数列表）

子类构造方法调用父类构造方法

super的追溯不仅仅在于直接的父类

package hua1;

class Animal {
	protected int i = 1;
}

class Person extends Animal {
	protected int i = 5;
	private String name = "huahuahaolang";
	private int age = 9;

	public String getInfo() {
		return "name: " + name + ", age: " + age;
	}

	public void testI() {
		System.out.println(super.i);
		System.out.println(i);
	}
}

class Student extends Person {
	private int i = 8;
	private String school = "jai;ajg";

	public String getInfo() {
		return super.getInfo() + ", school: " + school;
	}

	public void testI() {
		System.out.println(super.i);
		System.out.println(i);
	}
}

public class Test {
	public static void main(String[] args) {
		Person p=new Person();
		System.out.println(p.getInfo());
		p.testI();
		Student s=new Student();
		System.out.println(s.getInfo());
		s.testI();
	}

}

output;name: huahuahaolang, age: 9
1
5
name: huahuahaolang, age: 9, school: jai;ajg
5
8

10、多态：在Java中，子类对象可以代替父类的对象使用。

Java引用变量与所引用对象间的类型匹配关系：

一个对象只能属于一种确定的数据类型，该对象自对象的创建直至销毁不能改变。

一个引用类型变量可能引用（指向）多种不同类型的对象，既可以引用其声明类型的对象，也可以引用其声明类型的子类的对象。 

Person  p=new  student();// Student是person的子类

 p 在栈中，Student类型的对象在堆中

引用类型的数组元素相当于引用类型变量，多态性也同样适用

Person   p=new  Person[3];

p[0]=new Student();

p[1]=new Person();

......................................

一个引用类型变量如果声明为父类的类型，但实际引用的是子类的对象，那么该变量就不能再访问子类中添加的属性和方法。

Student   m= new   Student();

m.setSchool("dffasdfasdf");

Person e=new   Student();

e.setSchool("HUST");//这是非法的，编译不通过，在Person类中找setSchool这个函数，找不到。

11、虚方法调用

正常调用：

Person   p=new  Person();

p.getInfo();

Student   s=new  Student();

s.getInfo();

虚方法调用：

Person   p=new  Student();

p.getInfo();

这是编译时类型和运行时类型

12、方法声明的参数类型是父类型，可以使用子类的对象作为实参调用该方法。

13、引用类型数据值之间的强制类型转换称为造型casting。规则如下：

从子类到父类的转换可以自动进行：Person    p  =   new  Student();

在多态的情况下，从父类到子类的类型转换必须通过造型（强制类型转换）实现， 

Person  p1=  new Student();//父类的类型，子类的对象

Student   s1=(Student)p1;//合法的 

Person  p2 = new  Person();

Student   s2 =  (Student) p2;//这是非法的

无继承关系的引用类型间的转换是非法的。

String  s="hello  world" ;

Person   p=  (Person ) s;// 非法的 

14、运算符：instanceof用于检测一个对象的真正类型

class  Person{}
class  Student   extends   Person{}
class  Graduate   extends   Student{}
public  class Tool{
	public void distribute(Person p){
		if(p instanceof Graduate){
			Graduate g=(Graduate)p;
		}
		else  if(p instanceof  Student){
			
		}else {
			
		}
	}
}

15、协变返回类型：重写方法的时候，修改其返回值类型，但必须是重写前方法返回值类型的子类或实现类类型

class A{
	public Person getAssistor(){
		Person p=new Person();
		return p;
	}
}
class B extends A{
	public Student getAssistor(){//重写方法时改变了返回值类型
		Student s=new Student();
		s.setName("Nancy");
		s.setAge(25);
		s.setSchool("HUST");
		return s;
	}
}

15、子类使用父类的构造方法：super(参数列表)

调用无参数父类构造方法：super( );

用this（）调用同一个类中其他的重载的构造方法

public  Person(String name, int age){

super (name);//必须放在 第一行，并且super(name)和this(name)只能有一个

this. age=age;

}

16、static属性由其所在的类共享，而非static属性则必须依赖具体的对象而存在。

静态成员函数只能使用静态属性和静态方法。

public class Person{

public  static int toal=1900;

}

public  class Test{

public static void main(){

Person.total=100;//可以通过类名直接访问

}

}

17、static初始化块，static块仅在其所属的类被载入时执行一次，通常用于初始化static类属性

class  Person{

public static int total;

static{

total=100;

System.out.println();

}

}

非static的初始化在创建对象的时候被自动调用

class A{
	private int a=10;
	{
		System.out.println("create");
	}
	A(){
		System.out.println("hua");
	}
	A(int i){
		a=i;
		System.out.println("huahua");
	}
}
public class TestTool {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new A();
		new A(4);
	}

}

output:

create
hua
create
huahua

18、静态导入:在一个类中导入其他类或接口中的static成员，语法格式：

import  static <包路径>.<类名>.*或import  static <包路径>.<类名>.静态成员名

19、单例模式：

class Single{
	private String name;
	private static Single onlyone=new Single();
	private Single(){}
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public static Single getSingle(){
		return onlyone;
	}
}
public class TestSingle {

	public static void m1(){
		Single s2=Single.getSingle();
		System.out.println(s2.getName());
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Single s1=Single.getSingle();
		s1.setName("HST");
		m1();//静态方法使用静态成员函数
	}

}

output：HST

20、final 关键字，修饰类、变量、方法。

final修饰的类不能被继承；

final修饰的方法不能被重写；

final修饰的变量成为常量，只能被赋值一次。final修饰的成员变量只能在声明的同时或者在每个构造方法中显示赋值；

public class TestSingle {
final int a;
TestSingle(){
a=2;
}

}

final不允许修饰构造方法、抽象类和抽象方法

 final class Test{//不能被继承
	public static int totalNumber=5;
	public final int id;//初始化
	public Test(){
		id=++totalNumber;
	}
	public static void main(String []args){
		Test t=new Test();
		System.out.println(t.id);
		final int i=9;//初始化
		final int j;
		j=1;//初始化
	}
}