Java基础--面向对象（下）

最新推荐文章于 2024-06-20 20:20:21 发布

•́‸ก iably

最新推荐文章于 2024-06-20 20:20:21 发布

阅读量107

点赞数

文章标签： java 开发语言代理模式

本文链接：https://blog.csdn.net/qq_48319619/article/details/124125881

版权

1、接口

接口是一组行为的规范，接口不关系对个具体实现类之间是否是一种关系，关注他们的行为是否达到统一。

一旦实现（子）类实现了接口，那么必须要实现该接口中的所有行为。所以往往在设计时候，接口一般只放一个功能。（定义小而精的接口）

① 接口是一种数据类型

② 用interface进行定义，代表接口。

③ 接口中只能放常量和抽象方法。接口中不管是常量还是抽象方法默认权限都是公开的

④ 接口是不能被创建对象的

⑤ 接口是需要被实现类/子类实现的。一旦实现（子）类实现了接口，那么必须实现该接口的所有行为。

⑥ 一个类是可以实现多个接口的！实现时需要通过implements来实现，在后面写上接口名即可

若一个子类继承了一个父类又想实现接口，子类extends 父类名 implements 接口名

⑦ 接口和接口之间是可以继承的，例如：B接口比继承了A接口，但是C类若实现了B接口，那么C勇士还要实现A接口中的抽象内容。

class Aoo{ //定义一个 Aoo这个类
    
}

interface Boo{ //定一个 Boo 接口
    
}

package oo.d;

/**
 * 接口的测试类：
 */
public class InterfaceDemo {
    public static void main(String[] args) {
//        Inter1 i1 = new Inter1(); 接口不能被创建对象
    }
}

interface Inter1{ //接口 中默认是常量
    //接口中不管是常量还是抽象方法  默认访问权限都是公开的！
    //    int NUM = 10; 默认是常量
    static final int NUM = 1;//标准常量写法

    // void test(); 默认是抽象方法
    abstract void test();
}

class  Aoo{ //父类
}
class Boo extends Aoo implements Inter1{// 先继承父类  再实现接口
    @Override
    public void test() {

    }
}

接口和抽象类的区别：

抽象类可以放构造方法；接口没有构造方法。

抽象类可以放普通成员变量；接口不可以。

抽象类可以放普通方法也放抽象方法；JDK1.8以前接口只能放抽象方法，现在其实可以加载静态方法、

抽象类中的成员（变量或方法）可以访问修饰符；接口中修饰符默认都是public

接口不可以实现接口，但是可以继承接口。

一个类只可以继承一个类，但是可以实现多个接口。

总设计规则：

①将所有（概念统一的）类的共性属性和行为提取到父中（泛化）

②在父类中若所有子类的行为具体实现逻辑都一样，设计为普通方法

③接口：（不同的类别或同样的类别）部分尊在行为相同，我们可以使用接口来进行优化和复用

2、多态、内存管理、面向对象总结

3、API文档

API（Application Programing Interface）应用程序接口（功能）

API表示的就是功能，通过学习API快速的开发

API实现初衷:设计速录就是将复杂的业务逻辑封装成功能，供调用者更好的使用。对于使用者而言，不需要关注功能内部的实现细节，只需要知道如何使用即可

使用API（功能），有的功能需要导包，做常用的包

①java.long 包：Java语言的核心语法，内部封装了Java最核心的API，所以一站在使用long包下的内容的时候不需要导包。

例如：String、Object、System、Interface....

②java.io包：可以实现文件操作，输入输出等功能

③java.net：网络相关的功能

④java.util：工具包

3.1 String（字符串）

①java.long.String 这个类用final修饰不能被继承

②String类中维护了一个不可变（用final修饰）的char数组

③ 字符串一旦创建，对象的内容是不可变的，若重新为字符串的变量赋值，则表示一个新的对象

④String是一种数据类型，是引用类型

String name = "陈晓东";//声明一个String类型的变量 name里面存 了"陈晓东"字符串对象 //推荐的形式
String name1 = new String("陈晓东");//但是这种方式Java不推荐
char[] chs ={'陈','晓','东'};
上述代码 name 和 chs 在内存引用的内容是同一个。

String可以复用的条件，String创建对象的形式分为两种

静态字符串创建方式可以实现复用：

① 以字符串字面量的形式创建：例如："ABC"、"hello world"

②字符串的常量

