Java08面向对象02：OOP三大特性、抽象类和接口、内部类

分手后的思念是犯贱 2024-03-25 12:51 71阅读 0赞

## 4 `面向对象三大特性` ##

### 4.1 封装Encapsulation ###

1.  该露的露，该藏得藏  
    程序设计要追求`“高内聚低耦合”`。**高内聚**：类的内部操作细节自己完成，不允许外部干涉；**低耦合**：仅暴露少量的方法给外部使用。
2.  封装（数据的隐藏）  
    信息隐藏：就是禁止直接访问 一个对象中 数据的实际表示，而通过操作接口来访问。
3.  `private属性私有，get/set`

package com.f.oop3Encapsulation;
    
    /**
     * 1.封装的优点：
     *  1.1 提高程序的安全性，保护数据；
     *  1.2 隐藏代码的实现细节；
     *  1.3 统一接口；
     *  1.4 增加系统可维护性
     */
    public class Employee {
        
        //属性：字段
        String name;
        String sex;//性别
        int age;
        int seniority;//工龄
    
        public String getName(){
        
            return name;
        }
        public void setName(String name){
        
            this.name= name;
        }
        //性别
        public String getSex() {
        
            return sex;
        }
        public void setSex(String sex) {
        
            switch (sex){
        
                case "男":
                case "man":
                    this.sex = "男";
                    break;
                default:
                    this.sex = "女";
            }
        }
        public int getAge(){
        
            return age;
        }
        public void setAge(int age){
        
            if (age< 0 || age>120){
        
                this.age= 6;
            }else {
        
                this.age= age;
            }
        }
        //工龄
        public int getSeniority() {
        
            return seniority;
        }
        public void setSeniority(int seniority) {
        
            if (seniority> 52 || seniority< 0){
        
                this.seniority = 0;
            }else {
        
                this.seniority = seniority;
            }
        }
    }

package com.f.oop3Encapsulation;
    public class Application {
        
        public static void main(String[] args) {
        
            Employee emp = new Employee();
            emp.setSex("man");
            System.out.println(emp.getSex());
    
            emp.setAge(-1);//不合法
            System.out.println(emp.getAge());
        }
    }

### 4.2 继承Inherits ###

1）集成的本质就是对某一批类的抽象，从而实现对世界更好的建模。  
2）`extends`的意思是“扩展”。子类是父类的扩展。  
3）Java中类只有单继承，没有多继承

4）继承是类和类之间的一种关系。此外还有依赖、组合、聚合等关系。  
5）继承关系的两个类，一个位子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示；  
6）子类和父类之间应该具有“（子类） is a （父类）”的关系；

7）object 类：Java中所有的类，默认直接或间接继承 Object；

#### 4.2.1 `super` ####

> super注意点：
> 
> 1.  super调用父类的构造方法，必须在构造方法的第一个位置；
> 2.  super只能出现在子类的方法或构造方法中；
> 3.  super和 this不能同时调用构造方法。

> super VS this：
> 
> 1.  代表对象不同：  
>     this：调用者是当前类；  
>     super：调用者是父类
> 2.  前提：  
>     this：没有继承也可以使用；  
>     super：只能在继承的前提下才能使用。
> 3.  构造方法：  
>     this()：本类的构造方法  
>     super()：父类的构造方法

1.`Employee 类`

package com.f.oop4JiCheng;
    /**
     * 1.public > protected > default > private
     *   属性一般都是私有（private），方法一般是共有（public）
     * 2.Java中所有的类，默认直接或间接继承 Object
     */
    public class Employee /*extends Object*/{
        
        //私有  属性：字段
        private String name;
        int money= 10_0000_0000;
    
        //Employee 无参构造器
        public Employee(){
        
            System.out.println("Employee 无参构造器");
        }
    
        public String getName(){
        
            return name;
        }
        public void setName(String name){
        
            this.name= name;
        }
        
        public String say(){
        
            return "这里是财务，你有什么事？";
        }
    }

2.`Finance extends Employee`

package com.f.oop4JiCheng;
    //财务
    public class Finance extends Employee {
        
        private int money= 10_0000;
        /* Finance 无参构造器*/
        public Finance(){
        
            super();//可以隐藏不写
            System.out.println("Finance 无参构造器");
        }
    
        public void test(int money){
        
            //形参中的
            System.out.println("形参中的:"+money);
            //本类中的属性
            System.out.println("本类中的:"+this.money);
            //父类中的属性
            System.out.println("父类中的:"+super.money);
        }
    }

3.测试

package com.f.oop4JiCheng;
    public class Application {
        
        public static void main(String[] args) {
        
            Finance fin = new Finance();
            fin.setName("tom");
            System.out.println(fin.say());
    
            fin.test(100);
        }
    }

#### 4.2.2 `方法重写` ####

