javeSE基础语法汇总以及核心概念（三）

概念图

包的导入和使用

//单个导入 com.lss.utils 包名（文件夹名）Test 包下面其中一个类（class）
import com.lss.utils.Test;
// 包下面所有的类
import com.lss.utils.*;

public class User extends Student {
    private String username;
    private String password;
    private String email;

    public String getUsername()
    {
        return username;
    }

    public void setUsername(String username)
    {
        this.username = username;
    }

    public static void main(String[] args) {
        // 使用
        Test.test();
    }
}

JavaBean

JavaBean是遵循特定规则和约定的Java类，用于封装多个对象到一个单一对象中，让数据处理更加方便。标准JavaBean通常用于Java EE（企业版）应用程序的开发。以下是标准JavaBean的基本概念和要求：

1. 规范要求

要成为一个标准JavaBean，类需要满足以下几个条件：

• 公共无参构造函数：JavaBean需要提供一个公开的无参数构造函数，以便可以方便地创建实例。

  public class Person {
      public Person() {
          // 无参构造函数
      }
  }
  

• 属性私有化：JavaBean的属性（字段）应为private，通过公共的getter和setter方法访问。

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

• 支持序列化：JavaBean通常需要实现Serializable接口，以便能够将对象的状态序列化并反序列化（用于存储和网络传输）。

  import java.io.Serializable;
  
  public class Person implements Serializable {
      // ...
  }
  

2. JavaBean的特点

• 属性访问：JavaBean通过getter和setter方法提供对属性的访问，这构成了与其他类的接口。
• 可重用性：JavaBean可以在多个不同的Java程序和组件中重复使用，提高了代码的复用性。
• 封装性：将数据与操作数据的方法封装在一起，有助于保持数据安全和一致性。

3. 使用场景

JavaBean广泛应用于Java EE应用程序中，如：

• 在Java服务器页面（JSP）中表示数据。
• 在企业级应用程序中用作数据传输对象（DTO）。
• 在框架（例如Spring）中进行依赖注入。

示例

一个符合JavaBean规范的简单示例：

// `Serializable`接口是一个标记接口，它允许Java对象支持序列化和反序列化操作
import java.io.Serializable;

public class Person implements Serializable {
    private String name;
    private int age;

    public Person() {
        // 无参构造函数
    }

    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;
    }
}

总之，JavaBean是一种便于管理和重用数据的 Java 类结构，规范的设计使得它在企业级应用开发中备受欢迎。

Java是一种面向对象的编程语言，面向对象编程（OOP）的核心思想是将事物视为对象，通过对象之间的交互来实现程序的功能。以下是Java面向对象编程的基础总结：

面向对象的四大基本特征

封装（Encapsulation）

封装是将数据（属性）和操作数据的方法（行为）结合在一起，通过访问修饰符（如private、public、protected）控制对数据的访问，保护对象的内部状态不被外部直接访问。封装提高了代码的可维护性和安全性。

public class Person {
    private String name; // 属性

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的复用。子类可以扩展和修改父类的行为。Java只支持单继承（一个类只能继承一个父类），但可以实现多个接口。

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

多态（Polymorphism）

多态是指同一操作或方法在不同对象上可以表现出不同的行为。Java实现多态主要有两种方式：方法重载（Compile-time Polymorphism）和方法重写（Run-time Polymorphism）。

• 方法重载：在同一个类中，方法名相同但参数不同。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
}

• 方法重写：子类重写父类的方法。

public class Animal {
    public void sound() {
        System.out.println("Animal sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

抽象（Abstraction）

抽象是一种提取共同特征的过程，通过定义抽象类和接口来实现。抽象类可以包含抽象方法（没有实现）和具体方法（有实现），而接口只包含抽象方法。

// 抽象类
public abstract class Shape {
    public abstract double area(); // 抽象方法
}

// 接口
public interface Drawable {
    void draw(); // 抽象方法
}

抽象类的应用

package com.lss.utils;

abstract class Animal {
    abstract void eat(); // 抽象方法
    public void sleep() {
        System.out.println("Animal sleep");
    }
}

package com.lss.utils;

public class Dog  extends Animal{
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }

    public static void main(String[] args) {
        // 抽象类不能实例化 报错
        // Animal d = new Animal()
        Animal a = new Dog();
        a.eat();
    }
}

面向对象的优势

• 代码重用：通过继承和接口实现复用，减少了代码重复。
• 可维护性：封装和抽象提高了代码的可读性和可维护性。
• 灵活性：多态性使得程序在运行时能够扩展和适应多种情况。
• 模块化：将复杂系统分解成小的、独立的模块，降低了复杂性。

面向对象的设计原则

• 单一职责原则：每个类只负责一个职责。
• 开放-关闭原则：软件实体应对扩展开放，对修改关闭。
• 里氏替换原则：子类对象应能够替换父类对象而不影响程序的正确性。
• 接口隔离原则：接口应尽量小，客户端不应依赖于不需要的接口。
• 依赖倒转原则：高层模块不应依赖于低层模块，二者应依赖于抽象。

总结

Java的面向对象编程通过封装、继承、多态和抽象等核心特性，使得程序设计更加清晰、系统化和易于维护。掌握这些面向对象的基础知识是成为一个优秀Java开发者的重要一步。