【java 基础二】- 面向对象、类、接口等

ゝ一世哀愁。 2024-03-17 10:48 24阅读 0赞

## 一、定义 ##

Java面向对象编程(OOP)是一种编程范式，其旨在通过将程序逻辑封装在对象中来使代码更易于理解和维护。Java是一种面向对象的编程语言，它支持封装、继承和多态等概念。以下是Java面向对象编程的核心概念：

1.  对象(Object)：对象是具有属性和行为的实体。在Java中，对象是通过类定义的。
2.  类(Class)：类是对象的蓝图，它定义了对象的属性和行为。通过类定义，可以创建多个具有相同属性和行为的对象。
3.  封装(Encapsulation)：封装是将对象的属性和行为组合在一起，形成一个独立的单元。这有助于隐藏对象的内部实现细节，并提供了对外部代码的抽象。
4.  继承(Inheritance)：继承是一种机制，允许开发者通过定义一个新类来从现有类继承属性和行为。这有助于代码重用和减少冗余。
5.  多态(Polymorphism)：多态是指对象在接收相同的消息时可以表现出不同的行为。这可以通过方法的重载或覆盖来实现。

Java语言是面向对象的语言，因此对象是Java语言的核心，外事万物皆为对象，面向对象有三大基本特征，如上，封装，继承，多态。

### 1.1 封装 ###

四种访问控制级别  
![在这里插入图片描述][adfd1c87b8704746a313b33d110398ee.png]  
优点

> 1、保护代码被破坏，提高数据安全性。  
> 2、提高了代码的复用性  
> 3、高内聚和低耦合，增强代码的可维护性

比如说一个类最简单的封装就是把属性隐藏起来，只提供 get和set 方法进行操作：

public class 盐蠢 {
        
    	private String chun;
    	public String bing;
        public void setchun(){
        }
        public String getchun(){
        
    		return chun;
    	}
    }

再比如把尽可能多的东西藏起来，对外提高简洁的接口、或者把所有属性藏起来  
比如洗衣机，对外只有两个接口，其他的外界均不知道

public class 洗衣机 {
        
    	private String chun;
    	private String bing;
    	其他属性。。。
    		
        public void 开关(){
        }
        public void 洗衣模式(){
        
    		
    	}
    }

### 1.2 继承 ###

![在这里插入图片描述][ce4e5726664f4e2e8a7f14c772ab031d.png]  
语法，使用 extends 关键字来实现

class A extends B {
        }

详细的我们在下面类跟接口中讲

### 1.3 多态 ###

允许不同的对象对同一个消息做出不同的响应。

在继承中，子类可以继承父类的属性和方法，也可以重写父类的方法来实现自己的特定行为。当父类的引用指向子类的对象时，可以通过父类的引用调用子类重写的方法，实现多态。

在接口中，类可以实现接口中定义的方法，这样可以实现不同的类拥有相同的行为，也可以通过接口的引用调用这些方法，实现多态。

public class AnimalSound {
          
        public static void main(String[] args) {
          
            Animal animal1 = new Dog();  
            Animal animal2 = new Cat();  
            animal1.say();  
            animal2.say();  
        }  
    }  
      
    abstract class Animal {
          
        abstract void say();  
    }  
      
    class Cat extends Animal {
          
        private String small_name = "猫";  
      
        @Override  
        void say() {
          
            System.out.println("喵喵喵");  
        }  
    }  
      
    class Dog extends Animal {
          
        private String small_name = "狗";  
      
        @Override  
        void say() {
          
            System.out.println("汪汪汪");  
        }  
    }

## 二、类与接口 ##

### 2.1 类 ###

类是同一类事物的统称，将现实世界的一个事物抽象成对象，类是对象的抽象，而对象是类的具体实例，类包括对象的属性和方法。

public class 盐蠢 {
        
    	private String chun;
    	public String bing;
        public void setchun(){
        }
        public String getchun(){
        
    		return chun;
    	}
    }

#### 属性和方法 ####

