Java小白（09）——面向对象（2）

最新推荐文章于 2024-08-13 10:34:11 发布

R.任小白

最新推荐文章于 2024-08-13 10:34:11 发布

阅读量171

点赞数

分类专栏： Java 文章标签：字符串 java

本文链接：https://blog.csdn.net/qq_40875544/article/details/103086109

版权

Java 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

1、包

包的命名：所在组织的域名倒过来写

java对于所有出现在自己工程的类是按包管理的，没有建包时Java默认一个空包，

在另外一个类中引用不同包的类时必须引入包，引入包时一定在package包名称下面

import 包名称.子包名称.类名称;    //手动导入包

import  包名称.字包名称.*;      //由JVM自动加入加载所需要的类

2、访问控制

友元关系
公有
public：被public修饰的属性或方法在任意其他类其他位置都可以看见（访问或调用）；
私有
private：只能在本类中调用的属性；

访问控制符可以修饰类，方法，属性；
当不加任何访问控制修饰符时，默认为package，即只能在同包下面访问；

Java里的对象和内存的关系

Java的内存一定在Java虚拟机（JVM）中分的，Java内存分为五部分：（1）程序计数器，不起到任何存储的作用，里面只有一个行号计数器记录代码运行的行数，（2）栈，在栈里面存的是物理地址（3）堆（常量池也在堆里）（4）静态常量池（在一开始JVM就创建了0-127个数字）（5）方法区

栈：只记录开始

堆：对象真正保存在堆里

类只是一个模板真正执行代码的是对象
Car c = new Car(1000);

c.fo();  //c通过栈找到堆

Car a = new Car(999);

//当a等于null时a通过找到的是null,此时代码会报出一个空指针的错误

a = null; 

a.fo();

在这里插入图片描述
红色代表的是private，黄色代表的是不加访问控制时，只有在同包里的能调用，绿色代表的是public

- static

静态内容一定义开始就有，静态的内容放在元数据区内，在1.8版本以前叫永久代或持久代，静态东西先于对象存在；

动可调静静不可调动，即动态可以调用静态的内容，反过来不行,

动态出现的时候静态一定有，静态出现的时候动态不一定出现;

静态可以修饰属性，方法，内部类

public static String  name;

2、常用类

1、String

String是一个字符的容器，既然是一个容器，他一定符合容器的常用操作，求长，定位，替换，

String的两种创建对象的方式，在java.lang包下
String str = "liguocheng";
String str1 = new String("liguocheng ");

此时比较的是str1地址的开始和str的开始
System.out.println(str == str1);

str的liguocheng在静态常量池中，str直接指向常量池内容；
str1创建在堆里，里面保存的liguocheng也是在常量池中，此时str1先找到栈，从栈找到堆，再指向常量池；

String str = "liguocheng";

String str2 = "liguocheng";

在常量池中出现的数据不会出现第二次；此时str2还是原先的liguocheng；
两个==做判断时，只有都在常量池中才相等，一个在堆里一个在常量池中不相等，

System.out.println(str == str2);

String str2 = new String("liguocheng ");

String str3 = new String("liguocheng ");

System.out.println(str3 == str2);//此时结果显示为false，new等于在堆里建了对象，两个对象所指地址不同

两个==对比的是地址

在这里插入图片描述

字符串比较的时候一般比较的是内容，字符串用equals（）方法来比较

String str = "liguocheng";
String str1 = new String("liguocheng ");

System.out.println(str .equals(str1));

四类八种基础型数据直接赋值都在常量池中，只要是常量池的内容都可以用==作比较

基础数据类型的对象类型

（所有基础数据类型的对象类型都有两种赋值方式，直接赋值和创建对象赋值，直接赋值和创建对象赋值比较大小使用equals()作比较.一般用来作为辅助该种类的变量工具来使用）

1、int（int比较大小时应该用基础数据类型int比较）
**对于基础类型int比较时一定用基础类型来比较**
当不大于127时b和b1比较时指向同一个值，当大于127后，指向不同值

Integer  b = 14;//Integer是int的对象类型

Integer  b1 = 14;

Integer a = new Integer(14);

int c = 14;

2、Byte

Byte  b = 3;

Byte a = new Byte((byte)3);  //因为Java默认为int，因此要类型转换

3、short

Short  b = 3;

Short a = new Short((Short)3);

4、long

Long b = 3;

Long a = new Long(3);

5、Float

Float b = 3;

Float a = new Float(3.4f);

浮点型不能使用==比较，因为浮点数不能确定精确度，应该使用equals（）比较

6、Double

double  b = 3;

double a = new double(3.4);

浮点型不能使用==比较，因为浮点数不能确定精确度，应该使用equals（）比较

只要不存在浮动就可以使用==来比较

7、Char

character b = new character('b');

character c = 'c';

character a = 'c';

System.out.println(c==a);//c 和a可以用== 比较

8、Boolean

Boolean   c = new Boolean(flase);

Boolean b = flase;

Boolean a  =flase;

System.out.println(b==a);//无浮动是精确的可以用==比较

基础数据类型的一些方法


1、将一个字符串转为相应的类型
int a = Integer.parseInt("55");//将一个是数字的字符串变为int型的数字，不能将十六进制转为int
Byte a = Byte.parseByte("55");
Long a =Long.parseLong();
Float a = Float.parseFloat();
Double a = Double.parseDouble();
Boolean a = Boolean.parseBoolean()

只有character没有parse方法,因为本身就是字符组成的，转的过程只要找到一个一个字符，转的过程都拿String来转的
2、
charAt()从一个字符串中找到指定字符位置
String st = "a";
st.charAt(0);