③字符串的字面量拼接成的字符串

   public static final String S3 = "ABC"; //字符串常量 可以进行常量池复用
    public static void main(String[] args) {
//        String s1 = "ABC";//使用字面量  创建了一个String 对象
//        String s2 = s1;
//        s1 = s1 + "DEF";
//        System.out.println(s1);
//        System.out.println(s2);
        //可以复用的情况测试：
        String s1 = "ABC";
        String s2 = "ABC";
        String s4 = "A" + "BC"; //字符串字面量拼接 可以复用
        System.out.println(s1 == s2);
        System.out.println(S3 == s1);
        System.out.println(s1 == s4);

动态字符串创建的方法不可复用：

① 使用new关键字创建的字符串：String s = new String("ABC");

②String变量拼接字面量

//不可复用的情况测试：
        String s5 =new String("ABC");  //不推荐
        String s6 = new String(new char[]{'A','B','C'}); //不推荐
        System.out.println(s5 == s1);
        String s7 = "A";
        String s8 = s7 + "BC";
        System.out.println(s8 == s1);
    }

3.2 StringAPI

String类中，提供了一些方法（API），可以获取字符串的长度，获取字符串中某个下标的字符，转换大小写，转换小写...

①获取字符串的长度，通过下边获取字符串中的某个字符


        String str = "Thinking in java是一本好书";
        int length = str.length();// 获取字符串长度
        System.out.println(length);
        char c = str.charAt(20);// 通过下标获取字符串中对应的字符
        System.out.println(c);
        /**
         *  面试题：请写一段程序,测试出 "Thinking in java是一本好书" 里面 字符i存在的次数
         * */
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
             if(str.charAt(i) == 'i'){//判断当前字符是否 等于 字符 i
                count++;//计数
             }
        }
        System.out.println("i存在的次数："+count);

② indexof()从头向后检索字符或者字符串在当前这个字符串中的位置

lastindexof()从后向前检索字符或者字符串在当前这个字符串中的位置

健硕到传入的字符或者字符串后，理解返回对应的下标

  String str = "Thinking in java是一本好书";
        int index = str.indexOf('i');//通过传入的字符 返回字符在字符串中存在的下标
        System.out.println(index);
        int index1 = str.indexOf('x');//如果找不到 则返回-1
        System.out.println(index1);
        int index2 = str.indexOf('i', 3);//可以指定起始检索位置向后检索字符
        System.out.println(index2);//5
        int index3 = str.indexOf("java");
        System.out.println(index3);
        //lastIndexOf 从后往前开始检索  无非检索的方向发生的变化 其它的功能使用与index是一致的。
        int index4 = str.lastIndexOf('i');
        System.out.println(index4);

③ 转换当前字符串的大小写方法

//3.转换大小写
        String str = "Thinking in java是一本好书";
        str = str.toUpperCase();//字符串字母内容转大写
        System.out.println(str);
        str = str.toLowerCase();//字符串字母内容转小写
        System.out.println(str);
        //4.去除两端空白
        String name = " Tom";
        System.out.println(name);
        name = name.trim();//去除字符串两端空白
        System.out.println(name);
        //5.是否是以什么开头 或 什么结尾的方法
        boolean r = name.startsWith("T");//判断是否是以xx开头的字符串内容
        System.out.println(r);
        boolean r1 = name.endsWith("m");//判断是否是以xx结尾的字符串内容
        System.out.println(r1);

④ subString();截取字符串

 String str = "bjzhangpeng@tedu.cn";
//        String user = str.substring(7);//截取字符串,填入截取起始下标位置,从此位置向后全部截取
        int endIndex = str.indexOf('@');
        String user = str.substring(0,endIndex);//截取字符串 不包括结束索引的位置（包头不包尾）
        System.out.println(user);
        //截取字符串的用法:
        //1.substring(开始索引,结束索引); 会截取出区域的字符串内容.
        //2.subString(开始索引,开始索引+要截取的长度);
        //为什么不包含结束位置,其实就是为了方便以后按照长度进行截取.
        String test = str.substring(0,0+5);
        System.out.println(test);

⑤ valueof(); String类提供的静态方法，主要作用就是可以将数值类型的字符变量转换为字符串

int a = 100;
String b = String.valueOf(a);
System.out.println(b);//"100"
System.out.println(100);//打印语句中放的任意的值类型数据 其实都是做了String.valueof的处理来显示的.

⑥contains();判断是否包含XX内容的方法使用

String c = "AOP";
boolean r = c.contains("A");//判断传入的字符串内容是否存在当前这个变量c中
System.out.println(r);

String不适合频繁的修改，一旦发生修改，就是创建对象，若频繁的使用Sring修改，对内存的消耗非常大！容易出现异常，java.lang.OutOfMemoryError内存溢出

4、StringBuilder、正则表达式

解决当侵犯的对字符串进行修改时，可以使用Java提供的StringBuilder

因为StringBuilder内部维护了可变char数组，修改性能小，提供很多字符串修改相关的操作。