Java类的属性（Properties）是指在类中定义的一些变量，用于描述类或类的对象的某些特征或状态。类的属性可以在类的对象创建时进行初始化或者在运行时动态赋值。  
在Java中，类的属性可以通过访问修饰符来控制其可见性，如public、protected、private等。public属性可以被任何其他类访问，protected属性可以被同一包中的类和其他类的子类访问，private属性只能被本类访问。  
类的属性可以是基本类型（如int、double、char等）或引用类型（如String、List等）。基本类型的属性可以直接赋值，而引用类型的属性需要通过new关键字来创建对象并进行赋值。  
访问类的属性可以使用点操作符（.）访问。例如，如果有一个名为MyClass的类，其中有一个名为name的字符串属性，可以使用以下方式访问该属性：

MyClass obj = new MyClass();  
    String name = obj.name;

类的属性也可以通过getters和setters方法进行访问和修改。getters方法用于获取属性的值，setters方法用于设置属性的值。getters和setters方法通常以驼峰命名法命名，并且setters方法在方法名前加上set关键字。例如：

public class MyClass {
          
        private String name;  
      
        public String getName() {
          
            return name;  
        }  
      
        public void setName(String name) {
          
            this.name = name;  
        }  
    }

##### 方法重载 与 重写 #####

重写父类的方法，方法名字、参数、返回值相同，常见的如overwirte

public class Persion {
        
    	public String attrite = "";
    	public void todo(){
        
           System.out.println("属性是：人性本善");
        }
    }
    public class Student extends Persion{
        
        public void todo() {
        		//重写了父类的方法，方法名和参数相同
            System.out.println("todo: 属性是，你他妈变坏了啊");
        }
    }

同一个类中的相同名字不同参数的方法,调用时根据传递的参数不同来区分是哪个方法

public class Persion {
        
    	public String attrite = "";
    	public void todo(){
        
           System.out.println("属性是：人性本善");
        }
        
    	public void todo(String name){
        
           System.out.println(name + "所有人 属性是：人性本善");
        }
    }

> 重写和重载是Java中的两个重要的概念，它们的主要区别有以下几点：  
> 1、定义不同  
> 重载是指在同一个类中，方法名相同但参数不同的方法，编译器根据参数的数量、类型、顺序来区分不同的重载方法。返回值类型可以相同也可以不同。  
> 重写是指在子类中重新定义父类的方法，方法名、参数列表和返回值类型必须与父类中被重写的方法一致。子类可以根据需要修改方法的具体实现，但外观必须与父类的一致。  
> 2、范围不同  
> 重载是在一个类中定义多个方法，允许方法的参数数量、类型或顺序不同。  
> 重写是在子类中重新定义父类的方法，允许方法的参数数量、类型和返回值类型相同。  
> 3、多态性不同  
> 重载是在编译时多态，即编译器在编译时确定调用哪个方法。  
> 重写是在运行时多态，即运行时确定调用哪个方法，可以根据对象的实际类型来调用方法。  
> 4、参数不同  
> 重载的方法参数可以不同，但重写的方法参数必须相同。  
> 5、访问修饰符不同  
> 重载对访问修饰没有特殊要求，可以是public、protected、private或没有访问修饰符。  
> 重写的要求比较严格，被重写的方法必须为public、protected或default访问修饰符，子类方法的访问修饰符不能比父类方法的访问修饰符严格。  
> 6、返回值不同  
> 重载对返回值类型没有要求，可以相同也可以不同。  
> 重写对返回值类型有要求，必须与父类中被重写的方法的返回值类型相同或是其子类。

##### 构造方法 #####

Java构造方法是一种特殊的方法，主要用来实例化对象和初始化对象。构造方法的主要作用是在对象创建时对对象进行初始化，对对象中的实例进行赋值。构造方法的名字必须与定义它的类名完全相同，没有返回类型，甚至连void也没有。构造方法可以被重载，但不允许被继承。当没有指定构造方法时，系统会自动添加无参构造方法。

public class Persion {
        
    	public String attrite = "";
    	