**1）方法重写**（：都是`静态方法的重写`和属性无关。）–>多态的前提

**2）重写**：的前提是需要有继承关系，子类重写父类的方法！

1.  修饰符范围可以扩大但不能缩小：  
    public > protected > default > private
2.  方法名必须相同；
3.  参数列表必须相同；
4.  抛出的异常：范围可以扩大，但是不能缩小

**重写总结**：子类的方法和父类必须一致，方法体不同；重写只和非静态的方法有关，与非静态的方法无关。。

**3）为什么需要重写？**

1.  父类的功能子类不一定需要，或不一定满足；
2.  快捷键：Alt + Insert --> Override 。

class A：

package com.f.oop4JiCheng;
    //重写都是方法的重写，和属性无关
    public class A {
        
        public static void test(){
        
            System.out.println("A ->static test()");
        }
        public String say(){
        
            return "say:---A";
        }
    }

class B：

package com.f.oop4JiCheng;
    
    public class B extends A {
        
        public static void test(){
        
            System.out.println("B ->static test()");
        }
    
        //Override 重写
        @Override//注解：有功能的注释
        public String say(){
        
            return "say:---B";
        }
    }

class Application：

package com.f.oop4JiCheng;
    public class Application {
        
        public static void main(String[] args) {
        
            /*静态方法中：
            1.方法的调用只和左边有关，定义的数据类型有关;
            2.静态方法中子类不能重写父类的方法*/
            A a = new B();//父类的引用指向了子类
            a.test();//A ->static test()
            B b = new B();
            b.test();//B ->static test()
    
            /*非静态方法中：
            1.子类重写了父类的方法，就会执行子类的方法*/
            System.out.println(a.say());//say:---B
            System.out.println(b.say());//say:---B
        }
    }

### 4.3 多态Polymorphism ###

1）特性：动态编译（运行时才确定类型），可扩展性强；  
2）多态：同一方法可以根据发送对象的不同，而采取多种不同的行为方式；  
3）一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（一般是父类 或有关系的类）；  
4）注意：多态是方法的多态，属性没有多态性；

#### 4.3.1 多态存在的条件 ####

1.  有继承关系；
2.  子类重写父类的方法；
3.  父类引用指向子类对象。

#### 4.3.2 多态注意事项： ####

> 1.  多态是方法的多态，属性没有多态；
> 2.  父类和子类有联系，注意类型转换异常 ClassCastException
> 3.  多态存在条件：继承关系、方法需要重写、  
>     父类引用指向子类对象:Father f1 = new Son();
> 4.  不满足多态的情况：  
>     4.1 private修饰的方法：私有方法；  
>     4.2 static修饰的方法：它是属于类，不属于实例；  
>     4.3 final 常量

package com.f.oop5DuoTai;
    //父类：员工
    public class Employee {
        
        public void say(){
        
            System.out.println("Emp,say()");
        }
    }

package com.f.oop5DuoTai;
    //子类：财务
    public class Finance extends Employee{
        
        public void say(){
        
            System.out.println("Fin,say()");
        }
        public void eat(){
        
            System.out.println("Fin,eat()");
        }
    }

package com.f.oop5DuoTai;
    public class Application {
        
        public static void main(String[] args) {
        
            /* 1.一个对象的实际类型是确定的：
            new Employee();//父类
            new Finance();子类*/
    
            /* 2.可以指向的引用类型就不确定了*/
            //Finance:能调用的方法都是自己的 或者是继承父类的
            Finance fin1 = new Finance();
            //Employee：父类可以指向子类，但是不能调用子类独有的方法
            Employee emp2 = new Finance();
            Object obj3 = new Finance();
    
            /* 对象能执行哪些方法，主要看对象左边的类型，和右边关系不大*/
            fin1.eat();//子类重写了父类的方法，执行子类的方法
            ((Finance) emp2).eat();
        }
    }

#### 4.3.3 `instanceof`判断对象类型 ####

`instanceof`的作用1：判断一个对象是什么类型；

package com.f.oop5DuoTai;
    //子类：开发部
    public class Development extends Employee{
        
    }

package com.f.oop5DuoTai;
    //子类：财务
    public class Finance extends Employee{
        
    }

package com.f.oop5DuoTai;
    //父类：员工
    public class Employee {
        
        public void say(){
        
            System.out.println("Emp,say()");
        }
    }

