【Java学习】面向对象编程（二）【详解篇14】

最新推荐文章于 2023-04-22 20:39:55 发布
最新推荐文章于 2023-04-22 20:39:55 发布
阅读量376 收藏 2
点赞数 2
分类专栏： 数据结构 java篇 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59157222/article/details/120443661
版权

文章目录

抽象类

什么是抽象类？

普通类代码示例：

 class Shape {//此时这个Shape类里面的方法没有具体的实现
    public void draw(){//如果一个方法没有具体的实现，那么这个方法就可以是一个抽象方法。
        
    }
 }

1.抽象方法：一个方法如果被abstract修饰，那么这个方法就是抽象方法。抽象方法可以没有具体的的实现。直接就可以以分号结束。
2.包含抽象方法的类，叫做抽象类。需要用关键字abstract来修饰这个类。

抽象类代码示例：

abstract class Shape {//抽象类Shape
    public abstract void draw();//此时可以给draw方法加一个abstract关键字，如果一个方法被abstract所修饰，那么这个方法叫做抽象方法

}

也就是说抽象类里面一定是包含抽象方法的，当然不包含也可以，但是如果类里面有一个方法是抽象方法，那么这个类就一定要给它声明成抽象类。

抽象类需要注意的点

1.抽象类不可以被实例化,普通的类可以实例化一个对象，但是抽象类不能够实例化一个对象，所以不能这样写Shape shape=new Shape();

代码示例：

abstract class Shape {//抽象类Shape
    public abstract void draw();//此时可以给draw方法加一个abstract关键字，如果一个方法被abstract所修饰，那么这个方法叫做抽象方法
}
public class TestDemo1 {
    public static void main(String[] args) {
        Shape shape=new Shape();//error：抽象类不可以被实例化
    }
}

image-20210914110607175

2.抽象类（类内的数据成员）和普通类没有太多区别，唯一的区别就是普通类可以被实例化，抽象类不可。

代码示例：

abstract class Shape {//抽象类Shape
    public abstract void draw();//抽象方法 
    public int age;//成员属性
    private int name;
    public void func(){//成员方法
        
    }
}

抽象类存在的作用是什么？

3.抽象类存在的最大意义就是为了被继承。

4.如果一个类继承了抽象类，那么这个类必须要重写这个抽象类当中的抽象方法，不重写就会报错。

代码示例：

abstract class Shape {//抽象类Shape
    public abstract void draw();//抽象方法
   
    }
  class Cycle extends Shape {//普通类Cycle继承抽象类Shape
      @Override  //Override是重写的意思， @Override叫做注解，给一个方法加上注解说明这个方法是可以重写的方法，
     //如果一个类继承了抽象类，那么这个类必须要重写这个抽象类当中的抽象方法，不重写就会报错。
      public void draw(){//实现方法的重写
          System.out.println("画一个○");
      }
  }
    class React extends Shape {//普通类React继承抽象类Shape
        @Override   //重写快捷键：ctrl+O或alt+insert;
        public void draw() {//实现方法的重写
            System.out.println("画一个♦");
        }
    }
    class Quert extends Shape {
        @Override
        public void draw() {
            System.out.println("画一个□");
        }
    }
    class Flower extends Shape{
        @Override
        public void draw() {
            System.out.println("画一朵❀");
        }
    }

5.如果不想重写抽象类当中的抽象方法，可以在继承抽象类的这个类前面加上abstract，让他也变成抽象类，此时就成了抽象类继承抽象类。但是如果一个类想要继承抽象类继承抽象类的类，还是需要重写抽象类当中的继承方法的，否则这个类就会报错。

（即：当抽象类A继承抽象类B,那么A可以不重写B中的方法,但是一旦A要是再被继承，那么一定还要重写这个抽象方法。）

代码示例：

abstract class Shape {//抽象类Shape
    public abstract void draw();//抽象方法
   
    }
abstract  class React extends Shape {//抽象类React继承抽象类Shape

    }