    	// 无参构造方法
    	public Persion(){
        
           System.out.println("构造方法");
        }
        
    	public Persion(String name){
        
           System.out.println("构造方法");
        }
        
    	public void todo(){
        
           System.out.println("属性是：人性本善");
        }
        
    }

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

Java匿名内部类是一种没有名字的内部类，它是一种实现某项功能的匿名类。匿名内部类可以用来创建一个接口的实例，而不需要额外的类或命名空间。  
匿名内部类是在 Java 中使用的一种创建匿名类的语法结构，通常用于处理需要一个类，但不需要将该类定义为一个单独的类的场景。  
匿名内部类可以访问外部类的成员变量和成员方法，并且可以继承一个接口，实现接口中的方法。匿名内部类可以用在许多Java应用中，如事件处理、GUI编程等。  
例如，下面的代码展示了一个使用匿名内部类的例子：

Button button = new Button() {
          
        {
          
            addClickListener(new ClickListener() {
          
                public void onClick() {
          
                    System.out.println("Button clicked");  
                }  
            });  
        }  
    };

#### 抽象类 ####

使用关键字 abstract

public abstract class Persion {
        
    	public String attrite = "";
    	public abstract void todo();
        
    	public void todo(String name){
        
           System.out.println(name + "所有人 属性是：人性本善");
        }
    }

Java抽象类是一种不能被实例化的类，它主要用于作为抽象类的祖先，提供一些公共方法和属性。抽象类可以包含抽象方法和非抽象方法，但抽象方法不能被实例化。  
Java中的抽象类必须被继承并且可以包含抽象方法。如果一个类继承了一个抽象类，那么该类也必须实现抽象类中的所有抽象方法。如果子类没有实现所有抽象方法，那么子类也必须声明为抽象类。  
在Java中，抽象类不能被实例化，但可以被其他类继承并使用。抽象类的主要作用是作为公共属性的集合，为不同对象提供共性，因此抽象类主要用于面向对象编程中的类型隐藏。

### 2.2 接口 ###

在Java中，接口是一种特殊的抽象类，其中所有方法都是抽象的。接口定义了一组规范，这些规范描述了类应该如何实现某些功能。接口中的方法没有具体的实现，只有方法的签名。  
以下是一个简单的Java接口定义示例：

public interface MyInterface {
          
       public void doSomething(); // 抽象方法无实现  
       public int calculateSum(int a, int b); // 抽象方法无实现  
    }

接口可以包含多个抽象方法，这些方法在接口中不需要提供任何实现，只有方法签名即可。在定义接口时，需要使用关键字interface。  
接口也可以包含默认方法和静态方法，这两种方法提供了实现，但是默认方法有默认的实现，而静态方法没有默认实现。  
接口中的所有方法默认都是public和abstract的，因此可以省略这些修饰符。此外，接口中可以定义默认方法和静态方法，这些方法提供了实现。以下是一个示例：

public interface MyInterface {
          
       default void doSomething() {
          
          System.out.println("Doing something...");  
       }  
      
       static int calculateSum(int a, int b) {
          
          return a + b;  
       }  
    }

实现接口需要使用关键字implements，类可以实现一个或多个接口。实现接口需要实现其中的所有抽象方法。以下是一个示例：

public class MyClass implements MyInterface {
          
       public void doSomething() {
          
          // 实现MyInterface接口中的doSomething方法  
          System.out.println("Doing something in MyClass...");  
       }  
         
       public int calculateSum(int a, int b) {
          
          // 实现MyInterface接口中的calculateSum方法  
          return a + b;  
       }  
    }

## 三、super 关键字 ##

Java中的super关键字用于调用父类的构造方法、实例变量和实例方法。

1.  调用父类的构造方法：  
    子类通过super()调用父类的构造方法，在子类的构造方法中必须第一行使用super()来调用父类的构造方法。

public class Animal {
          
        String name;  
      
        public Animal(String name) {
          
            this.name = name;  
        }  
    }  
      
    public class Dog extends Animal {
          
        String breed;  
      
        public Dog(String name, String breed) {
          
            super(name);  // 调用父类的构造方法  
            this.breed = breed;  
        }  
    }

