面向对象

1.类和对象

类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个部分。

类(Class)和对象(Object)是面向对象的核心概念
类是对一类事务的描述，数抽象的、概念上的定义
对象是实际存在的该类事务的每个个体，因而也称为实例(instance)
类的创建如下

class Person {

    // 实例变量
    public String name;
    public Integer age;

    // 构造方法1
    public Person() {
        this.name = "Eric";
        this.age = 99999;
    }
}


public class Demo {

    public static void main(String[] args) {
        // 实例化对象
        Person obj = new Person();
        System.out.println(obj.name);
        System.out.println(obj.age);

    }
}

2.静态成员

本质：静态属于类；非静态属于对象。

class Person {
    // 静态变量
    public static String city = "北京";
    
    // 实例变量
    public String name;
    public Integer age;

    // 构造方法1
    public Person() {
        this.name = "Eric";
        this.age = 99999;
    }
    
    // 绑定方法
    public void showInfo(){
        System.out.println("哈哈哈哈");
    }
    
    // 静态方法
    public static void showData(){
        System.out.println("哈哈哈哈");
    }
}

Person.city;
Person.showData();

Person obj = new Person();
obj.name;
obj.age;
obj.showInfo();

3.Hook重载

在同一个类中，允许存在一个或多个同名方法，只要它们的参数个数或参数类型不同即可

class Person {

    // 实例变量
    public String name;
    public Integer age;
    public String email;

    // 构造方法1
    public Person() {
        this.name = "Eric";
        this.age = 99999;
    }

    // 构造方法2
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
        this.email = "xxx@live.com";
    }

    // 构造方法3
    public Person(String name, String email) {
        this.name = name;
        this.age = 83;
        this.email = email;
    }
    
    // 定义方法（重载）
    public void doSomething() {
        System.out.println(this.name);
    }

    // 定义方法（重载）
    public void doSomething(String prev) {
        String text = String.format("%s-%s", prev, this.name);
        System.out.println(text);
    }
    
}

4.继承

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
继承关键字的关键字是exdents关键字来实现
Java中的继承，只支持单继承，不支持多继承，但支持实现多个接口

class Base { public String email; public Base(String email) { this.email = email; } public String getSubInfo() { return String.format("%s", this.email); } } // Base obj1 = new Base("xx"); // obj1.email; // "xx" // obj1.getSubInfo(); class Person extends Base { public String name; public Integer age; public Person(String name, Integer age, String email) { super(email);// 执行父类的构造方法 this.name = name; this.age = age; } public String getInfo(String v1) { return String.format("%s-%d-%s", this.name, this.age, this.email); } } // obj2 ==> email="xxx@live.com" name="wupeiqi" age=19 Person obj2 = new Person("wupeiqi",19,"xxx@live.com");

5.接口

接口,英文：Interface，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法

接口与类相似点：

一个接口可以有多个方法
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

接口声明：

interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

interface IMessage {
    public void send();
}

// Wechat类"实现"了Imessage接口
class Wechat implements IMessage {
    public void send() {
        System.out.println("发送微信");
    }
}

class DingDing implements IMessage {
    public void send() {
        System.out.println("发送钉钉");
    }
}

class Sms implements IMessage {
    public void send() {
        System.out.println("发送短信");
    }
}

Wechat v1 = new Wechat();
IMessage v2 = new Wechat();

接口有以下特性：

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
接口中的方法都是公有的。

interface Animal {
   public void eat();
   public void travel();
}

6.包

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

src
├── Hello.java
└── utils
    └── Helper.java

// hello.java
import utils.Helper;

public class Hello {

    public static void main(String[] args) {
        String data = Helper.getInfo();
        System.out.println(data);
    }
}

package utils;

public class Helper {
    public static String getInfo() {
        return "哈哈哈";
    }
}

类的修饰符：

public，公共（任何人都能调用包中的类）。
default，只能在当前包中被调用。

类成员修饰符：

public，公共，所有的只要有权限访问类，类中的成员都可以访问到。
private，私有，只允许自己类调用。
protected，同一个包或子类可以访问（即使没有在同一个包内，也可以访问父类中的受保护成员）。
default，只能在同一个包内访问。

目的：通过关键字让调用关系更加清晰

posted @ 2023-07-03 09:43 小青年て阅读(31) 评论(0) 收藏举报

刷新页面返回顶部