class Flower extends React{//普通类继承抽象类React
    @Override//重写抽象方法
    public void draw() {
        System.out.println("画一朵❀");  
    }

image-20210914100406059
6.类和方法之所以声明为抽象的就是为了被继承再重写，所以抽象类或者是抽象方法一定是不能被final和private修饰的，因为一旦被修饰就不能重写抽象方法了。
image-20210914105828953
image-20210914105651482
7.虽然Shape这个类不能被实例化对象了，但是它仍然可以发生向上转型,多态和运行时绑定。

abstract class Shape {//此时这个Shape类里面的方法没有具体的实现
    public abstract void draw();//如果一个方法没有具体的实现，那么这个方法就可以是一个抽象方法。
}   
    class Cycle extends Shape {//Cycle继承抽象类Shape
        @Override  //Override是重写的意思， @Override叫做注解，给一个方法加上注解说明这个方法是可以重写的方法，
        //如果一个类继承了抽象类，那么这个类必须要重写这个抽象类当中的抽象方法，不重写就会报错。
        public void draw() {//实现方法的重写
            System.out.println("画一个○");
        }
    }
    class React extends Shape {//React继承抽象类Shape
        @Override
        public void draw() {
            System.out.println("画一个♦");
        }
    }
    class Flower extends React {
        @Override
        public void draw() {
            System.out.println("画一朵❀");
        }
        class Quert extends Shape {
            @Override
            public void draw() {
                System.out.println("画一个□");
            }
        }
    }
    public class TestDemo1 {
        public static void drawMap(Shape shape) {
            shape.draw();
        }
        public static void main(String[] args) {
            //Shape shape=new Shape();//抽象类不可以被实例化
            //虽然Shape这个类不能被实例化对象了，但是它仍然可以发生向上转型,多态和运行时绑定
            Shape shape1 = new Cycle();
            Shape shape2 = new React();
            Shape shape3 = new Flower();
            drawMap(shape1);
            drawMap(shape2);
            drawMap(shape3);
        }
    }

打印结果：image-20210914110426048

面试小问题：

抽象类和普通类的区别是什么？

答：抽象类内的数据成员和普通类没有太多区别，唯一的区别就是普通类可以被实例化，抽象类不可

抽象类和接口的区别是什么？

答：想要回答这个问题我们得学习什么是接口。

接口

什么是接口？

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量。

接口的代码示例：

interface IShape {//我们创建接口的时候, 接口的命名一般以大写字母 I 开头.
    void draw();
    //接口中的方法一定是抽象方法, 因此可以省略 abstract
    //接口中的方法一定是 public, 因此可以省略 public
}
class Cycle implements IShape {//Cycle 使用 implements 继承接口. 此时表达的含义不再是 "扩展", 而是 "实现"
    @Override
    public void draw() {
        System.out.println("○");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        IShape shape = new Cycle();//在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
        // shape:接口引用，对应 new Cycle()：子类实例
        shape.draw();
    }
}

语法规则：

  • 使用 interface 定义一个接口

  • 接口中的方法一定是抽象方法, 因此可以省略 abstract

  • 接口中的方法一定是 public, 因此可以省略 public

  • Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”

  • 在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.

