【Java SE 基础】面向对象思想、继承、封装、多态

妖狐艹你老母 2022-12-15 02:51 152阅读 0赞

### 文章目录 ###

*   *  1、面向对象概念
     *  2、对象实例化
     *  3、继承封装多态
     *  4、static 变量
     *  5、抽象类和接口
     *  6、N 中内部类
     *  7、异常
     *  思考题

## 1、面向对象概念 ##

面向对象本质：**以类的方式组织代码，以对象的方式封装数据**

三大特性

*  继承
 *  封装
 *  多态

思想和 C++中一样，以下总结把重点放在了 Java 代码的写法和 C++ 的不同之处

## 2、对象实例化 ##

Java 的写法和 C++ 几乎一样，C++ 中堆内存会将返回地址交给一个指针管理，Java 中直接通过对象管理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center]

Java 创建对象内存分析图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 1]

## 3、继承封装多态 ##

**封装**

> 高内聚:类的内部数据操作细节自己完成，不允许外部干涉

> 低耦合:仅仅暴露少量的方法给外部使用

写法和 C++ 没啥区别，但是注意每个方法前面都要加权限

**继承**

对某一批类的抽象，实现更好的建模，通过关键字 **extends** 进行继承，这是和 C++ 不同的地方，注意 **java 中只有单继承，没有多继承**

public class Demo3Telecent extends Student{ 
    
    }

> 在 Java 中，所有的类都默认直接或间接继承 Object 类  
> 后期 Object 将会是学习的重点

super 和 this 区别

*  super 调用父类的构造方法必须在构造器的第一个
 *  super 必须只能出现在子类方法或者构造器中
 *  super 和 this 不能同时调用构造方法
 *  this 代表本身调用者这个对象，super 代表父类对象引用
 *  this 在没有继承的时候也可以使用，super 只能在继承条件下才可以使用
 *  this 默认调用本类构造，super 默认调用父类构造

**多态**

多态：需要有继承关系，子类重写父类方法

1.  方法名，参数列表必须相同
2.  修饰符，范围可以扩大，但是不可以缩小
3.  抛出的异常可以被缩小，但是不能扩大
4.  多态编译，具有可扩展性

多态是方法的多态，而不是属性的多态

Java 写法和 C++ 写法稍有不同

public class Demo3Telecent extends Student{ 
        @Override // 子类重写父类的 say 函数
        public void say() { 
            System.out.println("学生又在说话了！");
        }
    }

Java 需要在子类方法的上一行加 @Override，父类方法不需要做任何变动， 而 C++ 是父类的函数的前面加 virtual ，变为一个虚函数，子类可以加 virtual ，也可以不加

**instanceof 引用类型的转换**

它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。可以用来判断继承中的子类的实例是否为父类的实现

public class Demo2Application { 
        public static void main(String[] args) { 
            // Object 指向 Student
            Object object = new Student();
            // 满足父子关系，返回 true
            System.out.println(object instanceof Student); 
        }
    }

## 4、static 变量 ##

概念和 C++一样，这里就不总结了

在 java 中可以使用静态代码块，也就是匿名代码块

public class Person { 
        
        static { 
            // 这里做初始化的工作 
        }
    }

当创建对象的时候，按照下面执行顺序

public class Person { 
        // 当创建对象的时候，按照下面执行顺序
        static { 
            // 静态代码块，这里做初始化的工作，只执行一次
            System.out.println("静态代码块");
        }
        
        { 
            // 匿名代码块，赋初始值
            System.out.println("匿名代码块");
        }
        public Person() { 
            System.out.println("构造方法");
        }
    
        public static void main(String[] args) { 
            Person person = new  Person();
        }
    }

## 5、抽象类和接口 ##

含有 abstract 修饰符的 class 即为抽象类，abstract 类不能创建实例对象，抽象类中可以实现方法的实现，也可以直接声明方法，在子类中实现，相当于 C++ 中的虚函数，可以在父类实现，也可以在子类实现，比较灵活！

public abstract class Demo5Abstract { 
        /** * 抽象方法，只有抽象名字，没有方法的实现 */
        public abstract void doSomething();
    }
    // 不能 new 这个抽象类，只能靠自类去实现它,抽象方法也必须在子类中

C++ 写法是

virtual void doSomething() = 0;

**接口定义**

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为 public abstract类型，接口中的成员变量类型默认为public static final

这个相当于 C++ 中的虚基类，每一个虚基类至少有一个纯虚函数，纯虚函数必须在子类实现，父类仅仅提供声明，无法实现具体内部…

定义接口

/** * @Title: Demo6UserService * @Package oop * @Description: interface 定义的关键字，接口都需要有实现类 * @author: maze * @date 2020/10/15下午 20:24 */
    public interface Demo6UserService { 
        //接口中所有定义的其实都是 public abstract
        void add(String name);
        void delete(String name);
        void update(String name);
        void query(String name);
    }

实现接口类，重写方法

