关卡9--封装

最新推荐文章于 2024-05-06 21:32:45 发布

pupu-TUT

最新推荐文章于 2024-05-06 21:32:45 发布

阅读量136

点赞数 1

文章标签： jvm java 开发语言

本文链接：https://blog.csdn.net/qq_65008195/article/details/125916354

版权

1.封装

是面向对象三大特征之一（封装，继承，多态）

是面向对象编程对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作

封装的原则

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

成员变量private，提供对应的getXxx和setXxx（）方法

封装的好处：通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

2.构造方法

构造方法的概述

构造方法是一种特殊的方法作用是用来创建对象
在这里插入图片描述

功能：主要是完成对象数据的初始化

3.构造方法的注意事项

当一个类中没有给构造方法，系统将会给出一个默认的构造方法

如果自定义了一个带参构造方法，还想写一个无参构造方法，就要写一个无参构造方法

4.标准类的制作

成员变量使用private修饰；一个无参构造方法；一个带多个参数的构造方法；提供每个成员变量对应的set/get；提供一个显示对象信息的show

创建对象给成员赋值：

无参构造方法创建对象后使用set方法赋值

使用带参构造方法直接使用带有属性值的对象

5.字符串

A P I :

概述:应用程序编程接口

j a v a A P I:

指的就是JDK中提供各种功能的Java类

调用方法的时候，如果方法有明确的返回值，我们用变量接受

也可以手动完成，也可以快捷键完成

6. String构造方法

public String()
public String(char[] chs)
public String(byte[] bys)
String s = "abc";

String对象的特点

1.通过new创建的字符串对象，每次new都会申请一个内存空间，虽然字符串相同但地址值不同

2.以""方式给出的字符串，只要字符序列相同无论在代码中出现几次 jvm都只会建立一个String对象并在字符串池中维护

main方法先加载到栈内存在堆内存内创建一个字符数组 chs通过001指向数组

7.字符串的比较

使用==作比较

基本类型：比较的是数据值是否相同

引用类型：比较的是地址值是否相同

字符串是对象，它比较内容是否相同是通过一个方法来实现的**“equals”**（只能比较内容）

public boolean equals(Object and Object)

将此字符串与指定对象进行比较。我们比较的是字符串对象，所以参数直接传递一个字符串

案例：用户登录

package denglu;

import java.util.Scanner;

public class Login {
    public static void main(String[] args) {
        String a = "125411";
        String b = "12543";
        for(int i = 5;i>=0;i--){
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入用户名");
            String c =sc.nextLine();
            System.out.println("请输入密码");
            String d =sc.nextLine();
            if(a.equals(c)&&b.equals(d)){
                System.out.println("登陆成功");
                break;
            }else{
                System.out.println("请重新输入,你还有"+(i-1)+"次机会");
            }
        }
    }
}

案例：遍历字符串

键盘录入一个字符串，使用遍历实现在程序台遍历该字符串

思路：

键盘录入一个字符串，用Scanner实现

遍历字符串，首先能够获取字符串中的每一个字符 public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从零开始的

遍历字符串，其次要能够获取到字符串的长度

public int length():返回此字符串的长度

字符串的长度：字符串对象.length

package denglu;

import java.util.Scanner;

public class StringBian {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine();
        for(int i = 0;i<a.length();i++){
            System.out.println(a.charAt(i));
        }
    }
}

案例：统计字符次数

package denglu;

import java.util.Scanner;

public class Number {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String xx = sc.nextLine();
        int A = 0;
        int a = 0;
        int Digit = 0;
        for(int i = 0 ;i<xx.length();i++){
            if('A'<=xx.charAt(i)&&xx.charAt(i)<='Z'){
                A++;
            }else if('a'<=xx.charAt(i)&&xx.charAt(i)<='z'){
                a++;
            }else if('0'<=xx.charAt(i)&&xx.charAt(i)<='9'){
                Digit++;
            }else{
                continue;
            }
        }
        System.out.println(A);
        System.out.println(a);
        System.out.println(Digit);
    }
}

案例：拼接字符串

package splicing;

import jdk.internal.dynalink.beans.StaticClass;

public class Splicing1 {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        String a = kuku (arr);
        System.out.println(a);
    }
    public static String kuku(int [] arr){
        String s = "";
        s+="[";
        for(int i = 0;i<arr.length;i++){
            s+=arr[i];
            s+=" ,";
        }
        s+="]";
        return s;
    }
}

案例：字符串反转

package splicing;

import java.util.Scanner;

public class Rollback {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String car = sc.nextLine();
        String c=xx(car);
        System.out.println(c);
    }
    public static String xx(String car){
        String a ="";
        for(int i = car.length()-1;i>=0;i--){
            System.out.print(car.charAt(i));
            a+=car.charAt(i);
        }
        return a;
    }
}

帮助文档

String Builder

概述

是一个可变的字符串类，可以看成一个容器

这里的可变指的是String Builder中的内容是可变的

String和String Builder的区别

前者是不可变的后者是可变的

StringBuilder构造方法

public StringBuilder() 创建一个空白可变字符对象，不含有任何内容
public StringBuilder(String a)根据字符串内容来创建字符串可变对象

StringBuilder添加和反转方法

public StringBuilder(任意类型)  添加数据，并返回对象本身
public StringBuilder reverse() 返回相反的字符序列

package bulider;

public class Builder {
    public static void main(String[] args) {
        StringBuilder a = new StringBuilder();
        a.append(100).append('c').append(111);
        System.out.println(a);
        a.reverse();
        System.out.println(a);
    }
}

StringBuilder和String相互转换

从 StringBuilder转化为String：

public String toString（）：通过toString方法就可以把前者转化为后者

String转化为StringBuilder：通过构造方法就可以实现把一个String转化为StringBuilder

package bulider;

public class Invert {
    public static void main(String[] args) {
        //SrringBuilder转化为String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
        String s = sb.toString();
        System.out.println(s);
        //String 转化为SB
        String a = "hello";
        StringBuilder SB = new StringBuilder(s);
        System.out.println(SB);
    }
}

案例：拼接字符串

package pinjie;

public class Pin {
    public static void main(String[] args) {
        int arr[]={1,2,3};
        String a = xxx(arr);
        System.out.println(a);
    }
    public static String xxx (int arr[]){
        StringBuilder x = new StringBuilder();
        x.append("[");
        for(int i = 0 ;i<arr.length;i++){
            if(i==arr.length-1){
                x.append(arr[i]);
            }else{
                x.append(arr[i]).append(", ");
            }
        }

        x.append("]");
        String s = x.toString();
        return s;
    }
}
采用这种方法会节省效率和空间

案例：字符串反转（升级版）

package pinjie;

import java.util.Scanner;

public class Fan {
    public static void main(String[] args) {
        System.out.println("请输入一个字符串：");
        Scanner sc = new Scanner(System.in);
        String x = sc.nextLine();
        String a =wsy(x);
        System.out.println(a);
    }
    public static String wsy(String x){
       /* StringBuilder SB = new StringBuilder(x);
        SB.reverse();
        String a = SB.toString();
        return a;*/
        return new StringBuilder(x).reverse().toString();//这两个等价 
    }
}

er(System.in);
String x = sc.nextLine();
String a =wsy(x);
System.out.println(a);
}
public static String wsy(String x){
/* StringBuilder SB = new StringBuilder(x);
SB.reverse();
String a = SB.toString();
return a;*/
return new StringBuilder(x).reverse().toString();//这两个等价
}
}