  • 接口不能单独被实例化

扩展(extends) 和实现(implements)的区别

扩展指的是当前已经有一定的功能了, 进一步扩充功能.

实现指的是当前啥都没有, 需要从头构造出来.

实现接口的八大注意事项

1、接口当中的方法都是抽象方法。

image-20210916111805306

2、其实可以有具体实现的方法，这个方法是被default修饰的。（在JDK1.8中加入的），但是一般情况下不使用它。

image-20210916111636408

3、接口当中定义的成员变量，默认是常量，而抽象类和普通类当中默认的就不是常量，除非给他们加一个final才是常量。

interface Shape{//Shape就是一个接口
    public static final int a=10;//接口当中定义的成员变量，默认是常量
}
public class TestInterFace {

}

4、在抽象类当中什么类型的成员变量都可以定义，但是在接口当中定义的成员变量一定是被public static final所修饰，并且对于字段来说, 接口中只能包含静态常量(final static).

而方法都默认为public abstract，如果写成private或protected就会报错。

总之就是一句话，接口当中的成员变量默认是：public static final，成员方法是： public abstract。

interface Shape{//Shape就是一个接口
    public abstract void draw();//抽象方法
    public static final int num=10;//接口当中定义的成员变量（字段），默认是静态常量
    //接口当中的成员变量默认是：public static final，成员方法是： public abstract,
    //所以也可以这样写。
    int num=10;
    void draw();
}
public class TestInterFace {

}

其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量.

提示:
1.我们创建接口的时候, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

5、接口是不可以单独实例化的,这样写就会报错Shape shape=new Shape();

​可以这样想接口比抽象类还抽象呢，抽象类都不可以实例化，接口当然也不可以了。
image-20210916114904445
6、接口和类之间的关系不能用extends了，应该用implements。
image-20210916130615263
接口和继承一样，一旦一个类实现了这个接口Shape，一定要重写这个接口当中的方法。
image-20210916130656896

7、接口出现是为了解决Java单继承的问题。(后面会有详细解释)

因为在Java当中只能继承一个类，不能继承多个类，所以是单继承，而有了接口，就可以解决Java单继承的问题，实现继承多个类的能。

image-20210916131010968

8、只要这个类实现了该接口，就可以进行向上转型了。

接口也是可以发生向上转型的，前提是把一个对象赋值给接口类型之前一定要保证这个类实现了这个接口。

代码示例：

interface Shape {//Shape就是一个接口
    void draw();
    class Cycle implements Shape {//Cycle实现了接口Shape
      //接口和类之间的关系不能用extends了，应该用implements,一旦一个类实现了这个接口Shape，一定要重写这个接口当中的方法
        @Override  //Override是重写的意思， @Override叫做注解，给一个方法加上注解说明这个方法是可以重写的方法，
      //如果一个类实现了接口，那么这个类必须要重写这个接口当中的抽象方法，不重写就会报错。
        public void draw() {//实现方法的重写
            System.out.println("画一个○");
        }
    }
    class React implements Shape {//React实现接口Shape
        @Override
        public void draw() {
            System.out.println("画一个♦");
        }
    }
    class Flower extends React {//Flowe继承React
        @Override
        public void draw() {
            System.out.println("画一朵❀");
        }
    }
    class Quert implements Shape {//Quert实现接口Shape
        @Override
        public void draw() {
            System.out.println("画一个□");
        }
    }
    public class TestInterFace {
        public static void drawMap(Shape shape) {
            shape.draw();//发生多态
        }
        public static void main(String[] args) {
            Shape shape1 = new Cycle();//接口也是可以发生向上转型的，前提是把一个对象赋值给接口类型之前
            //一定要保证这个类实现了这个接口。
            Shape shape2 = new React();
            Shape shape3=new Quert();
            Shape shape4=new Flower();
            drawMap(shape1);//发生向上转型
            drawMap(shape2);
            drawMap(shape3);
            drawMap(shape4);
        }
    }
}

打印结果：image-20210920072118773

实现多个接口

有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过 多继承 的方式来实现的.

然而 Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口, 也能达到多继承类似的效果.

现在我们通过类来表示一组动物

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 Cat extends Animal implements IRunning{//猫继承于Animal并且实现IRunning这个接口,因为猫是一个动物并且拥有跑步这个功能
    public Cat(String name){//因为Animal是有构造方法的所以需要提供带有一个参数的构造方法
        super(name);
    }
    public void run(){//实现IRunning这个接口的同时需要重写IRunning的run方法。
        System.out.println(this.name+"正在欢快的跑步");
    }
}
class Fish extends Animal implements ISwimming{//鱼继承于Animal并且实现ISwimming这个接口,因为鱼是一个动物并且拥有游泳这个功能
    public Fish(String name){//提供带有一个参数的构造方法
        super(name);
    }
    public void swim(){
        System.out.println(this.name+"正在欢快的游泳");
    }
}
class Frog extends Animal implements IRunning,ISwimming{//实现多个接口，也就解决了多继承的问题，要什么就实现什么就ok了
    public Frog(String name){//因为Animal是有构造方法的所以需要提供带有一个参数的构造方法
        super(name);
    }
   //ctrl+O:重写 IRunning的run方法和ISwimming的swim方法
    @Override
    public void run() {
        System.out.println(this.name+"正在跑！！");
    }
    @Override
    public void swim() {
        System.out.println(this.name+"正在游!!");
    }
}
class YuanYang extends Animal implements IRunning, ISwimming, IFlying {
    public YuanYang(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 + "正在漂在水上");
    }
}
//从实现多个接口的方式可以发现，把run方法、swim方法和fly方法写在Animal当中是不合适的，如果写在Animal当中就需要实现多个不同的类，因为不是每一种动物都会这些功能，所以应该写到接口当中，继承Animal之后，直接要什么就实现什么接口就ok了。

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.

