面向对象1

包（package）

组织类的一种方法；
使用包的主要目的是保证类的唯一性。

如何导入包中的类

1. 可以使用java.util.Data这种方式引入java.util这个包中的Data类。（比较麻烦）
2. import引入：

import java.util.Data;
Public class Test{
Public static void main(String[] args) {
	Data data = new Data;
	System.out.println(data.getTime());
	}
}

3.如果需要使用java.util中的其他类，可以使用import java.util.*
4.若同时导入两个包时，如 java.util.*和java.sql.*同时导入时，util 和 sql 中都存在一个Data 这样的类，此时就会出现歧义，编译出错。在这种情况下需要使用完整的类名。

import java.util.*;
import java.sql.*;
public class Test {
	public static void main (String[] args) {
		java.util.Data data = new java.util.Data();
		System.out.println(data.getTime());
	}
}

注意事项：import 和 C++ 的#include 差别很大，C++必须#include 来引入其他文件内容，但是java不需要。
import 只是为了写代码的时候方便；import更类似于C++的namespace和using

静态导入

使用 import static 可以导入包中的静态的方法和字段

import static java.lang.System.*;
public class Test {
	public static void main(String[] args) {
		out.println("hello");
	}
}

将类放入包中

基本规则：
1.在文件的最上方加上一个package语句指定该代码在哪个包中；
2.包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式（如：com.baidu.demo）；
3.包名要和代码路径相匹配，例如创建一个com.baidu.demo的包，那么会存在一个对应的路径com/baidu/demo来存储代码；
4.如果一个类没有package语句，则该类被放到一个默认包中

包的访问权限控制

如果某个成员不包含public 和 private 关键字，此时这个成员可以在包内部的其他类使用，但是不能在包外部的类使用
常见的系统包
1.java.lang 系统常用基础类（String、Object），此包从JDK1.1后自动导入；
2.java.lang.reflect:java反射编程包；
3.java.net:进行网络编程开发包；
4.java.sql:进行数据库开发的支持包；
5.java.util:是java提供的工具类程序包；
6.java.io:I/O编程开发包。

继承

背景
代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.
例如, 设计一个类表示动物

// Animal.java 
public class Animal {     
	public String name;          
	public Animal(String name) {      
		this.name = name;     
	}          
	public void eat(String food) {         
		System.out.println(this.name + "正在吃" + food);     
	}
} 
 
// Cat.java 
class Cat {  
	public String name;          
	public Cat(String name) {      
		this.name = name;     
	}          
	public void eat(String food) {         
		System.out.println(this.name + "正在吃" + food);     
	} 
} 
 
// Bird.java 
class Bird {  
	public String name;          
	public Bird(String name) {         
		this.name = name;     
	}          
	public void eat(String food) {         
		System.out.println(this.name + "正在吃" + food);     
	}          
	public void fly() {         
		System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");     
	} 
}

Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系:
这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.
从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义). 此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.
语法规则：

class 子类 extends 父类 {     

} 

1.使用 extends 指定父类.
2.Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
3.子类会继承父类的所有 public 的字段和方法. 对于父类的 private 的字段和方 法, 子类中是无法访问的.
4.子类的实例中, 也包含着父类的实例.
5.可以使用 super 关键字得到父类实例的引用

对于上面的代码，我们可以用继承改进此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再 写 name 字段和 eat 方法.

class Animal {     
	public String name; 
    public Animal(String name) {         
    	this.name = name;     
    } 
    public void eat(String food) {         
    	System.out.println(this.name + "正在吃" + food);     
    } 
} 
class Cat extends Animal {     
	public Cat(String name) {         
		// 使用 super 调用父类的构造方法.          
		super(name);     
	} 
} 
class Bird extends Animal {     
	public Bird(String name) { 
		super(name);     
	} 
    public void fly() {         
    	System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");     
    } 
} 
 
public class Test {     
	public static void main(String[] args) {         
		Cat cat = new Cat("小黑");         
		cat.eat("猫粮");         
		Bird bird = new Bird("圆圆");         
		bird.fly();     
	} 
} 

如果我们把 name 改成 private, 那么此时子类就不能访问了

protected 关键字

对于类的调用者来说, protected 修饰的字段和方法是不能访问的
对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的

小结：Java 中对于字段和方法共有四种访问权限
1.private: 类内部能访问, 类外部不能访问
2.默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
3.protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问. 4.public : 类内部和类的调用者都能访问。

final 关键字

final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.