Java - 类与对象

概念

类是对现实生活中一类具有共同属性和行为的事物的抽象。

类的特点

类是对象的数据类型。

类是具有相同属性和行为的一组对象的集合。

对象的概念

既表示客观世界问题空间中的某个具体的事物，又表示软件系统解空间中的基本元素。

对象的属性：对象所具有的各种特征，每个对象的每个特征都拥有特定的值

对象的行为：对象能够执行的操作

 
 

类的定义

类是Java程序的基本组成单位

类的组成：属性和行为

属性：在类中通过成员变量来体现（类中方法外的变量）

行为：在类中通过成员方法来体现（和前面的方法相比去掉了static关键字即可）

定义类的步骤：

1、定义类

2、编写类的成员变量

3、编写类的成员方法

案例

public class phone{
    String name;
    String brand;
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
}

使用类创建对象

类名 对象名 = new 类名();

phone p = new phone();

 
 

对象内存分配

1、创建单个对象在内存中如下图所示

加载对象中方法时方法会被加载到栈内存中进行调用。

 

2、创建一个对象指向已有的对象（会指向同一地址）

  
 

成员变量与局部变量

 
 
 

private

是一个权限修饰符

可以修饰成员，作用是不被别的类使用，被private修饰的成员只能在本类中使用

如果需要被其他类使用，则

提供 get变量名() 方法，用于获取成员变量的值，方法用public修饰

提供 set变量名() 方法，用于设置成员变量的值，方法用public修饰

public class student{
    //变量都为私有
	private String name;
	private int age;
    //通过get来让外部访问
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

 
 

this

this修饰的变量用于指代成员变量

（方法的形参与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量）

用于解决局部变量隐藏成员变量。

public class student{
    private int age;
    
    public void setAge(int age){
        this.age = age;//this使其指向了成员变量
    }
}

 
 

封装

是面向对象的三大特征之一。

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

封装原则

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

例如成员变量private，提供对应的get()和set()方法

封装的好处

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

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

构造方法

主要完成对象数据初始化。

public class 类名{
    修饰符 类名(参数){    //方法构造
    }
}

如果没有定义构造方法，系统将给出一个默认的无参数构造方法

如果定义了构造方法，系统将不再提供默认的构造方法。

不论是否使用，都手工写无参数构造方法

一个标准类的制作有

①成员变量

使用private制作

②构造方法

提供一个无参构造方法

提供一个带多个参数的构造方法

③成员方法

提供每一个成员变量对应的setxxx()/getxxx()

提供一个现实对象信息的show()

无参构造法用setxxx()来设置赋值

带参构造法直接创造带有属性值的对象

案例

public class student {
    private String name;
    private int age;

    public student(){ } //该方法是无参调用
    public student(String name,int age){  //该方法为代参调用
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
}

 
 

String

字符串不可变，他的值在创建后不能被修改

可以被共享

字符串效果上相当于字符数组（char[]），但底层原理是字节数组（byte[]）

所以字符串跟字符数组不可混淆
 

 

String 的构造方法

//创建一个空白字符串对象
String s1 = new String();
//根据字符数组创建字符串对象
char[] chs = {'a','b','c'};
String s2 = new String(chs);
//根据字节数组创建字符串对象
byte[] bys = {97,98,99};
String s3 = new String(bys);
//直接创建
String s4 = "abc";

 
 

String对象的特点

1、通过new创建的字符串对象，每一次new都会申请一个内存空间，即使内容相同，但地址不同

char[] s = {'a','b','c'};
String s1 = new String(s);
String s2 = new String(s);

2、以“”方式给出的字符串，只要字符序列相同，无论在程序代码中出现多少次，

JVM都只会建立一个String对象，并在字符串池中维护。

String s3 = "abc";
String s4 = "abc";

s3和s4在常量池中是同一个对象。

 
 

字符串的比较

使用“==”做比较

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

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

基本类型包括 int byte short long float boolean double char

引用类型包括 Function,Array,Object,String

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫做：equals()

• public boolean equals(Object)：将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传递一个字符串。

char[] chs = {'a','b','c'};
String s1 = new String(chs);
String s2 = "abc";

//比较对象地址是否相同
System.out.println(s1==s2);
//比较字符串内容是否相同
System.out.println(s1.equals(s2));

字符索引

格式：字符串变量.charAt(int index);

字符串变量长度

格式：变量名.length

字符串拼接

定义一个String的对象

对该对象进行 += “字符串" 即可完成拼接

案例

public class StringTest1 {
    public static void main(String[] args) {
        int[] array = {1,2,45,6,7,8};
        String s = arrayToString(array);
        System.out.println(s);
    }

    public static String arrayToString(int[] arr){
        String s = "[";
        for(int i = 0;i<arr.length;i++){
            s += arr[i];
            if(i!=arr.length-1)
                s+=',';
        }
        s += ']';
        return s;
    }
}

//[1,2,45,6,7,8]

缺点是每次拼接都会创建一个String对象

因为字符串创建后是不能被修改的
 
 

StringBuilder的构造

格式：

StringBuilder str = new StringBuilder();

 

StringBuilder的操作

格式：

字符串对象.append(任何数据类型)  //添加数据，并返回对象本身
字符串对象.reverse()   //返回相反的字符序列（逆置）

链式编程法

StringBuilder str = new StringBuilder();
str.append("abc").append("123").append(20).append(true);
System.out.println(str);

//abc12320true

 

String 与 StringBuilder 相互转换

public String toString() 通过toString()实现把StringBuilder转换为String

public StringBuilder(String s) 通过构造方法实现把String 转换为 StringBuilder

 

StringBuilder字符串拼接

案例

public class StringTest1 {
    public static void main(String[] args) {
        int[] arr = {12,23,4,5,6};
        System.out.println(arrayToString(arr));

    }
    public static String arrayToString(int[] arr){   //可以改成public static StringBuilder,
        StringBuilder s = new StringBuilder();       //最后return改成StringBuilder
        s.append("[");
        for(int i=0;i<arr.length;i++)
        {
            if(i!=arr.length-1)
                s.append(arr[i]).append(",");
            else
                s.append(arr[i]).append("]");
        }
        return s.toString();
    }
}

 
 

常见类

Date

date 不是static类型，需要创建对象

public Date() 分配一个Date对象，并将其初始化，以便代表它被分配的时间，精确到毫秒

public Date(long date) 分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

如果括号不填默认显示运行时间。

分配基准时间是从1970年1月1日0时开始算起，单位是毫秒。例如1000 * 60 * 60得到的数输进去就是1970年1月1日1时

public long getTime() 获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值

public void setTime(long time) 设置时间，给的是毫秒值

 
 

SimpleDateFormat

是一个具体类，用于以区域设置敏感的方式格式化和解析日期。

public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认模式和日期格式

public SimpleDateFormat(String pattern) 使用指定pattern格式

常用模式字母对应关系如下：

y 年 | M 月 | d 日 | H 时 | m 分 | s 秒

使用Ⅰ：date->string

这里要用到方法 public final String format(Date date) 将日期格式化成字符串

Date a = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("y-M-d H:m:s");
String s = sdf.format(a);
System.out.println(s);

使用Ⅱ：string->date

public Date parse(String source) 从给定字符串的开始解析文本以生成日期

String s = "2022-1-1 17:30:45";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date ss = sdf.parse(s);
System.out.println(ss);