继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性,它主要是对方法的一个抽象 .

猫是一种动物, 具有会跑的特性.

青蛙也是一种动物, 既能跑, 也能游泳

鸳鸯也是一种动物, 既能跑, 也能游, 还能飞

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.

比如：

class Robot implements IRunning{//使用接口，不管是什么类，只要会跑就行，会跑就可以实现跑的功能

    @Override
    public void run() {
        System.out.println("我是机器人，我也会跑步！");
    }
}
public class TestMoreExtends {
    public static void main(String[] args) {
        IRunning iRunning=new Robot();
        iRunning.run();
    }
}

打印结果：image-20210921081716591

忘记类型，实现多态（继承）的代码示例：

class Robot implements IRunning{//使用接口，不管是什么类，只要会跑就行，会跑就可以实现跑的功能
    @Override
    public void run() {
        System.out.println("我是机器人，我也会跑步！");
    }
}
public class TestMoreExtends {
    //忘记类型，实现多态，实现一个方法, 叫 "散步",参数类型为IRunning
    public static void walk(IRunning running){//
        System.out.println("我带着伙伴去散步");
        running.run();
    }
    //忘记类型，实现多态，实现一个方法, 叫 "玩耍",参数类型为ISwimming
    public static void play(ISwimming swimming){
        System.out.println("我和小伙伴在游泳");
        swimming.swim();
    }
    public static void main(String[] args) {
        IRunning iRunning1=new Robot();//接口可以发生向上转型
        walk(iRunning1);//也可以发生多态，调用walk,把参数传进去
        //对于接口来说,不关心传参传的是谁，只要是实现了IRunning接口的就可以运行起来。
        IRunning iRunning2=new Frog("青蛙");
        walk(iRunning2);
        ISwimming iSwimming=new Fish("小鱼");
        play(iSwimming);
    }
}

打印结果：image-20210921085143868

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字，接口间的继承相当于把多个接口合并在一起

接口使用实例

给对象数组排序

给定一个学生类

class Student {//实现Comparable这个接口说明这个接口一定是有一个抽象方法
    public String name;
    public int age;
    public int score;
    public Student(String name, int age, int score) {//提供构造方法
        this.name = name;
        this.age = age;
        this.score = score;
    }
    //想要打印这三个属性的话，需要重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按年龄降序)

public class TestDemo {
    public static void main(String[] args) {
        Student student1=new Student("小王",18,99);
        Student student2=new Student("小明",21,69);
        Student student3=new Student("小李",17,79);
        /*if(student1<student2){//仅仅将这两个学生进行比较是错误的，因为不知道比较的是什么，name还是age,还是score？
        所以自定义类型是不能进行比较的，想要比较的话，需要在学生类后面加上implements Comparable<Student>，尖括号里面写的东西代表你当前要比较的是什么
        }*/
       /* if(student1.compareTo(student2)<0){
            System.out.println("student1的年龄小于student2的年龄");
        }*/
        Student[] students=new Student[3];//定义一个数组，里面放三个学生，并且对这三个学生进行排序。
        students[0]=student1;//学生1放在0号下标
        students[1]=student2;
        students[2]=student3;

按照我们之前的理解, 数组我们有一个现成的 sort 方法, 能否直接使用这个方法呢？

  Arrays.sort(students);//Arrays.sort默认从小到大排序
        //想要排序的话，底层势必会有两个学生进行两两比较
        System.out.println(Arrays.toString(students));
    }

运行结果出错：抛出异常

image-20210921185251552

仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系怎么确定? 需要我们额外指定.

让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

class Student implements Comparable<Student>{//实现Comparable这个接口说明这个接口一定是有一个抽象方法
    public String name;
    public int age;
    public int score;

    public Student(String name, int age, int score) {//提供构造方法
        this.name = name;
        this.age = age;
        this.score = score;
    }
    //想要打印这三个属性的话，需要重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {//重写compareTo方法,用当前对象和你传过来的参数进行比较
        //如果是根据年龄来比较的话就可以这样写
        //自定义类型需要在compareTo内部指定比较方式，即从小到大排列还是从大到小排列。
        if(this.age>o.age){//如果是大于号，就是从小到大排列，如果是小于号，就是从大到小排列，返回1
            return 1;

        }else if(this.age==o.age){//如果相等，返回0
            return 0;
        }else {//返回-1,说明小于
            return -1;
        }
    }
}

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.

然后比较当前对象和参数对象的大小关系(按年龄来算).

