包(package)
包是组织类的一种方式,使用包的主要目的是保证类的唯一性。
导入包中的类
一、
1.
public class Test{
public static void main(String[] args){
//得到一个毫秒级的时间戳
java.util.Date date = new java.util.Date();
System.out.println(date.gettime());
}
}
2.
import java.util.Date;//使用java中的Date类
public class Test{
public static void main(String[] args){
//得到一个毫秒级的时间戳
Date date = new Date();
System.out.println(date.gettime());
}
}
//使用java中的类就可以有如下写法:
java.util.*
//但还是建议要加上导入的类名,否则容易冲突。
二、导入包中的静态方法和字段
使用import static
eg:import static java.lang.*;
三、将类放到包中
- 在文件的最上方加入package语句,来指定此代码在哪个包中。
- 包名要和代码路径相匹配,如果创建的包是com.demo,则会有一个相对应的路径com/demo,用来存储代码。
- 如果一个类中没有package语句,那么这个类就会被放进一和默认包中。
四、包访问权限控制
public : 公开的,public 修饰的字段和方法对所有的用户开放,即类内部和类的调用者都能访问。
private: 私有的,private 修饰的字段和方法只能被类的内部使用
默认default(也叫包访问权限): 类内部、同一个包的类都可访问,其他类不能
protected: **类内部能访问,一个类的子类和同一个包的类可以访问 ,其他类不能访问。
继承
基本语法
class 父类 extents 父类{
}
使用extends指定父类;
java中一个子类只能继承一个父类(所以java是一门单继承的语言);
子类继承的是父类的所有public 的字段和方法;
对于父类private修饰的字段和方法,子类时无法访问的。
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{ //让Cat继承Animal类
public Cat(String name){
super(name); //super调用父类的构造方法
}
}
class Bird extends Animal{ //让Bird继承Animal类
public Bird(String name){
super(name);
}
public void fly(){
System.out.println(this.name+"正在飞");
}
}
public class TestDemo1 {
public static void main(String[] args) {
Cat cat = new Cat("小花");
cat.eat("猫粮");
Bird bird = new Bird("小明");
bird.fly();
输出结果:小花正在吃猫粮
小明正在飞
final
final关键字,修饰一个变量和字段的时候,表示常量(不能修改),功能是限制类被继承。
多态
向上转型
子类对象赋值给父类称为向上转型(或父类引用子类对象)
Bird bird = new bird("小花");
//也可以写成下面形式
Bird bird = new bird("小花");
Animal animal = bird;
//或者下面形式
Animal animal = new cat("小花");
//animal是父类的引用,指向一个子类Bird的实例。
向上转型发生的时机:直接赋值;方法传参;方法返回。
向下转型
if(animal instance of bird){//首先要判断bird是否是animal的实例
Bird brid = (Bird) animal;//需要强制类型转化
bird.fly();
}
//(Bird)表示强制类型转换;
向下转型的条件:父类已经引用了子类(向下转型后的类型)的对象
向下转型就是父类对象转成子类对象,相对于向上转型,向下转型不太常见。
动态绑定
public class Test {
public static void main(String[] args) {
Animal animal1 = new Animal("小花");
animal1.eat("谷子");
Animal animal2 = new Bird("小明");
animal2.eat("谷子");
}
}
//animal1 和 animal2 虽然都是 Animal 类型的引用, 但是 animal1 指向 Animal 类型的实例, animal2 指向Bird 类型的实例.
//针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而animal2.eat()实际调用了子类的方法。
因此, 在 Java 中, 调用某个类的方法, 究竟执行的是父类方法的代码还是子类方法的代码 , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定.
发生运行时绑定(动态绑定)的条件:1.先要向上转型(父类的引用引用子类的对象)2.父类和子类都有同名的覆盖方法(此方法之间的关系就是重写)
方法重写
对于上面动态绑定中的代码中,对eat方法来说,子类实现了父类的同名方法,并且参数类型和个数完全相同,所以称为覆写/重写/覆盖(Override)
重写的规则:
普通方法可以重写,static修饰的静态方法不能重写。
重写中子类的方法的访问权限不能低于父类的方法访问权限
多态
class Shape {
public void draw() {
}
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("○");
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("□");
}
}
// Test.java
public class Test {
public static void main(String[] args) {
Shape shape1 = new Cycle();
Shape shape2 = new Rect();
drawMap(shape1);
drawMap(shape2);
}
// 打印单个图形
public static void drawShape(Shape shape) {
shape.draw();
}
}
当类的调用者在编写 drawMap 这个方法的时候,参数类型为 Shape (父类), 此时在该方法内部并不知道, 也不关注当前的 shape 引用指向的是哪个类型(哪个子类)的实例.
此时 shape 这个引用调用 draw 方法可能会有多种不同的表现(和 shape 对应的实例相关),这种行为就称为多态。
抽象的抽象类
abstract class Shape{//对于包含抽象方法的类,必须加上abstract表示这是一个抽象类
abstract public void draw();//这是一个抽象方法,没有方法体。
}
1.抽象类不能实例化;
2.抽象方法不能是private的;
3.抽象类中可以包含其他非抽象方法,也可以包含字段。这个非抽象方法同普通方法,可以被重写,可以被子类直接调用。
作用
抽象类存在的最大意义就是为了被继承
抽象类本身不能被实例化,如果要使用,只能创建该抽象类的子类,再让子类重写抽象类中的抽象方法。
接口
接口包含的方法都是抽象方法,字段只能包含静态常量。
interface IShape {//使用interface定义一个接口
void draw(); //接口的方法一定是public abstract,因此可以省略
}
class Cycle implements IShape { //Cycle使用implements继承接口.此时表达的含义是 "实现"
@Override
public void draw() {
System.out.println("○");
}
}
public class Test {
public static void main(String[] args) {
IShape shape = new Rect();
shape.draw();
}
}
接口中只能包含抽象方法,对于字段,接口中只能包含静态变量(final static)
interface IShape {
void draw();
public static final int num = 10;
}
- 我们创建接口的时候, 接口的命名一般以大写字母 I 开头.
- 接口的命名一般使用 “形容词” 词性的单词.
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号