3、compare()用来比较，用后一位减去前一位大于0证明前面大小与0后面大等于0一样大
System.out.println（Integer.compare(13,14);

4、bitCount()用来数位
System.out.println（Integer.bitCount(1);

5、decode()将十六进制转为int值 
   System.out.println（Integer.decode("0x65");

6、reverse()反转
00000000 00000000 00100000 00100000  8224
   倒过来
 00000100 00000100 00000000 00000000

7、MAX_VALUE 找到最大值
System.out.println(Integer.MAX_VALUE);
8、MIN_VALUE  找到最小值
System.out.println(Integer.MIN_VALUE);
9、MIN_NORMAL 自然数部分

字符串的一些常用方法

1、
char[] c = str.toCharArray();将字符串转为字符数组

2、split()按照指定的字符串堆字符串进行拆分

3、reverse()字符串反转

4、replaceAll()字符串替换

5、replace()字符串替换
 String a =  str.replace("r","e")； //替换,记住替换的不是原字符串，是返回一个新的对象a，字符串不可改变。

6、concat() 字符串拼接
 sc.delete(3,5);//删除从第四位开始删除5-3两个
 7、
 sc.insert(2,"zhi");//从第2位开始插入zhi

8、toUpperCase()将字符串变换大小写
  System.out.println(str.toUpperCase());

9、equalsIgnoreCase() 将str与str1对比,一样返回true      
 System.out.println(str.equalsIgnoreCase(str1));
       
10、contains()判断一个字符串中是否有包含指定的字符,输出truefalse
System.out.println(str.contains("ge"));//判断是否包含ge

11、startWith()判断是否是一个指定的字符串开始
System.out.println(str.startWith("g"));判断是否以g开头

12、endWith()判断是否以指定的字符串结尾

13、将字符串转为GBK形式
 String str2 = "任大圣";
        byte[] arra = str2.getBytes();
        String str4 = new String(arra,"GBK");
        System.out.println(str4);

StringBuffer()和StringBuilder()

 
StringBuffer用来操作String。StringBuffer里面内容可以改变
用StringBuffer与StringBuilder一样，区别只在前者线程安全，后者线程不安全
        //将字符串拼接起来
        //StringBuffer只有创建对象来赋值，创建一个StringBuffer类的对象
        StringBuffer sc = new StringBuffer("ren");
        sc.append("da");
        sc.append("sheng");
        System.out.println(sc);

字符串不可改变的特性导致直接操作字符串时会引起效率损耗问题，如两个字符串拼接，拼接完成会生成三个对象，五个字符串进行拼接，最后会出现9个对象，如果使用StringBuffer最后出现6个对象，尽量不要用+的方式进行字符串拼接。

replace（）和replaceAll（）区别
replace的参数是char和字符串，即可以支持字符的替换，也支持字符串的替换；
replaceAll的参数是regex，即基于规则表达式的替换，比如：可以通过replaceAll("\d", “*”)把一个字符串所有的数字字符都换成星号；
如果只想替换第一次出现的，可以使用replaceFirst()，这个方法也是基于规则表达式的替换，但与replaceAll()不同的是，只替换第一次出现的字符串。
“\”在java中是一个转义字符，所以需要用两个代表一个
用replaceAll替换“\”应是"\"，就要用replaceAll("\\","\\\\")，而replace则replace("\","\\")。

例题：

1、判断手机号是否合法

import java.util.Scanner;

public class Phone {

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个手机号：");
        String p = sc.next();
        if(p.length()==11){
         if(p.startsWith("13")||p.startsWith("15")||p.startsWith("17")||p.startsWith("18")||p.startsWith("19")){
             try{
                 long f = Long.parseLong(p);
             }
             catch (Exception e){
                 System.out.println("不合法1");
             }
             System.out.println("合法");

         }else{
             System.out.println("不合法2");
         }
        }else{
            System.out.println("不合法3");
        }

    }
}

2、回文字符串
如： abccba是回文字符串，上海自来水来自海上是回文字符串，abcd不是回文字符串
要求通过输入计算出该字符串是不是回文字符串

import java.util.*;
public class ReString{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
      while(true) {
        String str = sc.nextLine();
          
       StringBuffer st = new StringBuffer(str);
       String s = st.reverse().toString();
          
          if(str.equals(s)) {
              System.out.println("是");
          }else {
              System.out.println("不是");
          }
    }
}
}

3、统计输入的字符串里面，有多少个数字

import java.util.*
public class Total{
	public static void main(String[] args) {
		Scanner sc = new SCanner(System.in);
		while(true) {
			String str = sc.nexrLine();
			int num = 0;
			for(int i = 0;i<str.length();i++) {
				if(str.charAt(i)>='0'&&str.charAt(i)<='9'){
					num++;
				}
			}
			Systrem.out.println("有"+num+"数字")
		}
	}
}

4、统计字符串里面，出现最长连续数字的长度是多少
如：dghjk1234k5679jj 最长连续数字是1234 数字全是0123456789

import java.util.*;
public class ContinuousNum{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true) {
        	String str = sc.nextLine();
            int num = 0;

            for(int i = 0;i<str.length();i++) {
                int max = 1;
                int star = i;
                int end = i;
                if(str.charAt(i)>='0'&&str.charAt(i)<='9') {
                    while(i<str.length()&&str.charAt(i)>='0'&&str.charAt(i)<='9') {
                        end++;
                        i++;
                    }
                    for(int i = star;i<end-1;i++) {
                        if(str.charAt(i)-str.charAt(i+1)==-1) {
                            num++;
                            if(num>max) {
                                max = num;
                            }
                        }else {
                            max=1
                        }
                    }
                }
            }
            System.out.println(num);
        }
    }
}