  • 如果当前对象应排在参数对象之前, 返回小于 0 的数字;
  • 如果当前对象应排在参数对象之后, 返回大于 0 的数字;
  • 如果当前对象和参数对象不分先后, 返回 0.

执行结果：符合预期
image-20210921184939054
完整代码如下:

package com.xiaoba.demo4;
import java.util.Arrays;
/**
 * 一般情况下：自定义类型进行比较，需要是可以比较的，通过实现Comparable接口，比较是从大到小排列还是从小到大排列需要自己重写compareTo方法
 * 根据自己的想法来安排排列方式
 */
//比较自定义类型可以让这个类实现Comparable接口
class Student implements Comparable<Student>{//实现Comparable这个接口说明这个接口一定是有一个抽象方法
    public String name;
    public int age;
    public int score;
    public Student(String name, int age, int score) {//提供构造方法
        this.name = name;
        this.age = age;
        this.score = score;
    }
    //想要打印这三个属性的话，需要重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
    @Override
    public int compareTo(Student o) {//重写compareTo方法,用当前对象和你传过来的参数进行比较
        //如果是根据年龄来比较的话就可以这样写
        //自定义类型需要在compareTo内部指定比较方式，即从小到大排列还是从大到小排列。
        if(this.age>o.age){//如果是大于号，就是从小到大排列，如果是小于号，就是从大到小排列，返回1
            return 1;
        }else if(this.age==o.age){//如果相等，返回0
            return 0;
        }else {//返回-1,说明小于
            return -1;
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student student1=new Student("小王",18,99);
        Student student2=new Student("小明",21,69);
        Student student3=new Student("小李",17,79);
        /*if(student1<student2){//仅仅将这两个学生进行比较是错误的，因为不知道比较的是什么，name还是age,还是score？
        //所以自定义类型是不能进行比较的，想要比较的话，需要在学生类后面加上implements Comparable<Student>，尖括号里面写的东西代表你当前要比较的是什么

        }*/
      /* if(student1.compareTo(student2)<0){
            System.out.println("student1的年龄小于student2的年龄");
        }*/
        Student[] students=new Student[3];//定义一个数组，里面放三个学生，并且对这三个学生进行排序。
        students[0]=student1;//学生1放在0号下标
        students[1]=student2;
        students[2]=student3;
        Arrays.sort(students);//Arrays.sort默认从小到大排序
        //想要排序的话，底层势必会有两个学生进行两两比较
        System.out.println(Arrays.toString(students));
    }
    //一般写的整型默认就是从小到大排列，只有自定义类型才可以控制排序方式
    public static void main1(String[] args) {
        int[] array={12,3,8,24,36,78};
        Arrays.sort(array);//排序
        System.out.println(Arrays.toString(array));
        int a=10;
        int b=20;
        if(a>b){
        }
    }
}

注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 “可比较” 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则。

Clonable接口和深拷贝

对于简单类型是深拷贝：画图举例说明
image-20210921230508990

深拷贝代码示例：

public class demo5 {
    public static void main(String[] args) {
        int[] array1={1,2,3,4,5};
        int[] array2=array1.clone();//让array1通过克隆就可以克隆出一个新的数组赋值给array2。
        //对于clone()来说是浅拷贝，什么是浅拷贝和深拷贝呢？
        /*如果是简单类型就是深拷贝，如果是引用类型就是浅拷贝，但是java面向对象的，面向对象的必然是一个浅拷贝，所以如果面试的时候，可以不用分太细，直接统一说成浅拷贝也可。*/
        array2[0]=99;
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

打印结果：image-20210921230041263

对于引用类型是浅拷贝：画图举例说明

image-20210921232501033

此时两个引用同时指向一个对象，通过array2修改person里面的某一个数据
之后，array1下标所对应的数据也会被修改，此时就达到了浅拷贝。

如何实现深拷贝呢？
想要实现深拷贝，不仅要克隆它自己本身，还要将对象也克隆一份，克隆出来的对象假设有一个新的地址，array2就指向了这个新的地址，此时通过修改array2就不会影响到array1的值了，这种拷贝就达到了深拷贝。

image-20210921232536657

Cloneable接口

1、如果想要克隆自定义类型，需要实现Cloneable接口，public interface Cloneable{ }这个接口是一个空接口
面试问题：为什么是一个空接口呢？
空接口也把他叫做标记接口：即只要这个类实现了这个接口，那么就标记这个类是可以进行克隆的。

class Person implements Cloneable{
    public int age;//对象里面存储的是一个未初始化的简单类型age
    //2、重写父类的克隆方法，这个克隆方法是object的克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class demo5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();//因为克隆方法的返回值是object,所以需要进行强制类型转换是类型的到匹配
        System.out.println(person1.age);
        System.out.println(person2.age);
        System.out.println("=============修改===============");
        person2.age = 99;
        System.out.println(person1.age);
        System.out.println(person2.age);
    }

上述代码中，对象里面存储的是一个未初始化的简单类型age，要想实现自定义类型进行克隆，只需两步
第一步：需要实现Cloneable接口
第二步：重写父类的克隆方法，只需要默认的即可。

疑问：克隆出来是深拷贝还是浅拷贝呢？

克隆方法本身就是一个浅拷贝。

class Money{//定义一个钱类
    double money=39.9;//类里面有一个钱，初始值为39.9
}
class Person implements Cloneable{
    public int age;//对象里面存储的是一个未初始化的简单类型age

    Money m=new Money();//在Person类当中定义一个Money，并且实例化一个对象
    //2、重写父类的克隆方法，这个克隆方法是object的克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class demo5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
        System.out.println("=============修改===============");
        person2.m.money=99.9;
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
    }
    //将简单类型换成引用类型之后，就成了浅拷贝

打印结果：image-20210922070600615

如何做到深拷贝呢？

第一步：让Money实现克隆接口

第二步:重写克隆方法

class Money implements Cloneable{//定义一个钱类
    double money=39.9;//类里面有一个钱，初始值为39.9

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public int age;//对象里面存储的是一个未初始化的简单类型age

    Money m=new Money();//在Person类当中定义一个Money，并且实例化一个对象
    //2、重写父类的克隆方法，这个克隆方法是object的克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //return super.clone();
        //1.克隆person
        Person p=(Person) super.clone();//将当前对象克隆一份赋给p
        //2.克隆当前的Money对象
        p.m=(Money) this.m.clone();//将当前对象的m克隆一份出来，给p这个地方生成的m，此时就指向了一个新的对象，以达到深拷贝的目的
        //3.克隆完之后，调用克隆，将引用返回给person2
        return p;
    }
}
public class demo5 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
        System.out.println("=============修改===============");
        person2.m.money=99.9;
        System.out.println(person1.m.money);
        System.out.println(person2.m.money);
    }

打印结果：image-20210922072150831

总结：

封装：主要是通过private关键字来修饰某些字段和某些方法，如果字段、方法被private关键字修饰之后，那么他们只能在当前类当中进行访问，不能出了这个类，也就是说它的作用域就在这个类当中。

