• Java面向对象（史上最详细的整合）

    目录

    一：什么是面向对象

    二：类与对象的关系

    1.什么是类

    2.什么是对象

    3.创建与初始化对象

    1.什么是类

    2.什么是构造器

    3.创建对象内存分析

     三：封装、继承、多态

    1.封装

    2.继承

    3.this和super关键字

    4.方法重写

     静态方法：

     非静态方法：

    5.多态

    6.instanceof关键字

    7.static关键字

     8.抽象类

    9.接口

    一：什么是面向对象

    “面向对象的方法主要是把事物给对象化，包括其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程，面向过程抽象成类，然后封装，方便使用就是面向对象，（万物皆对象）。

    其本质就是：以类的方式组织代码，以对象的组织（封装）数据。

    二：类与对象的关系

    1.什么是类

    什么是类：类是一种抽象的数据类型，他是对某一类事物的整体描述/定义，但是并不代表某一具体的事物。例如：手机，电脑等等；又比如Person类、Pet类、Cat类等等。

    2.什么是对象

    什么是对象：对象是抽象的具体实例。比如张三是人的一个具体实例，旺财是一个狗的具体实例。

                          能够体现出特点，展现出功能的具体实例，而不是一个抽象的概念。

    3.创建与初始化对象

    1.什么是类

    1.使用new关键字创建对象，除了分配内存空间以外还会个创建好的对象进行默认初始化以及对类中的构造器进行调用。

    通常情况下一个类能不能直接使用，需要根据一个类创建一个对象，才能使用，因此我们需要创建一个对象来调用这个类。

    创建类的步骤
    1）导包：
    格式：import包名称.类名称;
    对于同一个包的情况下，可以省略导包语句
    2）创建：
    格式：
    类名称 对象名=new 类名称（）;
    3）使用：
    （1）成员属性：
    格式： 对象名.成员变量名；、
    （2）成员方法：
    格式: 对象名.成员方法名（参数）;

    定义一个标准类（包括如下四个部分）
    （1） 所有的成员变量都用private修饰、
    （2） 每个成员变量都有getxxx()detxxx()方法
    （3） 有一个无参构造
    （4） 有一个全参构造

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     //一个项目只存在一个main方法
    5.     public static void main(String[] args) {
    6.         /*类：抽象的、需要实例化
    7.           类实例化后会返回一个自己的对象
    8.           students对象就是Students的一个具体实例
    9.         */
    10.         Students students= new Students();
    11.         students.name = "张三";
    12.         students.age=20;
    13.         System.out.println(students.name+students.age);
    14.     }
    15.     //属性
    16.     String name;
    17.     int age;
    18.  
    19.     //方法
    20.     void stu(){
    21.         //this代表这个类  指向型
    22.         System.out.println(this.name+"学生在学习");
    23.     }

    2.什么是构造器

    类中的构造器也叫构造方法，在进行创建对象的时候必须进行调用。并且每一个类中都隐藏一个无参构造。

    格式：public 类名称（形参 实参）{
    方法体
    }

    构造器：

    1.和类名必须相同

    2.没有返回值

    作用：

    1.new的本质就是在调用构造方法

    2.初始化对象的值

    注意点：

    定义有参构造之后，如果还想用无参构造的话，那么就必须显示的定义一个无参构造。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     //一个项目只存在一个main方法
    5.     public static void main(String[] args) {
    6.         Students students= new Students("代码贩子");
    7.         System.out.println(students.name);
    8.     }
    9.     String name;
    10.     //一个类及时什么也不写也会存在一个方法
    11.     //定义一个构造器
    12.     //实例化初始值
    13.     /*
    14.     使用new关键字，必须使用构造器
    15.     用来初始化值
    16.      */
    17.     //无参构造
    18.     public Students(){
    19.         //代表的是上面的name
    20.         this.name = "张三";
    21.     }
    22.     //有参构造
    23.     //一旦定义了有参构造，无参构造必须显示定义
    24.     public Students(String name){
    25.         this.name = name;
    26.     }
    27. //alt+inset可以快速构造

    3.创建对象内存分析

    1.首先先在方法区把Demo01类的游戏额代码信息放进来。

    2.主方法main（）会被压入栈.。

    3.一旦new会在方法区加载出Student这个类。

    4.当等于通过Students A= new Students();生成一个A同学放入栈中（此时的A只是一个引用或者变量名）。

    5.针对于这个对象A会在堆里面，通过这个模板new了一个A。

    6.此时的action（）方法其实调用了方法区中的action（）方法，此时Students A= new Students();方法就完成了。

    7.接下来给name、age进行赋值。

    8.将方法区的Demo01中的常量池中的值丢个堆中A进行name和age的赋值，此时A.name = "代码贩子、"; A.age = 24;以及A.action();中的值就赋完了，此时这个对象A的堆中就有这些值了，此时就可以使用它了。

    9.如果出现了同学B就相当于当等于通过Students A= new Students();生成一个A同学放入栈中（此时的A只是一个引用或者变量名）。

    10.针对于这个对象A会在堆里面，通过这个模板new了一个B。

    11.此时的action（）方法其实调用了方法区中的action（）方法，此时Students。 B= new Students();方法就完成了，此时后面的操作相同。

    注意：静态方法区所有带static关键字的东西一开始就在这个地方，和类一起加载的，类一加加载，它就加载了。所有的对象都可以加载它。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */
    4.     //一个项目只存在一个main方法
    5.     public static void main(String[] args) {
    6.         Students A= new Students();
    7.         A.name = "代码贩子、";
    8.         A.age = 24;
    9.         System.out.println(A.name+A.age+A);
    10.         A.action();
    11.     }
    12.     public String name;
    13.     public int age;
    14.     //无参构造
    15.     void action(){
    16.         System.out.println("疯狂学习Java编程知识！");
    17.     }

     三：封装、继承、多态

    1.封装

    定义（自己理解）：该露的露，该藏的藏。将一些较为复杂的内部结构进行隐藏，将一些简单的（比如接口）该暴露给用户的东西暴露出来，比如电视机的外观等等。大部分程序的细节都应该藏起来。我们设计的程序应该追求”高内聚，低耦合“（也就是系统内部的数据操作应该由自己完成，不允许外部进行干预；仅仅暴露少量的方法给外部来进行使用）。

    一旦使用了private进行修饰，本类当中可以随意访问，但是超出了本类就不可以访问了。
    间接访问private成员变量，就定义一对getxxx（）setxxx（）方法

    对于set来说，不能有返回值，参数类型和成员变量对应
    对于get来说，不能有参数，必须有返回值类型，并且返回值类型与成员变量对应。

    封装的意义：

    1.提高程序的安全性，保护数据。

    2.隐藏代码的关键细节（以s1.setAge(24)来说，用户根本不知道里面干了什么，只有我们程序员才知道）;。

    3.统一接口。

    4.提高了系统的可维护性。

    1.     /**
    2.      * @Author代码贩子、 --南京邮电大学
    3.      */    
    4.     public static void main(String[] args) {
    5.         Students s1 = new Students();
    6.         /*
    7.         s1.name;无法进行调用，变量被private被私有了
    8.         如果换成public公有的关键字才可以被调用
    9.          */
    10.         s1.setName("代码贩子、");
    11.         s1.setAge(24);
    12.         s1.setSex('男');
    13.         System.out.println(s1.getName());
    14.         System.out.println(s1.getAge());
    15.         System.out.println(s1.getSex());
    16.     }
    17.     //private关键字为私有化
    18.     private String name;//名字
    19.     private int age;//年龄
    20.     private char sex;//性别
    21.     /*
    22.     想要解决主程序中的s1.name被调用的问题就需要提供一些可以操作这个属性的方法
    23.     解决办法就是提供一些public的get、set方法
    24.      */
    25.     //获得这个数据
    26.     public String getName(){
    27.         return this.name;
    28.     }
    29.     //给这个数据设置值
    30.     public void  setName(String name){
    31.          this.name=name;
    32.     }
    33.     //快捷键
    34.  
    35.     public int getAge() {
    36.         return age;
    37.     }
    38.  
    39.     public void setAge(int age) {
    40.         if (age<100&&age>0) {
    41.             this.age = age;
    42.         }else {
    43.             this.age=3;
    44.         }
    45.     }
    46.  
    47.     public char getSex() {
    48.         return sex;
    49.     }
    50.  
    51.     public void setSex(char sex) {
    52.         this.sex = sex;
    53.     }

    2.继承

    定义：继承的本质就是对某一批类进行的抽象，从而实现对现实世界最好的建模。

    关键字：extends。意思为”扩展“，子类是父类的扩展。

    修饰符的级别;public>protected>default（或者是不写）>private

    Java中的类只有单继承的关系，没有双继承的关系（相当于一个父类可以有多个子类，但是多个子类只能以有一个父类）。

    级别（由大到小）

    关键字名称

    Public

    protected

    default

    private

    作用域

    可以被该类的和非该类的任何成员访问

    子类可以使用父类中，其他的不可以，它相当于传递给子类的一种继承的东西。

    一个包内可以访问，如果不在一个包内，即使是继承关系，子类也无法访问。

    只有该类可以直接调用，其余类想要调用需要使用get（）set（）方法

    继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。

    继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，用关键字extends来表示。

    子类和父类之间，从意义上讲应该具有”is a“的关系。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         Student student =new Student();
    7.         //子类可以继承父类的所有方法
    8.         /*
    9.         父亲说我有钱了
    10.         儿子继承了父亲的财产
    11.         儿子也说我有钱了
    12.          */
    13.         //子类没有任何的说明
    14.         //接收这个方法
    15.         student.money();
    16.         //子类可以继承父类的所有属性
    17.         //父类中父亲姓代码，那么子类中的儿子也会继承叫代码
    18.         System.out.println("我跟随父亲的姓氏姓："+student.xingshi);
    19.         /*
    20.         父类中的父亲有十个小妾，但是用private关键字进行私有了，只属于父类自己
    21.         儿子不管是出于道德还是出于代码逻辑都不能进行继承
    22.         System.out.println(student.xiaoqie);
    23.         因此子类无法进行继承和调用
    24.          */
    25.         /*
    26.         出于道德不继承父亲的小妾，但是父亲有十件古董，但是被父亲私有制了，那么我们要想获得必须经过父亲的同意
    27.         让父类提供一些public的get、set方法
    28.          */
    29.         System.out.println("父亲同意将私有的古董给我："+student.getGudong()+"件");
    30.     }
    31. }
    32. public class Demo01 {
    33.     /**
    34.      * @Author代码贩子、 --南京邮电大学
    35.      */
    36.     public static void main(String[] args) {
    37.         Student student =new Student();
    38.         //子类可以继承父类的所有方法
    39.         /*
    40.         父亲说我有钱了
    41.         儿子继承了父亲的财产
    42.         儿子也说我有钱了
    43.          */
    44.         //子类没有任何的说明
    45.         //接收这个方法
    46.         student.money();
    47.         //子类可以继承父类的所有属性
    48.         //父类中父亲姓代码，那么子类中的儿子也会继承叫代码
    49.         System.out.println("我跟随父亲的姓氏姓："+student.xingshi);
    50.         /*
    51.         父类中的父亲有十个小妾，但是用private关键字进行私有了，只属于父类自己
    52.         儿子不管是出于道德还是出于代码逻辑都不能进行继承
    53.         System.out.println(student.xiaoqie);
    54.         因此子类无法进行继承和调用
    55.          */
    56.         /*
    57.         出于道德不继承父亲的小妾，但是父亲有十件古董，但是被父亲私有制了，那么我们要想获得必须经过父亲的同意
    58.         让父类提供一些public的get、set方法
    59.          */
    60.         System.out.println("父亲同意将私有的古董给我："+student.getGudong()+"件");
    61.     }
    62. }
    63. //学生（派生类；Person的子类）继承了人的所有关系
    64. public class Student extends Person {
    65. }
    66. //教师（派生类；Person的子类）继承了人的所有关系
    67. public class Teacher extends Person {
    68. }
    69.

    3.this和super关键字

    supper代表队的是在子类中调用父类中的属性或者是方法。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         Student student = new Student();
    7.         student.name("代码贩子本人");
    8.     }
    9. }
    10. /**
    11.  * @Author代码贩子、 --南京邮电大学
    12.  */
    13. public class Person extends Object {
    14.     protected String name = "代码贩子、";
    15. }
    16. public class Student extends Person {
    17.     private String name = "小代码贩子、";
    18.     void name(String name){
    19.         System.out.println(name);//代表的是方法传进来的String name
    20.         System.out.println(this.name);//代表的是private私有制的name
    21.         System.out.println(super.name);//代表的是父类protected受保护的name
    22.     }
    23. }
    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         Student student = new Student();
    7.     }
    8. }
    9.  
    10. /**
    11.  * @Author代码贩子、 --南京邮电大学
    12.  */
    13. public class Person extends Object {
    14.    public void say(){
    15.         System.out.println("我是父亲");
    16.     }
    17. }
    18. public class Student extends Person {
    19.     public void say(){
    20.         System.out.println("xusheng");
    21.     }
    22.     public void test(){
    23.         say();
    24.         this.say();
    25.         super.say();
    26.     }
    27. }

    如果父类的构造器换成私有制的关键字属性，那么原本的子类就无法使用super关键字来进行方法的调用。

    这里参杂了一个代码位置的问题。

    首先在我们的子类以及父类都会隐藏一个默认的无参构造器。相当于在Person类中有个public Person() { System.out.println("父类无参执行了！"); }，在子类中有个public Student() { System.out.println("子类有参执行了！"); }。此时在new Studengt（）；的时候执行的结果如下所示：

    因为在子类中调用子类的构造器之前还隐藏了一段代码： super()。

    面向过程详细设计文档
    doc 2星 超过35%的资源 109KB
    下载

    super();的代码只能放在子类构造器第一行，如果和System.out.println("子类有参执行了！");互换位置就会报错。因为new Studengt（）；的同时将父类的也new了。

    this关键字也是如此，急啊如在子类中急啊如一个有参构造器，public Student(String name) { this.name = name; }，此时调用的时候this("代码贩子、");也只能放在无参构造器的额第一行。此时苏果想要放super关键字也必须放第一行，this关键字就会报错。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         Student student = new Student();
    7.     }
    8. }
    9.  
    10. /**
    11.  * @Author代码贩子、 --南京邮电大学
    12.  */
    13. public class Person extends Object {
    14.     //走一个无参构造器
    15.     public Person() {
    16.         System.out.println("父类无参执行了！");
    17.     }
    18.     void say(){
    19.         System.out.println("我是父亲");
    20.     }
    21. }
    22. public class Student extends Person {
    23.     private  String name;
    24.  
    25.     public void say(){
    26.         System.out.println("xusheng");
    27.     }
    28.     public Student() {
    29.         /*
    30.         在调用构造器的时候，要么调用父类要么调用子类，必须保证在构造器的第一个
    31.         正常情况下super();不写也是正常的，会默认的调用无参。
    32.          */
    33.         this("代码贩子、");//调用本类有参构造器，必须放在子类的第一行。
    34.         //super();//调用父类无参构造器，必须放在子类的第一行。（隐藏）
    35.         System.out.println("子类有参执行了！");
    36.     }
    37.     public Student(String name) {
    38.         this.name = name;
    39.     }
    40.  
    41.     public void test(){
    42.         say();
    43.         this.say();
    44.     }
    45. }

    假如父类中的无参构造我们不写，只写了有参构造，那么在子类中就无法进行父类无参构造的调用，不仅如此，子类中的无参也会报错。南无说我就想要调用父类中的有参构造，那么就需要在子类无参构造中利用super("代码贩子、");的形式一步步的调用。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         Student student = new Student();
    7.     }
    8. }
    9.  
    10. /**
    11.  * @Author代码贩子、 --南京邮电大学
    12.  */
    13. public class Person extends Object {
    14.     public String name;
    15.     //走一个有参构造器
    16.  
    17.     public Person(String name) {
    18.         this.name = name;
    19.     }
    20.  
    21.     void say(){
    22.         System.out.println("我是父亲");
    23.     }
    24. }
    25. public class Student extends Person {
    26.     private  String name;
    27.  
    28.     public void say(){
    29.         System.out.println("xusheng");
    30.     }
    31.     public Student(){
    32.         super("代码贩子、");
    33.     }
    34.  
    35.     public void test(){
    36.         say();
    37.         this.say();
    38.     }
    39. }

    因此我们封装的时候无论一个类怎么写，在写的时候一般只要重写了有参构造，一般都会加上无参构造。

    super注意点：

          1.super是调用父类的构造方法，必须写在构造方法的第一个。

          2.super必须只能出现在子类的方法或者3.构造方法中。

          3.this和super不能同时调用构造方法。

     VS this注意点：

          1.代表的是本身调用者这个对象。

          2.代表父类对象的应用。

    前提：

          2.没有继承的前提下也可以使用。

          3.只能在继承条件下才可以使用。

    构造方法：

          this（）；调用的是本类的构造。

          super（）；调用的是父类的构造。

    4.方法重写

     静态方法：

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         /*
    7.         方法的调用只和定义的数据类型有关 
    8.          */
    9.         A a = new A();
    10.         a.test();//走的是A类的静态方法
    11.  
    12.         B b = new A();//父类的引用可以指向子类
    13.         b.test();//走的是B类的静态方法
    14.     }
    15. }
    16. //A类继承了B类
    17. public class A extends B {
    18.     public static void test(){
    19.         System.out.println("A=>test()");
    20.     }
    21. }
    22. //重写都是方法的重写，和属性无关
    23. public class B {
    24.     public static void test(){
    25.         System.out.println("B=>test()");
    26.     }
    27. }

     

     非静态方法：

    此时把A和B中的静态方法去掉，利用快捷键在A类中进行重写，默认走的都是B的方法。如果在A类中重写自己的方法，得到的都是A的方法。所以可以得出一个结论，就是静态方法和非静态方法有区别。

    原因是B b = new A();//非静态方法中子类重写了父类的方法。此时才叫重写

    并且重写的时候修饰符还必须是public的，不能是私有的。

    只有子类继承了父类才能重写，并且是子类重写父类的方法。

    1. public class A extends B {
    2.     @Override
    3.     public void test() {
    4.         super.test();
    5.     }
    6. }
    7. //重写都是方法的重写，和属性无关
    8. public class B {
    9.     public  void test(){
    10.         System.out.println("B=>test()");
    11.     }
    12. }

    1. public class A extends B {
    2.     @Override
    3.     public void test() {
    4.         System.out.println("A=>test()");
    5.     }
    6. }
    7. //重写都是方法的重写，和属性无关
    8. public class B {
    9.     public  void test(){
    10.         System.out.println("B=>test()");
    11.     }
    12. }

     

     总结（重写）：

          1.必须有继承到关系并且还是子类重写父类的方法，和属性无关。

    特点：

          1.方法名必须相同。

          2.参数列表必须相同。

          3.修饰符范围可以扩大。

          4.抛出的异常：可以被缩小但是不能扩大。

          总结：子类的方法和父类必须要一致，方法体不同。

    为什么需要重写？

    父类的功能：子类可能不一定需要，或者是不一定满足！

    5.多态

    定义：同一个方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用类型很多。

    多态可以让程序变得更灵活。

    一个对象的实际类型是确定的，比如new Student()，new Person();但是可以指向这个类型的引用类可以是任意的。比如：Person s2 = new Student(); Object s3 = new Student()。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         /*
    7.         一个对象的实际引用类型是确定的，比如：
    8.         new Student()
    9.         new Person()
    10.          */
    11.         Student s1 = new Student();//子类指向的引用
    12.         /*
    13.         子类能调用的方法都是自己的或者是父类的
    14.          */
    15.         //父类的引用可以指向子类（有父子关系就可以 ，比如用String肯定不行，因为没有指定的关系。）
    16.         Person s2 = new Student();//父类指向的引用
    17.         /*
    18.         父类型虽然可以指向子类，但是不能调用子类独有的方法
    19.          */
    20.         Object s3 = new Student();
    21.  
    22.         s2.run();//运行结果为run，因为子类重写了父类的方法，执行的为子类的方法
    23.         s1.run();
    24.         s1.eat();
    25.         //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大。
    26.         /*
    27.         ((Student)s2).eat();
    28.         强制转换后可以进行调用
    29.          */
    30.         (s2.eat());//无法调用是因为 Person s2 = new Student();虽然new了Student()但不能使用Student()方法，要看Person里面有没有，有的话才能用。
    31.         // 子类重写了父类的方法，执行的为子类的方法。子类和父类的方法都有的话，子类没有重写方法，就调用父类的，如果重写的话就带哦用子类的。
    32.     }
    33. }
    34.  
    35. /**
    36.  * @Author代码贩子、 --南京邮电大学
    37.  */
    38. public class Person extends Object {
    39.     public void run(){
    40.         System.out.println("run");
    41.     }
    42. }
    43. public class Student extends Person{
    44.     @Override
    45.     public void run() {
    46.         System.out.println("son");
    47.     }
    48.     public void eat(){
    49.         System.out.println("eat");
    50.     }
    51. }
    JAVA图书馆书库管理系统设计(论文+源代码).rar
    rar 0星 超过10%的资源 760KB
    下载

    注意事项：

          1.首先多态是方法的多态，跟属性无关。

          2.要有关系（父子类），不然的话会出现类型转换异常。

    存在条件：

          1.要有继承的关系。

          2.方法需要重写（static属于类，不属于实例、final输入常量，在常量池，private私有的不能重写就不能进行多态）。（假如子父类都有run方法，那么子类没有重写方法，就调用父类的，如果重写的话就带哦用子类的）。

          3.父类引用指向子类对象、

    6.instanceof关键字

    作用：instanceof关键字可以判断两个类之间是否存在父子关系。

    1.父类引用指向子类的对象。

    2.子类转换为父类（向上转型），不用强制转换。

    3.父类转换为子类（向下转型），强制转换后会丢失方法。

    4.方便方法的调用，减少重复的代码，提升代码的利用率并且使代码变得更简洁。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         //Object>String
    7.         //Object>Person>Student
    8.         //Object>Person>Teacher
    9.         //System.out.println(A instanceof B);
    10.         //A和B是否有继承关系
    11.         Object object = new Student();
    12.         System.out.println(object instanceof Student);//true
    13.         System.out.println(object instanceof Person);//true
    14.         System.out.println(object instanceof Object);//true
    15.         System.out.println(object instanceof Teacher);//false
    16.         System.out.println(object instanceof String);//false
    17.         Person person = new Student();
    18.         System.out.println(person instanceof Student);//true
    19.         System.out.println(person instanceof Person);//true
    20.         System.out.println(person instanceof Object);//true
    21.         System.out.println(person instanceof Teacher);//false
    22.         //System.out.println(person instanceof String);//编译错误
    23.     }
    24. }
    25.  
    26. /**
    27.  * @Author代码贩子、 --南京邮电大学
    28.  */
    29. public class Person extends Object {
    30.     public void run(){
    31.         System.out.println("run");
    32.     }
    33. }
    34. public class Student extends Person{
    35.     @Override
    36.     public void run() {
    37.         System.out.println("son");
    38.     }
    39.     public void eat(){
    40.         System.out.println("eat");
    41.     }
    42. }
    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     public static void main(String[] args) {
    6.         Person student = new Student();
    7.         //因为这里是Person类型的student
    8.         //student.eat();
    9.         //将Person类型的student的对象转换成student类型，我们就可以使用student类型的方法了。
    10.        Student obj = (Student) student;
    11.        //这样就可以使用低一层的方法了
    12.        obj.eat();
    13.        //第二种写法（（student）obj）.eat();
    14.         /*
    15.         由低转高（子类转换成父类）
    16.         可能会丢失一些方法
    17.          */
    18.         Person person = new Student();
    19.         //丢失一些方法
    20.         //person.eat();
    21.     }
    22. }
    23.  
    24. /**
    25.  * @Author代码贩子、 --南京邮电大学
    26.  */
    27. public class Person extends Object {
    28.     public void run(){
    29.         System.out.println("run");
    30.     }
    31. }
    32. public class Student extends Person{
    33.     @Override
    34.     public void run() {
    35.         System.out.println("son");
    36.     }
    37.     public void eat(){
    38.         System.out.println("eat");
    39.     }
    40. }

    7.static关键字

    1.static静态变量在类中是共享的。

    2.非静态方法可以访问本类中的所有静态方法。

    3.静态方法可以调用本类中所有的静态方法。

    原因：因为静态的方法是和mian方法一起加载出来的，加载之前还没有普通的方法，所以就无法调用。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     /*
    6.     static静态变量在类中是共享的
    7.      */
    8.     private static int name;//静态变量
    9.     private double age;//非静态变量
    10.     public static void main(String[] args) {
    11.         System.out.println(name);//直接可以调用
    12.         System.out.println(age);//不可以直接调用
    13.        Demo01 demo01 = new Demo01();
    14.         //通过对象调用
    15.         System.out.println(demo01.age);
    16.         System.out.println(demo01.name);
    17.     }
    18. }

    1.静态代码块(最早的执行)；静态代码块只在一开始执行一次并且后面将不再执行。

    2.匿名代码块在对象一创建的时候，就先走匿名代码块，然后再走构造器；作用：赋初始值。

    3.构造器最后执行。

    1. public class Demo01 {
    2.     /**
    3.      * @Author代码贩子、 --南京邮电大学
    4.      */
    5.     {
    6.         //匿名代码块
    7.         //作用：赋初始值
    8.         System.out.println("匿名代码块");
    9.     }
    10.     static {
    11.         //静态代码块(最早的执行)
    12.         System.out.println("静态代码块");
    13.     }
    14.  
    15.     public Demo01(){
    16.     //构造器（最后执行）
    17.         System.out.println("构造器");
    18.     }
    19.     public static void main(String[] args) {
    20.         Demo01 demo01 = new Demo01();
    21.         System.out.println("-------------分隔符-------------");
    22.         /*
    23.         因为静态代码块只执行一次
    24.         对象一创建的时候，就先走匿名代码块，然后再走构造器
    25.         静态代码块只在一开始执行一次并且后面将不再执行
    26.          */
    27.         Demo01 demo02 = new Demo01();//此时执行的时候静态代码块就没了
    28.     }
    29. }

     8.抽象类

    抽象类定义;在普通类的结构里面增加抽象方法的组成部分。

    抽象方法定义：是指没有方法体的方法。

    关键字为：abstract。

    注意：

          1.不能new这个抽象类，只能靠它的子类进行实现。

          2.抽象类中可以写普通的方法。

          3.抽象方法必须在抽象类中。

    1.  
    2. /**
    3.  * @Author代码贩子、 --南京邮电大学
    4.  */
    5. //抽象类
    6. public abstract class Person {
    7.     //约束 有人帮我们实现 
    8.     //只有方法的名字，没有方法的实现
    9.     public abstract void work();
    10. }
    11. //抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类本身也是一个抽象类。
    12. public class Student extends Person{
    13.     @Override
    14.     public void work() {
    15.  
    16.     }
    17. }

    9.接口

    接口的定义：简单来说为某种特征的约定。

    关键字：interface。

    1.类可以实现接口 implements

    2.实现了接口的类，就需要重写接口中的方法

    3.利用接口实现多继承，但是与继承关系无关。

    1. //接口定义的关键字interface
    2. //接口都需要有实现类
    3. public interface userService {
    4.     //接口中的所有定义都是抽象的 public abstract
    5.     void add(String name);
    6.     void delete(String name);
    7.     void update(String name);
    8.     void query(String name);
    9. }
    10. public interface timeService {
    11.     void timer();
    12. }
    13. //类可以实现接口 implements
    14. //实现了接口的类，就需要重写接口中的方法
    15. //利用接口实现多继承
    16. public class userServiceImpl implements userService,timeService{
    17.     @Override
    18.     public void add(String name) {
    19.  
    20.     }
    21.  
    22.     @Override
    23.     public void delete(String name) {
    24.  
    25.     }
    26.  
    27.     @Override
    28.     public void update(String name) {
    29.  
    30.     }
    31.  
    32.     @Override
    33.     public void query(String name) {
    34.  
    35.     }
    36.  
    37.     @Override
    38.     public void timer() {
    39.  
    40.     }
    41. }

    总结：

          1.约束。

          2.定义一些方法，让不同的人实现功能。

          3.接口不能被实例化，并且接口没有构造方法。

          4.implements关键字可以实现多个接口。

          5.必须要重写接口中的方法。

  • 相关阅读:
    再谈谷歌GMS认证之Android 13
    海思3559万能平台搭建：OSD功能的优化
    在 Python 3 中释放 LightGBM 的力量：您的机器学习大师之路
    仿真模型简单介绍
    软件测试的发展趋势
    NetSuite BOM成本查询
    【MindSpore易点通】模型训练中的梯度下降
    编写X86环境下的ShellCode
    归并排序 图解 递归 + 非递归 + 笔记
    KubeDNS 和 CoreDNS
  • 原文地址：https://blog.csdn.net/weixin_45650003/article/details/126363948