增删改插

        //增
        String str = "好好学习Java!";
        StringBuilder builder = new StringBuilder(str);//创建对象并传入要处理的字符串对象
        //append 字符串追加
        builder.append("为了找份好工作");
        System.out.println(builder);
        //改
        //好好学习Java!为了找份好工作  修改为好好学习Java!为了改变世界
        //replace 替换   1. 替换开始索引  2.结束的索引(包头不包尾)  3.替换的内容
        builder.replace(9, 16, "为了改变世界");
        System.out.println(builder);
        //删
        //delete 1.从哪里开始索引删除   2.到哪里结束索引(包头不包尾)
        builder.delete(0,9);
        System.out.println(builder);
        //插
        //insert  1.从哪里开始插入(索引)  2.插入的内容
        builder.insert(0,"活着");
        System.out.println(builder);
        //字符串内容反转
        //reverse反转
        builder.reverse();
        System.out.println(builder);
        str = builder.toString();//将处理好的字符串对象 再赋值给 str
        System.out.println(str);

正则表达式

正则报表式可以用来检测格式是否正确的功能，例如：邮箱的格式，手机号，身份证号码格式...都可以用正则来进行约束用户输入的数据

基本正则表达式：

[]表示的是一个字符的意思

[a,b,c]表示可以写任意一个a或者b或者c其中一个字符

[^abc]表示的是除了a或者b或者c之外的任意的任意字符串

[a-z]表示的是可以任意写一个26个小写字母其中一个字符

[a-zA-Z0-9]表示的是可以写任意一个26个小写字母或者26个大写字母或者0-9的数字

[a-z&&[^bc]] 表示的是 26个小写字母中,除了bc 不可以写,其它都可以写

预定字符集

.表示任意一个字符

\d表示可以写任意一个数字字符

\w表示单个词的字符

\s表示空白字符

\d表示非数字字符

\W表示非字母或数字字符

\S表示废空白的字符

?   代表可以写 0 - 1次
    例如：[abc]? 表示可以写一个 a 或 b 或 c,不能写其它的字符内容。
+   代表至少出现1次以上 没有上限
     例如：[abc]+ 表示至少写一个a 或 b 或 c内容,可以出现多次,但不能写其它的字符内容。
*   代表任意次,一次不写也可以    
---------------------------
限制次数 
        [abc]{3} 代表写3个字符
        [abc]{3,5} 代表至少写3个 最多写5个 
        [abc]{3,}  代表至少写3次 没有上限

分组

(abc){3}  表示：可以视为abc为一组  至少出现3组的意思
(abc|def){3}    表示:可以视为abc 或 def 为一组 至少出现3组的意思

正则表达式判断是否是邮箱

 String email = "bjzhangpeng@tedu.com.cn";
        String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
        boolean match = email.matches(regex);//判断传入的正则表达式的格式 是否与 当前字符串对象中的邮箱格式匹配
        if(match){
            System.out.println("是邮箱");
        }else {
            System.out.println("不是邮箱！");
       }

正则表达式切割的使用方式

String str = "abc123def456ghi";
                                        //0-9的数字出现一个或多个的地方来进行切割
        String[] data = str.split("[0-9]+");//传入正则表达式 根据正则的格式来进行切割
        for (int i = 0; i < data.length; i++) {
           // System.out.println(date[i]);
        }
        String str1 = "a,b,c,d,e,f";
        String[] data1 = str1.split(",");//也可以传入字符串的内容  根据具体的内容来进行切割
        for (int i = 0; i < data1.length; i++) {
            System.out.println(data1[i]);
        }

正则表达式替换的使用方式

 String regex = "(sb|tmd|nc|wr|qnmd|dsb)";
        String message= "qnmd!你个dsb,你怎么这么nc!";
                                 //1.传入需要匹配的正则格式
                                // 2.若匹配时所替换的内容
        message = message.replaceAll(regex,"小可爱");
        System.out.println(message);
//        message = message.replaceAll(regex, "小可爱");
//        System.out.println(message);
        String str2 = "abc12de3f456";
        str2 = str2.replaceAll("[0-9]+", "NUMBER");
      //  System.out.println(str2);
        //replaceAll 支持正则的替换功能 , 也支持第一个参数填入具体的内容,匹配则全部替换。
        //replace   不支持正则的替换功能, 只要被替换的内容存在,则全部替换。

        String str3 ="abc123def123";
               //replace  方法   1.需要被替换的内容
                              //2. 实际替换的内容
        str3 = str3.replace("123","456");
        System.out.println(str3);

5、Object、包装类

object是所有类的直接父类或间接父类

我们所创建的类，默认继承了object这个类

为什么需要object类，因为Object类承载了所有类的共性内容，为Java提供了一系列的基础结构支撑，是所有类的（父类/基类）

5.1 创建一个point类

package object;
/**
 * point 代表点的意思。
 *
 * */
public class Point {

    private int x;//属性x
    private int y;//属性y

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}