  • 封装的优点：让类的调用者对类的使用成本进一步降低了。

继承：继承是通过extends关键字来表明他们之间的关系的，这个他们指的是子类/派生类 extends(继承于) 父类/基类/超类，在继承里面除了构造方法没有被继承，其他的都被继承了。

  • super关键字和this关键字二者的区别：
  • 子类在构造的时候要帮助父类进行构造
  • private修饰符、default修饰符（包访问权限）、protected（它的出现就是为了解决继承的问题）、public,这四种访问权限的大小关系是从小到大排列的。
  • 重写和重载的区别：
    • 子类的访问修饰限定符要大于等于父类的访问修饰限定。
    • 向上转型
  • 运行时绑定/动态绑定
    • 父类引用要引用子类对象，且父类和子类有同名的覆盖方法，通过父类引用去调用同名的覆盖（重写）方法就会发生运行时绑定。
  • 理解多态：一个引用可以指向不同的对象从而调用同样的方法展现出不同的运行时的状态的这种机制叫做多态。
  • 抽象类：包含抽象方法的类叫做抽象类，使用关键字abstract来修饰。
    • 抽象方法是没有具体的实现的
    • 抽象类是不能new（实例化）的
    • 抽象类的目的就是为了被继承
    • 一个类如果继承了这个抽象类，就一定要重写这个抽象类里面的抽象方法，如果这个类不想实现的话，再把这个类变成抽象类，但是不管怎样，早晚都还是要实现的，因为抽象类不能实例化，只能被继承。

接口：使用interface关键字来修饰的

