Java面向对象语言三大特征详解

Love The Way You Lie 2023-10-13 19:44 46阅读 0赞

#### 文章目录 ####

*  面向对象语言三大特征
 *   *  封装
     *   *  补:成员变量和局部变量
     *  继承
     *   *  \*\*好处:\*\*
         *  \*\*使用环境\*\*
         *  \*\*继承语法\*\*
         *  方法的重写
         *   *  方法重写的规则
             *  @Override使用说明
             *  super关键字
             *  继承中的构造方法
         *  抽象类
         *   *  特点:
         *  抽象方法
     *  多态
     *   *  向上转型
         *  多态的好处:提高代码的扩展性
         *  多态环境下对成员方法(非静态)的调用
         *  多态环境下对静态成员方法的调用
         *  向下转型(强制类型转换)
         *  优缺点

## 面向对象语言三大特征 ##

### 封装 ###

**含义:**

1.  包装,将一些常用的功能进行抽取,定义一个方法
2.  面向对象特征中的封装:隐藏,对类中的成员对外是否可见进行控制

**概念：将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问(总结:控制)**

**案例一:将类中属性私有化**

package day7.test3;
    
    public class Test3 {
        
        private String name;//将名字私有化,使用方法来控制
        private int age;
        //在本类中使用方法对私有的name进行初始化,方便控制name的初始化
        public void setName(String naem){
        
            if(name.length()<10){
        
                this.name=name;   
            }
        }
        public void setAge(int age) {
        
            if(age>=0&&age<150){
        
                this.age=age;
            }
        }
        public String getName(){
        
            return name;
        }
        public int getAge() {
        
            return age;
        }
    }

package day7.test3;
    
    public class Test3Test {
        
        public static void main(String[] args) {
        
            Test3 a=new Test3();
            a.setName("张三");
            System.out.println(a.getName());
        }
    }

**案例二:将某种方法私有化**

java设计模式(模板,固定套路)

解决一类问题的固定方式

单例模式,在系统中执行让某个类只创建一个对象

package day7.test4;
    
    public class Test4 {
        
        static Test4 test4=null;
        private Test4(){
        
    
        }
        //单一对象,只创建一个对象
        public static Test4 getTest4(){
        
            if(test4==null){
        
                test4=new Test4();
            }
            return test4;
        }
    }

package day7.test4;
    
    import OOPUnderstand.Test;
    
    public class Test4Test {
        
        public static void main(String[] args) {
        
            Test4 a=Test4.getTest4();
            Test4 b=Test4.getTest4();
            System.out.println(a);
            System.out.println(b);
        }
    }

#### 补:成员变量和局部变量 ####

*  在类中的位置不同
    
    成员变量:在类中定义 局部变量:在方法中定义或方法参数
 *  权限修饰不同
    
    成员变量:可以使用访问权限修饰符
    
    局部变量:不可以使用权限修饰符
 *  初始化不同
    
    成员变量:创建对象后,由构造方法初始化
    
    局部变量:没有默认初始化,必须定义,赋值
 *  生命周期不同
    
    成员变量:随着对象的创建而创建,随着对象的消失而消失
    
    局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
 *  在内存中的位置不同
    
    成员变量:非静态成员变量与对象一起在堆内存中
    
    静态成员变量与类信息在方法区中存储
    
    局部变量:与方法一起在栈内存中

### 继承 ###

**子继承父,儿子就可以拥有父亲的功能**

**可以将这些共性的属性和行为抽取,这样就不需要在每个类中定义同样属性和行为,只需要类与类之间建立联系即可**

#### **好处:** ####

*  **减少代码的冗余,提高了代码的复用性,**
 *  **有利于功能的扩展**

#### **使用环境** ####

*  满足is-a关系，即什么是什么(猫是动物,狗是动物)

#### **继承语法** ####

**通过extends关键字,可以声明另一个A**

[修饰符]class 类A{
        
        ......
    }
    
    [修饰符]class 类B extends 类A{
        
        ......
    }

*  子类会继承父类所有的实例变量和实例方法
 *  子类不能直接访问父类中私有的(private)的成员变量和方法
 *  在Java中,继承的关键字用的是"extends",表示子类是对父类的扩展
 *  Java支持多层继承(继承体系)
 *  一个父类可以拥有多个子类
 *  Java只支持单继承,不支持多重继承

**Java中如果一个类没有使用extends关键字显示的继承其他类,那么这个类默认继承Object类**

![在这里插入图片描述][0295bf21af954859958361449109fb45.png_pic_center]

**所以Java中所有的类都直接或间接的继承了Object类**

