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

一、定义

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

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

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

1.1 封装

四种访问控制级别

优点

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 继承

语法，使用 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;  
    }  
}

2. 调用父类的实例变量或实例方法：
   子类通过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 关键字也可以用来区分相同名称的局部变量和成员变量。例如：文章来源地址https://www.toymoban.com/news/detail-479126.html

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 关键字引用成员变量  
    }  
}

到了这里，关于【java 基础二 】- 面向对象、类、接口等的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！