Java面向对象编程，包、继承、组合、多态、抽象类、接口
了解java面向对象编程，了解基本语法
目录
- 1.包
- 2.包的访问权限控制
- 3.继承
- 4.protected 关键字
- 5.final 关键字
- 6.组合
- 7.多态
-
- 7.1向上转型
- 7.2动态绑定
- 7.3方法重写
- 7.4向下转型
- 7.5静态绑定
- 7.6super 关键字
- 7.7在构造方法中调用重写的方法(一个坑)
- 8.抽象类
- 9.接口
-
- 8.1实现多个接口
- 8.2接口间的继承
- 8.3接口的使用
- 8.4常用接口
-
- 8.4.1Comparable
- 8.4.2Comparator
- 8.4.3Clonable
1.包
包 (package) 是组织类的一种方式.使用包的主要目的是保证类的唯一性.
import
导入包中的类
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
import java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
比如 java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}
这样就会编译失败，Date不明确。应该：
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
System.out.println(date.getTime());
}
}
使用 import static 可以导入包中的静态的方法和字段.
import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 30;
double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));
System.out.println(result);
}
}
将类放到包中的基本规则
- 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
- 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如
com.cqupt.demo1. - 包名要和代码路径相匹配. 例如创建
com.cqupt.demo1的包, 那么会存在一个对应的路径com/cqupt/demo1来存储代码. - 如果一个类没有 package 语句, 则该类被放到一个默认包中.
2.包的访问权限控制
我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用.(包访问权限）
3.继承
语法：
class 子类 extends 父类 {
}
class Animal {
public String name;
public int age;
private int count;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println("eat()");
}
}
class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
}
class Bird extends Animal {
public Bird(String name, int age,String swing) {
super(name, age);
this.swing=swing;
}
public String swing;
public void fly() {
System.out.println(name + "fly()"+swing);
}
}
public class TestDemo {
public static void main(String[] args) {
Animal animal=new Dog("jenny",23);//父类引用 引用 子类对象
}
public static void main1(String[] args) {
Dog dog = new Dog("jenny",22);
System.out.println(dog.name);
dog.eat();
Bird bird = new Bird("james",45,"我要的飞翔");
System.out.println(bird.name);
bird.eat();
bird.fly();
}
}
1. 使用 extends 指定父类.
2. Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
3. 子类会继承父类的所有 public 的字段和方法.
4. 对于父类的 private 的字段和方法, 子类中是无法访问的.
5. 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用
4.protected 关键字
刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 “封装” 的初衷.
两全其美的办法就是 protected 关键字：
对于类的调用者来说, protected 修饰的字段和方法是不能访问的
对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的
总结：:Java 中对于字段和方法共有四种访问权限
- private: 类内部能访问, 类外部不能访问
- 默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
- protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
- public : 类内部和类的调用者都能访问
5.final 关键字
6.组合
和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。
组合表示 has - a 语义
一个学校中 “包含” 若干学生和教师.。
public class Student {
...
}
public class Teacher {
...
}
public class School {
public Student[] students;
public Teacher[] teachers;
}
7.多态
使用多态的好处是什么?
- 类调用者对类的使用成本进一步降低.
封装是让类的调用者不需要知道类的实现细节.
多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可.
因此, 多态可以理解成是封装的更进一步, 让类调用者对类的使用成本进一步降低 - 够降低代码的 “圈复杂度”, 避免使用大量的 if - else
- 可扩展能力更强.
class Shape {
public void draw() {
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("◇");
}
}
class Flower extends Shape {
@Override
public void draw() {
System.out.println("❀");
}
}
class Triangle extends Shape {
@Override
public void draw() {
System.out.println("△");
}
}
class Circle extends Shape {
@Override
public void draw() {
System.out.println("●");
}
}
public class Test {
public static void main(String[] args) {
Rect rect = new Rect();
Flower flower = new Flower();
Triangle triangle = new Triangle();
Circle circle=new Circle();
Shape[] shapes = {rect, flower, triangle, circle};
for (Shape shape:shapes) {
shape.draw();
}
}
public static void drawMap(Shape shape) {
shape.draw();
}
//多态:不同对象调用同一个方法产生不同的结果效果
public static void main1(String[] args) {
Rect rect = new Rect();
drawMap(rect);
Flower flower = new Flower();
drawMap(flower);
Triangle triangle = new Triangle();
drawMap(triangle);
}
}
7.1向上转型
public static void main1(String[] args) {
//向上转型
Animal animal = new Dog("jenny", 23);//父类引用 引用 子类对象
Dog dog = new Dog("james", 55);
func(dog);
}
此时 animal 是一个父类 (Animal) 的引用, 指向一个子类 (Dog) 的实例. 这种写法称为 向上转型.
7.2动态绑定
//动态绑定
public static void main2(String[] args) {
Animal animal = new Dog("jenny", 23);//父类引用 引用 子类对象
animal.eat();
Animal animal2 = new Bird("jjj", 45, "ijh");
animal2.eat();
//通过父类的引用 只能访问父类自己的成员
System.out.println(animal2.name);
}
在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定
7.3方法重写
子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为 覆写/重写/覆盖(Override)
注意：
- 重写和重载完全不一样. 不要混淆(思考一下, 重载的规则是啥?)
- 普通方法可以重写, static 修饰的静态方法不能重写
- 重写中子类的方法的访问权限不能低于父类的方法访问权限.
- 重写的方法返回值类型不一定和父类的方法相同(但是建议最好写成相同, 特殊情况除外）
class Animal {
public String name;
public int age;
private int count;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name + "eat()");
}
}
class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println(name + " 狼吞虎咽的 eat()");
}
//重载
public void func(int a) {
System.out.println(a);
}
public void func(int a, int b) {
System.out.println(a + b);
}
public void func(int a, int b, double n) {
System.out.println(a + b + n);
}
}
class Bird extends Animal {
public Bird(String name, int age, String swing) {
super(name, age);
this.swing = swing;
}
public String swing;
public void fly() {
System.out.println(name + "fly()" + swing);
}
}
Dog类中重写父类Animal中的eat()方法.
7.4向下转型
向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象. 相比于向上转型来说, 向下转型没那么常见.不是很安全
7.5静态绑定
//重载
public void func(int a) {
System.out.println(a);
}
public void func(int a, int b) {
System.out.println(a + b);
}
public void func(int a, int b, double n) {
System.out.println(a + b + n);
}
//静态绑定
public static void main3(String[] args) {
Dog dog = new Dog("jenny", 34);
dog.func(3);
dog.func(2, 4);
dog.func(4, 5, 3.88);
}
7.6super 关键字
前面的代码中由于使用了重写机制, 调用到的是子类的方法. 如果需要在子类内部调用父类方法怎么办? 可以使用super 关键字.
7.7在构造方法中调用重写的方法(一个坑)
我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func：
class B {
public B() {
// do nothing
func();
}
public void func() {
System.out.println("B.func()");
}
}
class D extends B {
private int num = 1;
@Override
public void func() {
System.out.println("D.func() " + num);
}
}
public class Test {
public static void main(String[] args) {
D d = new D();
}
}
//运行结果：D.func()0
1. 构造 D 对象的同时, 会调用 B 的构造方法.
2. B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
3. 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0
8.抽象类
- 包含抽象方法(没有具体实现的方法，被abstract修饰）的类
- 抽象类不能被实例化
- 不能被实例化，其实这个类只能被继承
- 抽象类中也可以包含普通的成员和方法
- 普通类，继承一个抽象类，普通类需要重写抽象类中所有的抽象方法
- 抽象类最大的作用就是被继承
- 如果抽象类B继承抽象类A，那么抽象类B可以不实现抽象父类A中的抽象方法
- 结合上一句，当B类被普通类继承，那么A和B这两个抽象类中的抽象方法必须在普通类重写
- 抽象类不能被final所修饰
- 抽象方法也不能被final修饰
abstract class Shape {
public abstract void draw();//抽象方法
}
//如果抽象类B继承抽象类A，那么抽象类B可以不实现抽象父类A中的抽象方法
abstract class A extends Shape{
public abstract void funcA();
}
//当B类被普通类继承，那么A和B这两个抽象类中的抽象方法必须在普通类重写
class B extends A{
@Override
public void draw() {
}
@Override
public void funcA() {
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("◇");
}
}
class Flower extends Shape {
@Override
public void draw() {
System.out.println("❀");
}
}
class Triangle extends Shape {
@Override
public void draw() {
System.out.println("△");
}
}
class Circle extends Shape {
@Override
public void draw() {
System.out.println("●");
}
}
public class Test {
//动态绑定
public static void drawMap(Shape shape){
shape.draw();
}
public static void main(String[] args) {
//Shape shape=new Shape();//error,抽象类不能被实例化
Shape shape=new Rect();//抽象类可以发生向上转型，子类对象赋值给父类引用
drawMap(shape);//动态绑定
}
}
抽象类的作用
- 抽象类存在的最大意义就是为了被继承.
- 抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。
9.接口
接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量。
- 使用interface实现
- 接口中的方法不能有具体实现；如果要具体实现，在前面加default来修饰这个方法。
- 接口中可以有static方法
- 里面所有方法默认public的，
- 抽象方法默认是public abstract
- 接口不能被实例化
- 接口和类之间用implements
- 当类实现接口，就要重写接口中的抽象方法
- 接口中的成员变量默认是由public static final修饰
- 当一个类实现一个接口之后，重写接口中的方法，方法前面必须加public
- 一个类可以通过extends继承抽象类或者普通类，但是只能继承一个；同时可通过implements实现多个接口，接口之间通过’,'隔开
- 接口接口之间通过extends来拓展；当一个类实现一个接口C，但是接口C又拓展接口D，那么 这个类要重写接口C和D中所有的方法
interface IShape {
public abstract void draw();//抽象方法
/* default public void func() {
System.out.println("ffff");
}
default public void func2() {
System.out.println("4332");
}
public static void funcStatic() {
System.out.println("sat");
}*/
}
//当类实现接口，就要重写接口中的抽象方法
class Rect implements IShape {
@Override
public void draw() {
System.out.println("◇");
}
}
class Flower implements IShape {
@Override
public void draw() {
System.out.println("❀");
}
}
class Triangle implements IShape {
@Override
public void draw() {
System.out.println("△");
}
}
class Circle implements IShape {
@Override
public void draw() {
System.out.println("●");
}
}
public class Test {
public static void drawMap(IShape iShape) {
iShape.draw();
}
//动态绑定
public static void main(String[] args) {
Rect rect = new Rect();
Flower flower = new Flower();
drawMap(rect);
drawMap(flower);
}
public static void main1(String[] args) {
//IIShape IIShape=new IIShape();//error,不能被实例化
IShape IShape = new Rect();
IShape.draw();
}
}
接口中只能包含抽象方法. 对于字段来说,接口中只能包含静态常量(final static).
interface IA {
public static final int A = 10;//成员变量默认是常量
int B = 10;//public static final
void funcA();//public abstract
}
class A implements IA{
@Override
public void funcA() {//子类重写父类的方法，必须加public，
// 子类的访问权限范围大于等于父类，父类默认是public
System.out.println("A::funcA");
}
}
8.1实现多个接口
interface IA {
public static final int A = 10;//成员变量默认是常量
int B = 10;//public static final
void funcA();//public abstract
}
interface IB {
void funcB();
}
abstract class BClass {
}
class AClass extends BClass implements IA, IB {
@Override
public void funcA() {
System.out.println("A::funcA()");
System.out.println(A);
}
@Override
public void funcB() {
System.out.println("A::funcB()");
}
}
一个类可以通过extends继承抽象类或者普通类，但是只能继承一个；同时可通过implements实现多个接口，接口之间通过’,'隔开
8.2接口间的继承
接口接口之间通过implements来拓展；当一个类实现一个接口C，但是接口C又拓展接口D，那么 这个类要重写接口C和D中所有的方法
interface IA1 {
void funcA();
}
interface IB1 extends IA1 {
void funcB();
}
class C implements IB1 {
@Override
public void funcA() {
System.out.println("IA1::funcA");
}
@Override
public void funcB() {
System.out.println("IB1::funcB");
}
}
8.3接口的使用
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
//不是所有的动物都可以飞
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
class Bird extends Animal implements IFlying {
public Bird(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在飞！");
}
}
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在游泳");
}
}
class Duck extends Animal implements IRunning, IFlying, ISwimming {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在飞！");
}
@Override
public void run() {
System.out.println(this.name + "正在跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在游泳");
}
}
class Roobot implements IRunning{
@Override
public void run() {
System.out.println("机器人在跑！");
}
}
public class Test4 {
public static void runFunc(IRunning iRunning) {
iRunning.run();
}
public static void swimFunc(ISwimming iSwimming) {
iSwimming.swim();
}
public static void flyFunc(IFlying iFlying) {
iFlying.fly();
}
public static void main(String[] args) {
runFunc(new Duck("鸭子"));
runFunc(new Frog("青蛙"));
new Roobot().run();
}
public static void main3(String[] args) {
flyFunc(new Duck("鸭子"));
flyFunc(new Bird("小鸟"));
}
public static void main2(String[] args) {
swimFunc(new Duck("鸭子"));
swimFunc(new Frog("青蛙"));
}
public static void main1(String[] args) {
runFunc(new Duck("鸭子"));
runFunc(new Frog("青蛙"));
}
}
8.4常用接口
8.4.1Comparable
这个接口有很大的缺点，对类的侵入性非常强，不敢轻易改动。
如果自定义数据类型进行大小比较，一定要实现可比较的接口
class Student implements Comparable<Student> {
public int age;
public String name;
public double score;
public Student(int age, String name, double score) {
this.age = age;
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
", score=" + score +
'}';
}
@Override
//谁调用这个方法，这就是this
public int compareTo(Student o) {
/*if (this.age > o.age) {
return 1;
} else if (this.age == o.age) {
return 0;
} else {
return -1;
}*/
//return this.age-o.age;//从小到大
return o.age-this.age;//从大到小
}
}
public class Test {
public static void main2(String[] args) {
Student students1 = new Student(12, "kkk", 99.8);
Student students2 = new Student(32, "lll", 67.8);
/*if(students1.compareTo(students2)>0){
}*/
System.out.println(students1.compareTo(students2));
}
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student(12, "kkk", 99.8);
students[1] = new Student(32, "lll", 67.8);
students[2] = new Student(22, "zzz", 90.5);
System.out.println(Arrays.toString(students));
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
public static void main1(String[] args) {
int[] array = {1, 21, 3, 14, 5, 16};
System.out.println(Arrays.toString(array));
Arrays.sort(array);//从小到大排序
System.out.println(Arrays.toString(array));
}
}
8.4.2Comparator
对类的侵入性非常弱。
class Student {
public int age;
public String name;
public double score;
public Student(int age, String name, double score) {
this.age = age;
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
", score=" + score +
'}';
}
}
class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
class ScoreComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return (int) (o1.score - o2.score);
}
}
class NameComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);
}
}
public class Test {
//根据名字比较
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student(24, "kkk", 99.8);
students[1] = new Student(12, "all", 87.8);
students[2] = new Student(22, "zzz", 79.5);
System.out.println(Arrays.toString(students));
NameComparator nameComparator=new NameComparator();
Arrays.sort(students, nameComparator);
System.out.println(Arrays.toString(students));
}
//根据成绩
public static void main4(String[] args) {
Student[] students = new Student[3];
students[0] = new Student(24, "kkk", 99.8);
students[1] = new Student(12, "lll", 87.8);
students[2] = new Student(22, "zzz", 79.5);
System.out.println(Arrays.toString(students));
ScoreComparator scoreComparator = new ScoreComparator();
Arrays.sort(students, scoreComparator);
System.out.println(Arrays.toString(students));
}
public static void main3(String[] args) {
Student students1 = new Student(12, "kkk", 99.8);
Student students2 = new Student(2, "lll", 67.8);
/*if(students1.compareTo(students2)>0){
}*/
//System.out.println(students1.compareTo(students2));
AgeComparator ageComparator = new AgeComparator();
System.out.println(ageComparator.compare(students1, students2));
}
//根据年龄
public static void main2(String[] args) {
Student[] students = new Student[3];
students[0] = new Student(24, "kkk", 99.8);
students[1] = new Student(12, "lll", 87.8);
students[2] = new Student(22, "zzz", 79.5);
System.out.println(Arrays.toString(students));
AgeComparator ageComparator = new AgeComparator();
Arrays.sort(students, ageComparator);
System.out.println(Arrays.toString(students));
}
}
8.4.3Clonable
创建对象的方式：
- new关键字
- clone()方法
对象实现cloneable接口，里面必须重写clone()方法：
将Person进行克隆为person2：
Person person = new Person();
person.age = 99;
Person person2 = (Person) person.clone();
class Person implements Cloneable {
public int age;
public void eat() {
System.out.println("吃！");
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class TestDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Person person = new Person();
person.age = 99;
Person person2 = (Person) person.clone();
System.out.println(person2);
System.out.println("================");
person2.age = 199;
System.out.println(person);
System.out.println(person2);
}
}