package com.f.oop5DuoTai;
    /**
     * Polymorphism 多态
     * 类之间的关系:
     *  Object > String
     *  Object > Employee > Development
     *  Object > Employee > Finance
     */
    public class Application {
        
        public static void main(String[] args) {
        
            Object obj = new Finance();
            //判断他们是否有关系
            System.out.println(obj instanceof Finance);//true
            System.out.println(obj instanceof Employee);//true
            System.out.println(obj instanceof Object);//true
            System.out.println(obj instanceof Development);//false
            System.out.println(obj instanceof String);//false
    
            System.out.println("----------------");
            Employee emp = new Finance();
            System.out.println(emp instanceof Finance);//true
            System.out.println(emp instanceof Employee);//true
            System.out.println(emp instanceof Object);//true
            System.out.println(emp instanceof Development);//false
            //System.out.println(emp instanceof String);//编译报错
    
            System.out.println("============");
            Finance fin = new Finance();
            System.out.println(fin instanceof Finance);//true
            System.out.println(fin instanceof Employee);//true
            System.out.println(fin instanceof Object);//true
            //System.out.println(fin instanceof Development);//编译报错
            //System.out.println(emp instanceof String);//编译报错
    
            /* 总结：如果有关系就能通过编译
            System.out.println(x instanceof Y);
            */
        }
    }

#### 4.3.4 类型转换； ####

是引用类型的（父类和子类之间的）类型转换

package com.f.oop5DuoTai;
    //子类：财务
    public class Finance extends Employee{
        
        public void go(){
        
            System.out.println("Finance.go()");
        }
    }

package com.f.oop5DuoTai;
    //父类：员工
    public class Employee {
        
        public void run(){
        
            System.out.println("Employee.run()");
        }
    }

package com.f;
    import com.f.oop5DuoTai.Employee;
    import com.f.oop5DuoTai.Finance;
    /**
     * Polymorphism 多态
     * 类型之间的转化：父类 和子类 之间
     */
    public class Application {
        
        public static void main(String[] args) {
        
            /** 父类转换为子类*/
            Employee emp = new Finance();
            //强制转换1
            Finance fin = (Finance) emp;
            fin.go();//Finance.go()
            //强制转换2
            ((Finance) emp).go();//Finance.go()
            System.out.println("---------");
            
            /** 子类转换为父类*/
            Finance finance = new Finance();
            //子类调用自己的方法
            finance.go();//Finance.go()
            //自动转换1 ;父类的引用指向子类的对象
            Employee employee = finance;
            employee.run();//Employee.run()
            //自动转换2；子类转型成功后 会丢失一些方法
            finance.run();//Employee.run()
        }
    }

## 5 Static关键字 ##

### 5.1 静态变量和静态方法 ###

package com.f.oop6Static;
    public class Student {
        
        //静态变量，全局都可以使用。多线程 中使用的较多！
        private static int age;
        //非静态变量
        private double score;
    
        //非静态方法 可以调用 静态方法
        public void run(){
        
            say();
        }
    
        /*静态方法只能 new出实例后才能调用 非静态方法*/
        public static void say(){
        
            new Student().run();
        }
    }

### 5.2 静态代码块 ###

执行顺序：静态代码块、匿名代码块、无参构造器；

package com.f.oop6Static;
    public class Person {
        
        /**1.静态代码块，加载类的时候执行，且永久只执行一次*/
        static {
        
            System.out.println("静态代码块");
        }
    
        /**2.匿名代码块,创建类的时候 一起创建；作用：赋初始值*/
        {
        
            System.out.println("匿名代码块");
        }
    
        /**3.无参构造器,创建类的时候 创建,但在匿名代码块之后*/
        public Person() {
        
            System.out.println("无参构造器");
        }
    
        public static void main(String[] args) {
        
            System.out.println("----");
            Person person = new Person();
    
            System.out.println("=====");
            Person per = new Person();
        }
    }

### 5.3 final修饰符 ###

final修饰类时，该类不可被继承，如 Math类。

import java.util.Random;
    
    public final class Math {
        
        private Math() {
        }
        public static final double PI = 3.14159265358979323846;
        public static double tan(double a) {
        
            return StrictMath.tan(a); // default impl. delegates to StrictMath
        }
        private static final class RandomNumberGeneratorHolder {
        
            static final Random randomNumberGenerator = new Random();
        }
    
        public static double random() {
        
            return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
        }
        //......
    }

## 6 抽象类和`接口` ##

### 6.1 抽象类 ###

抽象类，也是类 所以它只有单继承。  
1）`abstract`修饰符可以用来修饰方法 也可以修饰类。如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类；  
2）抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类；

3）**抽象类**不能使用 new关键字来创建对象，它是用来类继承的，但是可以有普通方法；  
4）**抽象方法**，只有方法的声明没有方法的实现；它是用来让子类实现的；

5）子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

package com.g.abstraction;
    
    public abstract class Action {
        
        /* abstract 修饰方法，抽象方法：只有方法名，没有方法的实现
        它就是一个约束，由继承类实现该方法*/
        public abstract void say();
    
        /*
        抽象方法：
            1.抽象方法只能在抽象类中存在
        抽象类：
            1.不能 new这个抽象类，只能由子类去实现
            2.抽象类中可以有 普通方法
        抽象类的作用：
            简化开发，提高开发效率
         */
    }