**注:父类不可以使用子类功能**

#### 方法的重写 ####

**当父类中的方法功能实现不能满足子类需求时,可以对方法进行重写(override)**

**子类可以对从父类中继承的方法来进行改造,在程序执行时,子类方法将覆盖父类方法,我么称为 方法的重写 也称方法的覆盖**

**注:构造方法,静态方法不能重写,成员变量不存在重写**

##### 方法重写的规则 #####

1.  方法名必须和父类相同,参数列表相同(**否则调用的是父类方法**)
2.  方法返回值类型与父类保持一致
    
    **即子类重写方法结构与父类一致**
3.  子类方法使用的访问权限不能小于父类被重写的访问权限
    
    **注意:1.父类私有方法不能重写 2.跨包的父类默认权限的方法也不能重写**
4.  子类方法抛出的异常不能大于父类被重写方法的异常

##### @Override使用说明 #####

@Override是java中定义的注解标签,用来进行标记(进阶部分细讲)写在方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。  
这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法

**帮助进行语法检测**

##### super关键字 #####

java类中使用super来调用父类中的操作

*  用于访问父类中定义的属性
 *  调用父类中定义的成员方法
 *  用于在子类构造器中调用父类构造器

注意：

*  尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
 *  super的追溯不仅限于直接父类还可以是父类的父类
 *  super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间识的标

**误区:不要把super误认为识父类对象,在创建子类对象时,不会创建父类对象,只会将父类中的信息加载到子类对象中存储**

##### 继承中的构造方法 #####

*  子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)”的方式调用父类指定的构造方法。
 *  **规定super(形参列表)，必须声明在构造器的首行**。
 *  如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构器  
    默认调用super()，即调用父类中空参的构造器。
 *  这么做是为了保证先对父类成员进行初始化

**开发中常见错误**

*  **如果子类构造器中既未显示调用父类或本类的构造器,且父类中又没有空参构造器,则编译错误**