1.  调用父类的实例变量或实例方法：  
    子类通过super.来访问父类的实例变量或实例方法。

public class Animal {
          
        String name;  
      
        public Animal(String name) {
          
            this.name = name;  
        }  
      
        public String getName() {
          
            return name;  
        }  
    }  
      
    public class Dog extends Animal {
          
        String breed;  
      
        public Dog(String name, String breed) {
          
            super(name);  // 调用父类的构造方法  
            this.breed = breed;  
        }  
      
        public void printName() {
          
            System.out.println(super.getName());  // 调用父类的实例方法  
        }  
    }

## 四、static 关键字 ##

Java中的static关键字用于定义静态变量、静态方法以及静态块。  
静态变量是指类变量，而不是实例变量。它们是与类而不是与对象关联的变量。这意味着所有实例都共享静态变量，并且可以通过类名访问静态变量，而无需创建实例。静态变量在内存中只有一份，因此也称为类变量。  
静态方法是指与类关联的方法，而不是与实例关联的方法。静态方法可以通过类名访问，无需创建实例。静态方法使用static关键字声明，它们不能访问非静态变量或非静态方法。  
静态块是指与类关联的代码块，在类加载时执行。它们用于执行一些初始化任务，例如初始化静态变量或常量。静态块使用static关键字声明。  
以下是一个使用static关键字的例子：

public class MyClass {
          
        static int staticVar = 10;  // 静态变量  
      
        static {
          
            // 静态块，用于初始化静态变量  
            staticVar = 20;  
            System.out.println("静态变量被初始化为：" + staticVar);  
        }  
      
        public static void main(String[] args) {
          
            // 访问静态方法  
            System.out.println("静态方法被调用");  
            System.out.println("静态变量的值为：" + staticVar);  
        }  
    }

## 五、this 关键字 ##

在 Java 中，this 关键字代表当前对象的引用。this 关键字可以在方法内部访问当前对象的成员变量和方法，还可以用来区分相同名称的局部变量和成员变量。  
下面是一个简单的示例：

public class Person {
          
        private String name;  
        private int age;  
      
        public Person(String name, int age) {
          
            this.name = name; // 使用 this 关键字引用成员变量  
            this.age = age;   // 使用 this 关键字引用成员变量  
        }  
      
        public void introduce() {
          
            System.out.println("My name is " + this.name + ", and I am " + this.age + " years old."); // 使用 this 关键字引用成员变量  
        }  
    }  
      
    public class Main {
          
        public static void main(String[] args) {
          
            Person person = new Person("Tom", 20);  
            person.introduce(); // 输出：My name is Tom, and I am 20 years old.  
        }  
    }

在这个示例中，我们定义了一个 Person 类，其中包含两个成员变量 name 和 age，以及一个带参数的构造函数和一个小写方法 introduce()。在构造函数中，我们使用了 this 关键字来引用成员变量，而在 introduce() 方法中，我们使用了 this 关键字来引用成员变量并打印出个人信息。在 main() 方法中，我们创建了一个 Person 对象并调用了 introduce() 方法。  
需要注意的是，在方法内部，this 关键字也可以用来区分相同名称的局部变量和成员变量。例如：

public class Person {
          
        private String name;  
        private int age;  
      
        public Person(String name, int age) {
          
            this.name = name; // 使用 this 关键字引用成员变量  
            this.age = age;   // 使用 this 关键字引用成员变量  
      
            String name = "Tom"; // 声明一个局部变量 name  
            this.name = "Tom";   // 使用 this 关键字引用成员变量 name  
      
            System.out.println("My name is " + this.name + ", and I am " + this.age + " years old."); // 使用 this 关键字引用成员变量  
        }  
    }

[adfd1c87b8704746a313b33d110398ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/2b782f000f29454a8289b95cfaf14065.png
[ce4e5726664f4e2e8a7f14c772ab031d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/98e4a0cfd262471fa7d12b7ec2c7786e.png