  • 对于它的成员变量：public static final （静态变量）
  • 对于它的成员方法：public abstract (抽象方法)
  • 接口也是不能够被实例化的
  • 实现接口使用implements关键字，可以实现多个接口。
  • 接口的出现主要是为了解决Java的多继承问题，因为Java是单继承，想要多继承就需要实现多个接口来实现多继承.
  • Compareable接口
    • 自定义类型要可以比较，需要实现这个接口。这个接口里面有一个compareTo方法。
    • Compareable接口主要是为了Java当中对象的一个比较。

常见面试题：

抽象类和接口的区别：核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口。

class Animal { 
 protected String name; 
 
 public Animal(String name) { 
 this.name = name; 
 } 
}

抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们

NO区别抽象类（abstract）接口(interface)
1结构组成普通类+抽象方法抽象方法+全局常量
2权限各种权限public
3子类使用使用extends关键字继承抽象类使用implements关键字实现接口
4关系一个抽象类可以实现若干接口接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
5子类限制一个子类只能继承一个抽象类一个字类可以实现多个接口
测试小姐姐~
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java之抽象类(abstract)
whpu1234的博客
07-26 1926
1.抽象类 用abstract修饰   1)父类知道子类应该包含怎样的方法，但无法准确知道这些子类如何实现   2）从多个具有相同特征的类中抽出一个抽象类，   使用规则：   1）abstract来定义抽象类   2）abstrct定义抽象方法，只有声明，不许实现   3）包含抽象方法的类是抽象类   4) 抽象类可以有普通方法，也可以没有抽象方法 （即抽象方法是抽象类的必要条件） demo:...
抽象类的详解
weixin_55079859的博客
06-23 6695
抽象类的详解
（七）Java关于抽象类abstract
SwaggerHB的博客
03-27 781
Java关于抽象类与内部类
JAVA：定义一个抽象类Shape，计算各种子类图形的面积（简易详细版）
最新发布
YesAnna_的博客
04-22 1万+
为什么要定义为抽象类？因为要计算的形状面积各不相同，方法体是不确定的，所以方法定义为抽象方法，抽象方法所在的类必须为抽象类（而抽象类不一定有抽象方法）。返回值类型也可以定义为其他的数据类型步骤：1.继承形状类Shape2.此时会显示报错，因为需要重写父类的抽象方法@Override下面的代码代表重写1.定义成员变量—>矩形的参数，长和宽2.创建空参构造和全参构造//参数 int width;int length;//空参构造 public Rectangle() {
练习-Java继承和多态之abstract类
m0_65420451的博客
08-28 3538
通过图形类的计算面积的方法，计算矩形和三角形的面积。将 Shape 图形类改为抽象类，并定义一个抽象方法 area()，返回值类型为 double，计算图形的面积；以上就是今天要讲的内容，本文仅仅简单介绍了Java继承和多态之abstract类。...
Java语言面向对象编程思想之类与对象实例详解
08-29
Java语言面向对象编程思想之类与对象实例详解 Java语言面向对象编程思想中，类和对象是两个核心概念。类是对对象的抽象描述，它定义了对象的属性和行为；对象是类的实例化，它具有类的所有属性和行为。下面是对类和...
Java面向对象编程之类的继承详解
08-28
"Java面向对象编程之类的继承详解" Java面向对象编程之类的继承是Java编程语言中最基本也是最重要的概念之一。继承是类和类之间的一种关系，通过继承，可以使子类继承父类的所有属性和方法，从而提高代码的复用性和...
详解Java面向对象编程中方法的使用
09-02
主要介绍了详解Java面向对象编程中方法的使用,包括方法的重载和参数以及泛型方法等知识点,需要的朋友可以参考下
Java面向对象编程中final关键字的使用方法详解
09-02
本篇文章将深入探讨`final`关键字在Java面向对象编程中的应用。 首先，`final`关键字可以用来修饰变量。当一个变量被声明为`final`时，这意味着它的值不能被再次赋值。例如，如果声明了一个`final`类型的对象引用，...
面向对象编程（Python版详解）
12-21
python版，面向对象编程分三篇给大家介绍，这是第一篇，欢迎阅读学习，一起进步 Python专栏请参考：人生苦短-我学python 文章目录一.面向对象编程介绍二.类和对象三.类的构成四.定义类 和 创建对象五.对象属性获取...
java程序设计——实验二
加载中.......
01-14 2361
1．编写Applet 程序 (二)．修饰符的使用 1．程序功能：通过两个类StaticDemo、Demo2_2 说明静态变量/方法与实例变量/方法的区别。 2．编写类文件Demo2_2.java，程序源代码如下。 (三)． 1.方法中参数传递的练习 1.编写一个传值调用的程序文件Demo2_3.java。 （1）程序功能：程序首先给整型变量x 和y 赋一个初值10，然后使用传值调用方式调用方法ff1对x 和y 做乘方及输出x 和y 的乘方值，最后再输出x 和y 的乘方值。 （2）程序源代码如下。 (三)．
Java抽象类
xiao梁同学的博客
11-23 124
Java抽象类，抽象类的概念，抽象类的特性，抽象类的作用
16、Java基础---抽象类
姜皓的博客
09-25 624
抽象类 一、抽象类 首先考虑“点” 和“长方形”这两个图形，这两个类中都有用于绘图的方法draw；下面来设计这两个类。 点类Point这是表示点的类，不持有字段。方法draw的实现如下，只显示一个符号字符'＋' void draw() { System.out.println ('+'); } 长方形类Rectangle 这是表示长方形的类，持有表示长和宽的int型字段width和...
从抽象类shape类扩展出一个圆形类Circle
m0_64212834的博客
03-14 2861
请从下列的抽象类shape类扩展出一个圆形类Circle,这个类圆形的半径radius作为私有成员，类中应包含初始化半径的构造方法。 public abstract class shape {// 抽象类 public abstract double getArea();// 求面积 public abstract double getPerimeter(); // 求周长 } 主类从键盘输入圆形的半径值，创建一个圆形对象，然后输出圆形的面积和周长。保留4位小数。 圆形类名Circle 裁判测试程
java继承。抽象类。与接口
WIFIfw的博客
07-14 941
点赞的人都美丽 1, .域隐藏 定义：子类定义与父类同名的成员变量 定义父类person子类student详细看代码注释； class Person { protected String name; protected int age; protected void show() { System.out.println("姓名："+name+" 年龄："+age); } } class Student extends Person { private String
Shape类
qq_51514930的博客
11-04 2943
（1）Shape类：抽象方法setColor（String color）方法，用来给图形设置颜色。 抽象方法showShapeInfo()方法，用来显示图形的详细信息。 （2）Shape2D类：计算面积的方法area()，计算周长的方法perimeter（）。 （3）Shape3D类：计算表面积方法surfaceArea()，计算体积方法volume（）。 （4）分别创建Rectangle、Circle、Box、Sphere类。 （5）在测试类TestShape中 创建Rectangle、Cir
抽象类Shape及其子类
qq_45138815的博客
03-19 4026
定义抽象类Shape，圆形Circle、长方形Square、Rectangle为子类。 Shape类有一个数据成员（double型），定义带参构造方法、抽象方法calArea()(返回值类型：double)在Circle、Square两个类中，实现calArea()方法。在Rectangle类中，增加一个数据成员（double型），实现calArea()方法。编写测试类：定义一个Shape类引用s...
java中的frame_在Java语言中,Frame默认的布局管理器是()。
weixin_32446485的博客
02-20 1650
案例分析一：假定CPU的主频是500MHz。硬盘采用DMA方式进行数据传送，其数据传输率为4MB/s, 每次DMA传输的数据量为8KB, 要求没有任何数据传输被错过。如果CPU在DMA初始化设置和启动硬盘操作等方面用了1000个时钟周期，并且在DMA传送完成后的中断处理需要500个时钟，则在硬盘100%处于工作状态的情况下， CPU用于硬盘I/O操作的时间百分比大约是多少？案例分析二：请求分页管理...
抽象方法和抽象类
MissZhou要努力
02-04 590
抽象类与抽象方法 在OOP语言中，一个类可以有一个或多个子类，而每个类都有至少一个公有方法做为外部代码访问其的接口。而抽象方法就是为了方便继承而引入的。 当类中有一个方法，他没有方法体，也就是没有花括号，直接分号结束，象这种方法我们叫抽象方法，必须使用关键字abstract定义。 如： public abstract function fun(); 包含这种方法的类必须是抽象类也要使用

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值