三、Java面向对象

1 . 方法

• 方法(method)是程序中最小的执行单元
• 方法就是一些代码的打包 需要的时候可以直接调用
• 方法之间是平级的关系 不能在方法里面定义方法
• 方法不调用就不执行

方法的定义

// 方法的定义
/*
[修饰符] 返回值类型 方法名称([参数 1],[参数 2]){
	语句A;
	
	return 返回值;
}
*/

// 创建一个方法 max_arrays 参数为一个数组 返回值为int类型
// 返回数组中的最大值
int max_arrays(int[] a){
    int max=a[0];
    for(int i=1;i<a.length;i++){
        max=max<a[i]?a[i]:max;
    }        
    return max;
}

// 不带返回值的方法 void
// 创建一个方法 方法中输出 "Hello World!"
// 没有返回值的方法 return 可以省略不写
// 如果要编写 return 则后面不能添加数据
void _print(){
    System.out.println("Hello World!");
}

方法的重载

• 在同一个类中定义了多个同名的方法 这些同名的方法具有近似的功能
• 每个方法需要的参数类型或者参数数量都互不相同 这些同名的方法 就构成了重载关系
• 同一个类中不能定义 方法名与所需参数完全相同的两个方法

// 定义三个方法 需要分别返回 两个数 三个数 四个数之间的最大值
int max(int a,int b){
    return a>b?a:b;
}
int max(int a,int b,int c){
    return max(a,max(b,c));
}
int max(int a,int b,int c,int d){
    return max(max(a,b),max(c,d));
}

方法的基本内存原理

• Java的内存分配
  • 栈 方法运行时使用的内存 方法进栈运行, 运行完毕就出栈
  • 堆 new出来的 都在堆内存中开辟一个小空间
  • 方法区 存储可以运行的class文件
  • 本地方法栈 JVM在使用操作系统功能的时候使用 和我们无关
  • 寄存器 给CPU使用 与开发无关

public class main {
    static int max(int a,int b){
        return a>b?a:b;
    }
    public static void main(String[] args) {
		int c=max(10,23);
    }
}
/*
刚开始程序运行 main方法入栈 接着调用 max 方法,max方法入栈之后运行判断大小语句并返回值 返回之后 max方法运行完毕出栈
再回到main函数 main函数运行完之后也出战 程序运行完毕
*/

基本数据类型和引用数据类型

基本数据类型	引用数据类型
整数类型 浮点数类型 字符类型 布尔类型	除了左边的基本数据类型都是引用类型 例如 字符串等

基本数据类型

• 数据值是存储在自己的空间中
• 赋值给其他变量,也是赋真实的值
• 方法传递基本数据类型时 传递的是真实的数据 并不会改变实际参数的值

public class main {
    public static void main(String[] args) {
		int a=10;
    }
}
/*
基本数据类型存储的都是自身的值
int a=10 就是在栈内存中开辟了一块int类型的空间 存储的值为10
*/

引用数据类型

• 数据值是存储在其他的空间中 自己空间中存储的只是数据的地址值
• 赋值给其他变量也是赋的地址值
• 方法在传递引用数据类型时 传递的是地址值 形参的改变 会影响实际参数的值

public class main {
    public static void main(String[] args) {
		int[] a=new int[]{1,2,3};
        String s="123";
    }
}
/*
引用数据类型的数据都是存储在堆空间当中
int[] a=new int[]{1,2,3}; 就是在堆内存中开辟了一个长度为3的数组 并且把数组在堆内存当中的地址值赋值给了变量 a
a就可以通过地址值在堆内存当中找到数组的元素
*/

2 . 面向对象

类和对象

• 类 (设计图) : 是对象共同特征的描述
• 对象 : 是真实存在具体的东西

在Java中必须先设计类,才能获得对象

类的定义

• 一个Java文件中可以定义多个class类 且只有一个类是 public 修饰,并且public修饰的类名必须与文件名相同
• 实际开发中一个Java文件一般只会定义一个类

/*
public class 类名{
	成员变量 (代表属性 一般是名词)
	成员方法 (代表行为 一般是动词)
	构造方法
	...
}
*/


//定义一个学生类 需要存储学生的 姓名 年龄 学号 ,学生的行为有 学习
public class Student {
    //属性
    String name;
    int age;
    String ID;

    //行为
    public void s(){
        System.out.println("学生在学习");
    }
}

成员变量的初始默认值

数据类型	类型	默认值
基本数据类型	整数	0
基本数据类型	小数	0.0
基本数据类型	布尔	false
引用数据类型	类,接口,数组,String	null

类的使用