父类
    package day7.extend;
    
    public class Animal {
        
        private String name;
        private int age;
        public Animal(){
        
            System.out.println("父类无参初始化");
        }
    
        public Animal(String name, int age) {
        
            this.name = name;
            this.age = age;//this指当前对象
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public void eat(){
        
            System.out.println("eat thing");
        }
    }

子类1
    package day7.extend;
    
    
    public class Cat extends Animal {
        
        public Cat(){
        
            //super();
            System.out.println("子类无参初始化");
        }
    
        public Cat(String name, int age) {
        
            super(name, age);
            System.out.println("有参构造");
        }
    
        @Override
        public void eat(){
        
            System.out.println("eat cat's food");
        }
    
    }
    class TestAnimal {
        
        public static void main(String[] args) {
        
            Cat mm = new Cat();
            System.out.println("年龄" + mm.getAge());
            System.out.println("名字" + mm.getName());
            mm.eat();
        }
    }

运行结果:  
![在这里插入图片描述][9e3b88764ffa4c1abeb17565d2bb40ac.png_pic_center]

**无参构造有无super()结果都是一样的,不过推荐写上super()**

package day7.extend;
    
    
    public class Cat extends Animal {
        
    
        public Cat(){
        
            super();
            System.out.println("子类无参初始化");
        }
    
        public Cat(String name, int age) {
        
            //super(name, age);
            System.out.println("有参构造");
        }
    
        @Override
        public void eat(){
        
            System.out.println("eat cat's food");
        }
    
    }
    class TestAnimal {
        
        public static void main(String[] args) {
        
            Cat mm = new Cat("咪咪",2);
            System.out.println("年龄" + mm.getAge());
            System.out.println("名字" + mm.getName());
            mm.eat();
        }
    }

![在这里插入图片描述][a05b80d9397e4d57896baac486447f51.png_pic_center]

**注释掉super(name,age),后发现虽然调用子类中有参构造,但运行结果依然是未初始化的成员变量**

package day7.extend;
    
    
    public class Cat extends Animal {
        
    
        /**
         * chidongxi
         */
    
        public Cat(){
        
            super();
            System.out.println("子类无参初始化");
        }
    
        public Cat(String name, int age) {
        
            super(name, age);
            System.out.println("有参构造");
        }
    
        @Override
        public void eat(){
        
            System.out.println("eat cat's food");
        }
    
    }
    class TestAnimal {
        
        public static void main(String[] args) {
        
            Cat mm = new Cat("咪咪",2);
            System.out.println("年龄" + mm.getAge());
            System.out.println("名字" + mm.getName());
            mm.eat();
        }
    }

![在这里插入图片描述][9f24c7accab94ce1a2730096a54c1d53.png_pic_center]

**取消掉注释后,加上super(name,age),就可以调用父类的有参构造方法对成员变量进行了初始化**

**注意,不能把子类构造方法中默认会调用父类无参构造方法,如果需要显示的使用super调用,必须放在构造方法的第一行,还可以调用父类中指定的构造方法**

![在这里插入图片描述][b63be7e0593d4729886e138c2f370e07.png_pic_center]

#### 抽象类 ####

**一个类中没有足够的信息来描绘一个具体的对象,这样的类就是抽象类**

**被abstract类关键字修饰的类,可能会出现抽象方法**

**注:抽象类除了不能实例化对象外,类的其他功能依然存在,成员变量,成员方法和构造方法,且没有抽象变量这一说法**

##### 特点: #####

1.  抽象类不能被实例化(**不能创建对象**),但可以有构造方法,因为抽象类中含有无具体实现的方法所以不能用抽象类创建对象
2.  抽象类只能用做**基类**,表示的是一种关系,继承**抽象类**的**非抽象类**必须实现其中的所有抽象方法,而已实现方法的参数,返回值要和抽象类中的方法一样,否则,该类也必须声明为抽象类

[访问权限符] abstract class 类名{
        
    
    }
    public abstract class Abstract{
        
    	
    }

--------------------

#### 抽象方法 ####

**抽象方法是一种特殊的方法:它只有声明,而没有具体的实现.**

[权限修饰符] abstract [返回值类型] 方法名 (参数列表);
    public abstract void setName(String name);

抽象方法必须用abstract关键字进行修饰

**注:不可以抽象构造方法**

**抽象方法是为了子类对其的重写,所有不能使用static修饰…被static修饰的为静态方法是可以通过类名直接调用的,但是抽象方法没有任何具体的实现,所以是错误的(静态的方法是不可以被重写的)**

### 多态 ###

**多种状态**

父类的引用指向子类对象,从而产生多种形态

Animal dog = new Dog();//这里Dog是Animal子类
    Animal cat = new Cat();

同一种事物,在不同时刻表现不同状态

**二者之间存在直接或间接的继承关系时,父类引用指向子类的对象,即形成多态**

*  在编译期类型是父类,运行期类型是子类时,被称为父类引用指向子类对象

class Animal{
        
    ....
    }
    class Cat extends Animal{
        
    .....
    }
    class Dog extends Animal{
        
    
    }
    Animal cat=new Cat();
    Animal dog=new Dog();//Animal的引用指向Dog的对象

#### 向上转型 ####

package homeworkday7.chouxiang;
    
    public abstract class Cuiweiyang {
        
        String name;
        String sex;
    //public static abstract void setName(String name);不能使用static调用
        public abstract void eat();
        public abstract void setName(String name);
        public abstract void abst();
    }
    package homeworkday7.chouxiang;
    
    public class Dengqinwen2 extends Cuiweiyang {
        
    
        public void eat(){
        
            System.out.println("喝水");
        }
    
        @Override
        public void setName(String name) {
        
    
        }
    
        @Override
        public void abst() {
        
    
        }
    }
    package homeworkday7.chouxiang;
    
    public class Test {
        
        public static void main(String[] args) {
        
            Cuiweiyang dqw=new Dengqinwen();
            Cuiweiyang dqw2=new Dengqinwen2();
            dqw.eat();//编译期间调用的是父类eat,运行期间运行的是子类eat方法
           
        }
    }

![在这里插入图片描述][852f945b003946cbb07f7a5b2eb7ccaf.png_pic_center]

**编译期间是看父类,运行期间切记是在运行子类方法,就算子类无,父类有,也是运行子类所继承的方法,绝对不是运行父类方法**

#### 多态的好处:提高代码的扩展性 ####

class Animal{
        
    	public void eat(){
        }
        ....
    }
    class Cat extends Animal{
        
    	public void eat(){
        
            System.out.println("猫吃鱼");
        }
        .....
    }
    class Dog extends Animal{
        
    	public void eat(){
        
        	System.out.println("狗吃骨头");
        }
            .....
    }
    class Test{
        
        public static void main(String[]args){
        
          Animal cat=new Cat();
    	  Animal dog=new Dog();//Animal的引用指向Dog的对象  
        }
    }
    
    class Person{
        
        public void Feed(Animal animal){
        
            animal.eat;//此时传递的参数是子类对象的地址
        }
        //避免了下面的繁琐,提高代码扩展性
        public void Feed(Dog dog){
        
            dog.eat;
        }
        public void Feed(Cat cat){
        
            cat.eat;
        }
    }

#### 多态环境下对成员方法(非静态)的调用 ####

如上,
    cat.eat();
    //调用的是子类中的方法

**简单来说就是:编译看左边,运行看右边**

#### 多态环境下对静态成员方法的调用 ####

package homeworkday7.chouxiang2;
    class Animal {
        
        public static void eat(){
        
            System.out.println("吃食物");
        }
    }
    class Cat extends Animal{
        
        public static void eat(){
        
            System.out.println("猫吃鱼");
        }
    }
    class Test{
        
        public static void main(String[] args) {
        
            Animal cat=new Cat();
            cat.eat();//调用的是Animal的方法
        }
    }

![在这里插入图片描述][5d261bdab5184f1ca31446fb5aa21990.png_pic_center]

**简单的说:编译运行都看左边**

**注意:变量不存在被子类覆盖写这一说法,只有方法存在覆写**

**为了实现多态性,我们将子类类型向上转为了父类类型.但是一旦类型上升为父类类型,那么就调用不到子类特有的方法**

**解决办法:**

**就行向下转型,把父类转换为子类类型**

#### 向下转型(强制类型转换) ####

格式 **\[类型\]对象名1 = (类型)对象名2**

**将后面大的父类对象转换为子类小的对象**

**注:同父类的子类不能相互转化**

package homeworkday7.chouxiang;
    
    public class Test {
        
        public static void main(String[] args) {
        
            Cuiweiyang dqw=new Dengqinwen();
            Cuiweiyang dqw2=new Dengqinwen2();
            Person zs = new Person();
              dqw.sleep();
              dqw2.sleep();
              Dengqinwen dqw3=(Dengqinwen) dqw;//把Cuiweiyang类型强制转化为子类的Dengqinwen类型
              zs.feed(dqw3);
        }
    }

Dengqinwen2 dqw4=(Dengqinwen2) dqw3;//错误,同父类的子类不能相互转化

![在这里插入图片描述][3023cbe4d4a2476eb142904391cddbda.png_pic_center]

#### 优缺点 ####

**优点**

1.  **灵活性:多态使用使代码更加灵活,可以通过父类类型的引用变量来引用不同子类对象,从而实现不同对象的统一操作**
2.  **可扩展性:通过多态,我们可以方便地扩展和添新的子类,而不需要修改已有的代码**
3.  **代码重用:多态可以提高代码的重用性,通过定义父类类型的方法,可以在不同的子类中进行具体实现,减少了代码的冗余**

**缺点**

1.  **性能损失:多态需要在运行时进行动态绑定和方法调用,这会带来一定的性能损失,相比于直接调用子类方法,多台调用会稍微慢一些**
2.  **可读性降低:由于多态的特性,代码的行为可能会依赖于运行时的实际对象类型,这可能会增加代码的复杂性和难以理解程度**
3.  **限制:多态只能通过父类类型的引用变量来引用子类对象,而不能直接访问子类特有的方法和属性,如果需要访问子类特有的功能,需要进行类型转换**

[0295bf21af954859958361449109fb45.png_pic_center]: https://img-blog.csdnimg.cn/0295bf21af954859958361449109fb45.png#pic_center
[9e3b88764ffa4c1abeb17565d2bb40ac.png_pic_center]: https://img-blog.csdnimg.cn/9e3b88764ffa4c1abeb17565d2bb40ac.png#pic_center
[a05b80d9397e4d57896baac486447f51.png_pic_center]: https://img-blog.csdnimg.cn/a05b80d9397e4d57896baac486447f51.png#pic_center
[9f24c7accab94ce1a2730096a54c1d53.png_pic_center]: https://img-blog.csdnimg.cn/9f24c7accab94ce1a2730096a54c1d53.png#pic_center
[b63be7e0593d4729886e138c2f370e07.png_pic_center]: https://img-blog.csdnimg.cn/b63be7e0593d4729886e138c2f370e07.png#pic_center
[852f945b003946cbb07f7a5b2eb7ccaf.png_pic_center]: https://img-blog.csdnimg.cn/852f945b003946cbb07f7a5b2eb7ccaf.png#pic_center
[5d261bdab5184f1ca31446fb5aa21990.png_pic_center]: https://img-blog.csdnimg.cn/5d261bdab5184f1ca31446fb5aa21990.png#pic_center
[3023cbe4d4a2476eb142904391cddbda.png_pic_center]: https://img-blog.csdnimg.cn/3023cbe4d4a2476eb142904391cddbda.png#pic_center