**抽象类也有构造器:**

package com.g.abstraction;
    
    public abstract class Say {
        
    }

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by FernFlower decompiler)
    //
    
    package com.g.abstraction;
    
    public abstract class Say {
        public Say() {
        }
    }

### 6.2 `**接口**` ###

`class`是声明类的关键字 ；interface是声明接口的关键字；  
接口，不是类 它可以单继承 也可以多继承。

> 普通类：只有具体实现；  
> 抽象类：具体实现和规范（抽象方法）都有；  
> 接口：只有规范专业的约束（内部只能写抽象方法）；有约束和实现分离的作用，达到面向接口编程的程度。

1）接口就是规范，他定义的是一组规则，体现了现实生活中的“如果你是…则必须能…”的思想；  
2）**接口的本质：是契约**。就像法律，制定好后就必须遵守。  
3）面向对象（Object Oriented,缩写为OO）的精髓：是对对象的抽象，最能体现这一点的就是接口。讨论设计模式时都针对具备了抽象能力的语言（如C++、Java、C\#等）的原因 是因为设计模式所研究的就是如何合理的去抽象

package com.h.interfaces;
    //interface 接口_1
    public interface UserService {
        
        /*2.可以定义常量，默认是：public static final
            实际使用中，一般不在这里定义*/
        int AGE= 18;
    
        /*1.接口中所有的定义都是抽象的，
            默认是：public abstract*/
        public abstract void add(String name);
        void deleter();
    }

package com.h.interfaces;
    //接口_2
    public interface TimeService {
        
        void time();
    }

package com.h.interfaces;
    
    /**
     * 1.抽象类通过 extends 继承父类（单继承）；
     * 2.类 通过 implements实现接口（可以是多个接口）；
     * 3.实现了接口的类，就需要重写接口中的方法
     */
    public class UserServiceImpl implements UserService,TimeService {
        
        @Override
        public void add(String name) {
        }
        
        @Override
        public void deleter() {
        }
    
        @Override
        public void time() {
        }
    }

> **接口作用总结：**
> 
> 1.  接口是约束；
> 2.  接口定义了一些方法，可以让不同的人实现；
> 3.  方法默认是 public static 修饰；
> 4.  常量默认是 public static final 修饰；
> 5.  接口不能被实例化，它没有构造器（构造方法）；
> 6.  用 implement 可以实现多个接口；
> 7.  实现类必须要重写接口中的方法。

## 7 内部类（了解） ##

内部类：就是在一个类的内部在定义一个类。

### 7.1 成员内部类 ###

package com.i.innerClass;
    //inner Class 内部类
    public class Outer {
        
        private int id= 10;
    
        /** 局部内部类:方法内部*/
        public void method(){
        
            class Inner2{
        
                public void in(){
        }
            }
        }
    
        /** 成员内部类：类内部*/
        public class Inner{
        
            //获取外部类私有属性
            public int getId() {
        
                System.out.println("内-部类");
                return id;
            }
        }
    }
    /** class内部类可以有多个，但是只能有一个是public修饰*/
    class OuterClass{
        
        public static void main(String[] args) {
        
    
        }
    }

package com;
    
    import com.i.innerClass.Outer;
    public class Application {
        
        public static void main(String[] args) {
        
            Outer outer = new Outer();
            //要使用内部类，要通过这个外部类来实例化内部类
            Outer.Inner inner = outer.new Inner();
            //调用内部类方法
            int id = inner.getId();
            System.out.println(id);
        }
    }

### 7.2 静态内部类 ###

package com.i.innerClass;
    //inner Class 内部类
    public class Outer {
        
        private static int id= 10;
        /**成员内部类：类内部*/
        public static class Inner{
        
            //获取外部类私有属性
            public int getId() {
        
                System.out.println("内-部类");
                return id;
            }
        }
    }

### 7.3 局部内部类 ###

package com.i.innerClass;
    //inner Class 内部类
    public class Outer {
        
        /** 局部内部类:方法内部*/
        public void method(){
        
            class Inner2{
        
                public void in(){
        }
            }
        }
    }

### 7.4 匿名内部类 ###

package com.i.innerClass;
    
    public class Outer1 {
        
        public static void main(String[] args) {
        
            //没有名字初始化类，不用将实例保存到变量中
            new Apple().eat();
    
            /** 匿名内部类，（接口实现类）*/
            UserService userService= new UserService() {
        
                @Override
                public void hello() {
        
    
                }
            };
        }
    }
    
    class Apple{
        
        public void eat(){
        
            System.out.println("吃了一个苹果");
        }
    }
    // 接口
    interface UserService{
        
        void hello();
    }

### 7.5 Lambda表达式 ###