public class main {
    public static void main(String[] args) {
        //创建一个学生类
        Student s=new Student();
        
        //给类中的属性赋值
        s.name="张三";
        s.age=13;
        s.ID="00001";
		
        //调用类中的方法
        s.s();        
    }
}

3 . 封装

• 对象代表什么 就得封装对应的数据 并提供数据对应的行为

this关键字

• 获取类中成员变量的值

// 定义一个学生类 添加成员变量 期末考试成绩, 添加成员方法 比较期末考试成绩大小 如果成员变量的大 返回true 否则false
public class Student {
    String name;
    int age;
    double resule;
    String ID;

    // 在这个方法中 形参与成员变量重名
    // 第一个this.result获取到的就是成员变量result的值 第二个不带this的result获取到的就是方法接收到的值
    public boolean comp(double result){
        return this.result>result;
    }
}

构造方法

• 构造方法没有返回值
• 构造方法必须与类名相同
• 构造方法可以重载
• 一般设计类会有空参构造和全参构造两种

//设计带构造方法的学生类 并且在类中添加一个打印学生所有属性的方法
public class Student {
    String name;
    int age;
    String ID;
	
    //全参构造
    public Student(String name, int age, String ID) {
        this.name = name;
        this.age = age;
        this.ID = ID;
    }
	
    //空参构造
    public Student() {
    }

    public void s(){
        System.out.println("学生在学习");
    }
    
    public void p(){
		System.out.println(this.name+" "+this.age+" "+this.ID);
    }
}

带有构造方法的类可以在创建类时自动赋值

//创建一个学生类 并且初始化学生的姓名 年龄 ID
public class main {
    public static void main(String[] args) {
        Student s=new Student("张三",13,"00001");
        s.p();
    }
}
//程序输出为 :张三 13 00001

private关键字

• 一个权限修饰符
• 可以修饰成员变量与成员方法
• 被private修饰的成员只能在本类中访问

// 刚刚在上面的学生类中 我们创建了学生类 可以之间通过 变量名.成员变量之间修改
// 但是这样修改数据不安全 明显年龄只能是正数 但是随意修改可以变成负数
// 给 成员变量添加 private 关键字之后 就不能在外部修改与访问成员变量 只能在类中才能获取

// 通过与this关键字相结合 设计一个学生类 包含学生的姓名 年龄
// 通过get方法获取成员变量的值 通过set方法修改成员变量的值
public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        setName(name);
        setAge(age);
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        // 传过来的age必须大于0才能修改年龄的值
        if(age>0){
            this.age = age;
        }
    }
}

标准的Javabean类

• 类名需要见名知意
• 成员变量需要使用private修饰, 并提供相应的get set方法
• 至少提供两个构造方法
  • 全参构造
  • 无参构造
• 位对应的行为提供相应的方法

创建一个标准的用户类

public class User {
    // 用户名
    private String name;
    // 邮箱
    private String email;
    // 密码
    private String password;
    // 年龄
    private int age;

    // 空参构造
    public User() {
    }

    // 全参构造
    public User(String name, String email, String password, int age) {
        this.name = name;
        this.email = email;
        this.password = password;
        this.age = age;
    }
	