/** * @Title: Demo6UserServiceImpl * @Package oop * @Description: 实现接口类,重写接口中的方法 * @author: maze * @date 2020/10/15下午 20:28 */
    public class Demo6UserServiceImpl implements Demo6UserService{ 
        @Override
        public void add(String name) { 
    
        }
    
        @Override
        public void delete(String name) { 
    
        }
    
        @Override
        public void update(String name) { 
    
        }
    
        @Override
        public void query(String name) { 
    
        }
    }

> **接口的作用**

1.  约束
2.  定义一些方法，让不同的人去实现
3.  接口不能直接被实例化，因为接口中没有构造方法
4.  implements 可以实现多个接口
5.  实现接口，必须重写接口中的方法

> **抽象类和具体类的相同之处和区别**
> 
> 1、抽象类和接口都不能直接实例化，没有构造方法  
> 2、抽象类中可以存在非抽象的方法，接口必须都为 public 且没有具体实现的抽象方法  
> 3、抽象类中的成员变量可以被不同的修饰符修饰，可接口中的成员变量默认都是静态变量 static final  
> 4、接口用来解决多重继承的问题，抽象类只能单继承  
> 5、抽象类是对象的抽象，接口则是一种行为规范

## 6、N 中内部类 ##

在一个类中再定义一个类

public class Out { 
        private int id;
        public void out(){ 
            System.out.println("这是外部类的方法");
        }
        public class Inner{ 
            public void in(){ 
                System.out.println("这是内部类的方法");
            }
        }
    }

主程序调用

public class Main { 
        public static void main(String[] args) { 
            Out out = new Out();
            Out.Inner inner = out.new Inner();
            inner.in(); // 输出内部类的方法实现
        }
    }

**内部类可以做啥？**

(非静态)内部类可以获取外部类所有的方法和属性  
类似于 C++ 中的友元类，可以访问友元类中的所有成员

另外还有局部内部类，就是在一个方法中定义一个类；还有匿名内部类，很多源码都是这样写的，比如

public class Test { 
        public static void main(String[] args) { 
            
        }
        UserService userService = new UserService(){ 
            @Override
            public void hello() { 
                //你好
            }
        };
    }
    interface UserService{ 
        void hello();
    }

## 7、异常 ##

你写的模块，用户输入不一定符合你的要求；程序要打开的文件不存在，或者打开的文件格式不对；读取数据的时候内存或者硬盘满了，这些都可能抛出异常

异常的作用就是让程序作出合理的处理，而不至于使程序崩溃

比如：栈溢出

public class Demo1 { 
        public static void main(String[] args){ 
            new Demo1().start();
        }
        public void start(){ 
           end();
        }
        public void end(){ 
            start();
        }
    }

**异常的分类**

*  检查性异常：用户出错问题引起的异常，这是程序猿无法预见的，例如打开一个文件不存在，会抛出异常！
 *  运行时异常：在编译期间不会出错，运行的时候导致，比如栈溢出
 *  错误 Error： 脱离程序的控制，比如虚拟机异常，这个时候一般会终止线程

**异常处理机制**

案例1：除数为 0

public class Demo1 { 
        public static void main(String[] args){ 
            int a = 1;
            int b = 0;
            try{ 
                System.out.println(a/b);
            }
            catch (Exception e){ 
                System.out.println("程序出现异常！");
            }
            finally { 
                System.out.println("这里一般做程序的善后工作");
            }
        }
    }

案例2：栈溢出

public class Demo1 { 
        public static void main(String[] args){ 
            // Ctrl + alt + t
            try { 
                new Demo1().start();
            } catch (Throwable e) { 
                System.out.println("程序崩溃异常");
                e.printStackTrace();
            } finally { 
                System.out.println("finally");
            }
        }
    
        public void start(){ 
           end();
        }
        public void end(){ 
            start();
        }
    }

案例3：主动抛出一个异常

public class Demo1 { 
        public static void main(String[] args){ 
            try { 
                new Demo1().test(1,0);
            }
            catch (ArithmeticException e){ 
                e.printStackTrace();
            }
        }
        // 假设这个方法处理不了异常，主动抛出
        public void test(int a,int b){ 
            // 主动抛出异常,一般用在方法
            if(b == 0){ 
                throw new ArithmeticException();
            }
        }
    }

**自定义异常**

public class MyException extends  Exception{ 
        private int detail;
        public MyException(int a) { 
            this.detail = a;
        }
    
        // 异常打印信息
        @Override
        public String toString() { 
            return "MyException{" + "detail=" + detail + '}';
        }
    }

测试类

public class Main { 
        public static void test(int a) throws MyException{ 
            System.out.println("传递的参数为:"+a);
            if(a >10){ 
                throw new MyException(a);
            }
            System.out.println("ok");
        }
        public static void main(String[] args) { 
            try { 
                test(11);
            }
            catch (MyException e){ 
                System.out.println("MyException=>"+e);
            }
        }
    }

## 思考题 ##

1、为什么C++ new 出来的需要使用指针管理，而 Java 不需要指针？  
2、为什么 Java 只有单继承，没有多继承？  
3、抽象类存在构造器吗？抽象类存在的意义在哪？

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/cf2acaece04e4de38c4a7149d35601fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_1_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNzYzMzQ0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/e351a15ad29a426198a7e9c1d33d2703.png