【随笔】Java面向对象一些知识点

小趴菜77

已于 2022-07-18 16:49:23 修改

阅读量216

点赞数 2

CC 4.0 BY-SA版权

文章标签： java 开发语言

于 2022-07-18 16:41:38 首次发布

本文链接：https://blog.youkuaiyun.com/MikeRabbit/article/details/125854729

本文详细介绍了Java中的面向对象特性，包括继承的概念、格式和特性。子类可以继承父类的属性和方法，同时拥有自己的特性。还讨论了构造器、重载和重写的概念，以及多态和封装的重要性。此外，枚举作为特殊类的应用也被提及，包括如何迭代枚举元素和在选择结构中使用枚举。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

面向对象

继承

概念：子类继承父类的特征和行为
继承格式：（extends关键字）

class 父类{
    
}

class 子类 extends 父类{
    
}

在这里插入图片描述

继承的特性
- 子类拥有父类非private的属性、方法
- 子类可以拥有自己的属性和方法（青出于蓝而胜于蓝）
- 子类用自己的方式实现父类的方法
- 提高类之间的耦合性（缺点：耦合度高，造成代码间联系越紧密，代码独立性越差）
当父亲类和爷爷类都具有相同的属性和方法时候优先调用父亲

继承关键字

extends(单继承+多重继承)

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, int myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements(多继承---->针对接口)

public interface A{
    public void eat();
    public void sleep();
    
    public interface B{
        public void show();
    }
    
    public interface C implements A,B{
        //C接口继承了A,B接口
    }
}

super:使用super关键字实现对父类成员的访问，用来引用当前对象的父类
this关键字：指向自己的引用

补充：

final关键字（防止继承和重写）：
- final关键字声明类后，就是把类定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写
构造器

子类不继承父类的构造器，只是调用（显式或隐式）
- 有参构造器—>必须使用super
- 无参构造器—>不需要使用关键字，系统会自动调用父类的无参构造器

重载（overload）：------>针对是同一个类

概念：在一个类里，方法名字相同，参数不同，返回类型可以相同，也可以不相同。

注意：每个重载的方法（构造函数）都必须有一个独一无二的参数类型列表

重写（override）:----------->针对的是父类和子类之间的操作

概念：子类对父类的允许访问的实现过程进行重新编写，返回值和形参都不能改变。（外壳不变，核心重写）

多态：

注意：
- 向上转型（子类向父类转换）
```
Pet pet = new Dog();			//子类：Dog为子类，Pet为父类
```
- 向下转型（父类向子类转换）

Dog dog = (Dog)pet;					//将pet转换为Dog类型的

封装（Encapsulation）：

概念：将抽象性函数接口的实现细节部分包装、隐藏起来的方法（透明）。

优点：

防止该类代码和数据被外部定义的代码随机访问
类内部的结构可以自由修改
可以对成员变量进行更精确的控制
隐藏信息，实现细节

枚举（enum）

定义：枚举是一个特殊的类，一般表示一组常量。

枚举类声明在类外部

//枚举类声明在类外部
package com.bdqn.threeCharacter;
enum Color{
    RED,GREEN,BLUE;
}

public class Test {
    //执行输出结果
    public static void main(String[] args){
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

在内部类中使用枚举

//在内部类中使用枚举
package com.bdqn.threeCharacter;
enum Color{
    RED,GREEN,BLUE;
}

public class Test {
    //执行输出结果
    public static void main(String[] args){
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

注意：每个枚举都是通过 Class 在内部实现的，且所有的枚举值都是 public static final 的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZloDsTEf-1658133515879)(C:\Users\14021\AppData\Roaming\Typora\typora-user-images\image-20220712142500988.png)]

迭代枚举元素（增强for循环实现）

package com.bdqn.threeCharacter;

enum Color1{
    RED,GREEN,BLUE;
}
public class Test3 {
    public static void main(String[] args){
        //foreach实现迭代
        //接收对象
        for(Color1 myVar: Color1.values()){
            System.out.println(myVar);
        }
    }
}

选择结构中使用枚举类来管理分支元素

package com.bdqn.threeCharacter;

enum Color3{
    RED,GREEN,BLUE;
}
public class Test4 {
    public static void main(String[] args){
        for(Color1 myVar: Color1.values()){
//            System.out.println(myVar);

            //选择结构
            switch (myVar){
                case RED:
                    System.out.println("红色");
                    break;
                case GREEN:
                    System.out.println("绿色");
                    break;
                case BLUE:
                    System.out.println("蓝色");
                    break;
            }
        }
    }
}

几个常用的方法
- values():返回enum类中所有的值。
- ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样
- valueOf()方法返回指定字符串值的枚举常量。

package com.bdqn.threeCharacter;

enum Color5{
    RED,GREEN,BLUE;
}

public class Test5 {
    public static void masin(String[] args){
        //调用values()
        //创建对象数组
        Color5[] arr = Color5.values();

        //迭代枚举
        for(Color5 col: arr){
            //查看索引
            System.out.println(col+"at index"+col.ordinal());

        }

        //使用valueOf()返回枚举常量，不存在的会报错IllegalArgumentException
        System.out.println(Color5.valueOf("RED"));
        

    }

}

枚举类成员

注意：枚举类跟普通类一样

变量
方法（包含具体方法或抽象方法）

注意：如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它
构造函数（只能使用private访问修饰符,所以外部无法调用）

enum Color
{
    RED, GREEN, BLUE;
 
    // 构造函数
    private Color()
    {
        System.out.println("Constructor called for : " + this.toString());
    }
 
    public void colorInfo()
    {
        System.out.println("Universal Color");
    }
}
 
public class Test
{    
    // 输出
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}