    // 所有成员变量的get() set()方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

一个对象的内存图

public class main {
    public static void main(String[] args) {
        User u=new User("张三","123@163.com","123456",13);
    }
}
/*
1. 加载class文件 
2. 申明局部变量
3. 在堆内存中开辟一个空间
4. 默认初始化
5. 显示初始化
6. 构造方法初始化
7. 将堆内存中的地址赋值给左边的变量
*/

成员变量和局部变量

• 成员变量 : 类中方法外的变量
• 局部变量 : 在方法中定义或在方法申明上的变量

成员变量和局部变量的区别

区别	成员变量	局部变量
类中位置不同	类中、方法外	方法内定义、方法申明上
初始化值不同	有默认初始化值	无默认初始化值
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的创建而创建 随着对象的消失而消失	随着方法的调用而出现 随着方法的运行结束而消失
作用域不同	整个类中有效	整个方法中有效

4 . 字符串 String

String 概述

• String是Java定义好的一个类 定义在java.lang包中 所以在使用的时候不需要导包

• Java程序中所有的字符串文字 (“123”,“abc”)都被识别位此类的对象

• 字符串的内容是不会发生改变的 它的对象在创建后不能被更改

String 的构造方法

构造方法	说明
public String()	创建空白字符串,不包含任何内容
public String(String original)	根据传入的字符串,创建字符串对象
public String(char[] chs)	根据传入的char数组,创建字符串对象
public String(byte[] chs)	根据传入的byte数组,创建字符串对象
…	…

创建String的两种方式

public class test {
    public static void main(String[] args) {
        // 直接赋值创建
        String s1="abc";
        // 使用构造方法创建
        String s2=new String();
    }
}

String 的常用方法

返回值	方法体	说明
char	charAt(int index)	返回 char指定索引处的值。
int	codePointAt(int index)	返回指定索引处的字符（Unicode代码点）。
String	concat(String str)	将指定的字符串连接到该字符串的末尾。
boolean	contains(CharSequence s)	判断当前字符串是否包含指定字符。
boolean	equals(Object anObject)	将此字符串与指定对象进行比较。
int	indexOf(int ch)	返回指定字符第一次出现的字符串内的索引。
String	trim()	返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。
char[]	toCharArray()	将此字符串转换为新的字符数组。
int	length()	返回此字符串的长度。

String 的比较

• Java中字符串不能使用 ==号来进行比较
• String是引用数据类型 使用==进行比较比较的是String在堆空间存储的地址值
• 字符串的比较需要使用String自带的 equals()方法来进行比较

String s=new String("1234");
System.out.println(s.equals("1234"));// true
System.out.println(s=="1234");// false

StringBuilder

• 一个可变的字符序列。

构造方法

构造方法	说明
StringBuilder()	构造一个没有字符的字符串构建器，初始容量为16个字符。
StringBuilder(CharSequence seq)	构造一个包含与指定的相同字符的字符串构建器 CharSequence 。
StringBuilder(int capacity)	构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量。
StringBuilder(String str)	构造一个初始化为指定字符串内容的字符串构建器。

常用方法

返回值	方法体	说明
StringBuilder	append(任意类型)	将指定的参数附加到此字符序列。
String	toString()	返回表示此顺序中的数据的字符串。
StringBuilder	reverse()	反转字符序列并返回。

字符串相关类的底层原理

• 字符串存储的内存原理
  • 直接赋值会复用字符串常量池中的
  • new出来的不会复用 而是开辟一个新的内存空间
• == 比较的是什么
  • 基本数据类型比较的是值
  • 引用数据类型比较的是地址值
• 字符串拼接的底层原理
  • 如果没有变量参与 都是字符串直接相加 编译之后就是拼接之后的结果 会复用串池的字符串
  • 如果有变量参与 每一行拼接的代码 都会在内存中创建新的字符串 浪费内存
• StringBuilder提高效率
  • 所有要拼接的内容都会往StringBuilder中放 不会创建很多无用的内存 节省内存

5 . 集合 ArrayList

• 可以存储基本数据类型
• 可以存储引用数据类型
• 可以存储自定义数据类型
• 集合长度可变 跟随存储的数据数量自动扩容

创建集合

/*
ArrayList<E> 集合名 = new ArrayList<E>();
E : 泛型
ArrayList 创建基本数据类型时,不能直接使用 int flaot.. ,只能使用基本数据类型对应的包装类
*/

ArrayList<Integer> list=new ArrayList<Integer>();

基本数据类型对应包装类

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

构造方法

方法体	说明
ArrayList()	构造一个初始容量为十的空列表。
ArrayList(Collection<? extends E> c)	构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
ArrayList(int initialCapacity)	构造具有指定初始容量的空列表。

常用方法

返回值	方法名	说明
int	size()	返回集合的长度
E	gte(int index)	获取指定下标的元素
E	set(int index,E e)	修改指定下标的元素,返回被修改的元素
E	remove(int index)	删除指定位置的元素,返回被删除的元素
boolean	add(E e)	添加元素 返回值表示是否添加成功
boolean	remove(E e)	删除第一个==e的元素 返回值表示是否删除成功

集合的基本使用

遍历集合

public static void main(String[] args) {
    ArrayList<Integer> list=new ArrayList<Integer>();
    for (int i = 0; i < 100; i++) {
        list.add(i);
    }
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

集合的长度 |
| E | gte(int index) | 获取指定下标的元素 |
| E | set(int index,E e) | 修改指定下标的元素,返回被修改的元素 |
| E | remove(int index) | 删除指定位置的元素,返回被删除的元素 |
| boolean | add(E e) | 添加元素 返回值表示是否添加成功 |
| boolean | remove(E e) | 删除第一个==e的元素 返回值表示是否删除成功 |

集合的基本使用

遍历集合

public static void main(String[] args) {
    ArrayList<Integer> list=new ArrayList<Integer>();
    for (int i = 0; i < 100; i++) {
        list.add(i);
    }
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}