Java基础学习-3

81~120

面向对象

面向：拿、找
对象：能干活的东西
面向对象编程：拿东西过来做对应的事情

面向对象编程符合人类思维习惯，编程更简单，更好理解

面向对象的学习：1、学习获取已有对象并使用，2、学习如何自己设计对象并使用

类和对象

类（设计图）：是对象共同特征的描述；
对象：是真实存在的具体的东西。
在Java中，必须先设计类，才能获得对象。

public class 类名{
	1、成员变量（代表属性，一般是名词）
	2、成员方法（代表行为，一般是动词）
	3、构造器
	4、代码块
	5、内部类
}

//such as
public class Phone{
	//属性（成员变量）
	String brand；
	double price；

	//行为（方法）
	public void call(){
		System.out.printIn("手机在打电话");
	}
	public void palyGame(){
		System.out.printIn("手机在玩游戏");
	}	
}

如何使用对象
访问属性：对象名.成员变量
访问行为：对象名.方法名（…）

public class PhoneTest{
	public static void main(String[] args){
		//创建手机的对象
		Phone p = new Phone();
		
		//叫做给手机赋值
		p.brand="小米";
		p.price=1999.98;
		
		//获取手机对象的值
		System.out.printIn(p.brand);
		System.out.printIn(p.price);
		
		//调用手机中的方法
		p.call();
		p.playGame();
	}
}

定义类的补充注意事项

用来描述一类事物的类，专业叫做：Javabean类。
在Javabean类中，是不写main方法的。

在以前，编写main方法的类，叫做测试类。
我们可以在测试类中创建javabean类的对象并进行赋值调用

类名首字母建议大写，需要见名知意，驼峰模式。
一个Java文件中可以定义多个class类，且只能有一个类是public修饰，而且public修饰的类名必须成为代码文件名。
实际开发中建议还是一个文件定义一个class类。
成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值；
一般无需指定初始化值，存在默认值。

封装

封装：如何正确设计对象的属性和方法
对象代表什么，就得封装对应的数据，并提供数据对应的行为
人画圆，画圆是圆的方法
人关门，关门是门的方法
张三砍死了李四，李四是自己凉的

好处：
让编程变得简单，有什么事，找对象，调方法就行
降低学习成本，可以少学，少记，或者说压根不用学，不用记对象有哪些方法，有需要时去找就行

private

是一个权限修饰符
可以修饰成员（成员变量和成员方法）
被private修饰的成员只能在本类中才能访问
针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
提供“setXxx（参数）方法”，用于给成员变量赋值，方法用public修饰
提供“getXxx（）”方法，用于获取成员变量的值，方法用public修饰

public class GirlFriend{
	private String name;
	private int age;
	private String gender;
}
//外部不能给private的赋值和调用

利用private做过滤通道

public class GirlFriend{
	private int age;
	public void setAge(int a){
		if(a>=18&&a<=50){
			age=a;
		}else{
			System.out.printIn("非法数据");
		}
	}
	public int getAge(){
		return age;
	}
}

this关键字

就近原则

public class GirlFriend{
	private int age;
	public void method(){
		int age=10;
		System.out.printIn(age);//此时输出为10
		System.out.printIn(this.age);//此时输出为0，全局中age的初始值
	}
}

private int age;
public void setAge(int age){
	//age=age;//自己赋值给了自己（局部变量中的age）
	this.age=age;
}

this的作用：可以区分成员变量和局部变量
this的本质和内存图：

构造方法

构造方法概述
构造方法也叫做构造器、构造函数
作用：在创建对象的时候给成员变量进行赋值的

构造方法：

public class Student{
	修饰符 类名（参数）{
		方法体；
	}
}

特点：
1、方法名与类型名相同，大小写也要一致
2、没有返回值类型，连void也没有
3、没有具体的返回值（不能由return带回结果数据）

执行时机：
1、创建对象的时候由虚拟机调用，不能手动调用构造方法
2、每创建一次对象，就会调用一次构造方法
如果我们自己没有写任何的构造方法，那么虚拟机会给我们追加一个空参构造方法

public Student(){
	System.out.printIn("看看我执行了吗")
}
public Student(String name,int age){
	this.name=name;
	this.age=age;
}

无参数构造方法：初始化的对象时，成员变量的数据均采用默认值
有参数构造方法：在初始化对象的时候，同时可以为对象进行赋值

JavaBean类

标准的JavaBean类
1、类名需要见名知意
2、成员变量使用private修饰
3、提供至少两个构造方法
（1）无参构造方法
（2）带全部参数的构造方法
4、成员方法
（1）提供每一个成员变量对应的setXxx（）/getXxx（）
（2）如果还有其他行为，也需要写上

快捷键：
alt+insert
快速生成JavaBean类

插件PTG
1秒生成标准JavaBean

内存图

一个对象的内存图

Student s=new Student();

1、加载class文件
2、申明局部变量
3、在堆内存中开辟一个空间
4、默认初始化
5、显示初始化
6、构造方法初始化
7、将堆内存中的地址赋值给左边的局部变量

等号的直接赋值是赋值上地址，并将被赋值与地址之间建立联系，而赋值与地址之间的联系断开，赋值的那个变成空

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

基本数据类型：数据值是存储在自己的空间中
特点：赋值给其他变量，也是赋的真实的值。

int a=10;
int b=a;

引用数据类型：数据值是存储在其他空间中，自己空间中存储的是地址值
特点：赋值给其他变量，赋的地址值

Student s1=new Student();
Student s2=new Student();
s1.num=10;
s2.num=s1;

this的内存原理

public class Student{
	private int age;
	public void method(){
		int age=10;
		System.out.printIn(age);
		System.out.printIn(this.age);
	}
}

this的作用：区分局部变量和成员变量
this的本质：所在方法调用者的地址值

成员变量和局部变量

成员变量：类中方法外的变量
局部变量：方法中的变量

类的小练习——new对象

//GrilFriend.java
public class GirlFriend {
    String name;
    int age;
    String gender;
    public void sleep(){
        System.out.println("女朋友正在睡觉");
    }
    public void eat(){
        System.out.println("女朋友正在吃饭");
    }
}

//GrilFriendTest.java
public class GirlFriendTest {
    public static void main(String[] args){
        GirlFriend gf1=new GirlFriend();
        gf1.name="花花";//别问，问就是女朋友的名字
        gf1.age=18;
        gf1.gender="女";
        System.out.println(gf1.name);
        System.out.println(gf1.age);
        System.out.println(gf1.gender);
        gf1.sleep();
        gf1.eat();
    }
}

APL和apl帮助文档

应用程序编程接口

使用帮助文档

1、打开帮助文档
2、点击显示,并找到索引下面的输入
3、在输入框中输入类名并点击显示
4、查看类所在的包
5、查看类的描述
6、查看构造方法
7、查看成员方法

字符串

java.lang.String类代表字符串,Java程序中的所有字符串文字都为此类的对象

String name="abaaba";
String schoolName="abaaba";

字符串不能发生改变,它们的值在创建后不能被更改

字符串方法

public String()----创建空白字符串,不含任何内容
public String(String original)----根据传入的字符串,创建字符串对象
public String(char[] chs)----根据字符数组,创建字符串对象
public String(byte[] chs)----根据字节数组,创建字符串对象

//1、使用直接赋值的方式获取一个字符串对象
String s1="abc";
System.out.println(s1);

//2、使用new的方式来获取一个字符串对象
//空参构造:可以获取一个空白的字符串对象
String s2=new String();
System.out.println("@"+s2+"!");

//传递一个字符串,根据传递的字符串内容再创建一个新的字符串对象
String s3= new String(original:"abc");
System.out.prinln(s3);

//传递一个字符串数组,根据字符串数组的内容再创建一个新的字符串对象
char[] chs={'a','b','c','d'};
String s4= new String(chs);
System.out.println(s4);

//传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
byte[] bytes={97,98,99,100};
String s5 =new String ();
System.out.println(s5);
//应用场景:以后在网络当中传输的数据其实都是字节信息
//我们一般要把字节信息进行转换,转成字符串,此时就要用到这个构造了

改变字符串内容：
将字符串改变为字符的数组，字符数组是可以改变的，改变完字符数组以后再转为字符串。

创建String对象

String name="尼古拉斯.阿伟";
String s1=new String();

当使用双引号直接赋值时,系统会检查该字符串在串池中是否存在
不存在:创建新的
存在:复用
每new一次就是在堆内存里开辟一个新的空间

比较方法

==号的比较
如果是基本数据类型,比较的则是值
如果是引用数据类型,比较的则是地址值

String s1="abc";
String s2="abc";
System.out.println(s1==s2);//true

String s1=new String("abc");//记录堆里面的地址值
String s2="abc";//记录的是串池中的地址值
System.out.println(s1==s2);//false

equals

引用数据类型的比较

boolean equals(要比较的字符串)

完全一样结果才为true,否则为false

equalsIgnoreCase

boolean equalsIgnoreCase(要比较的字符串)

忽略大小写的比较

字符串的遍历

//1、键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("");
String str = sc.next();
//2、进行遍历
for(int i=0;i<str.length();i++){
	char c = str.charAt(i);
	System.out.println(c);
}

StringBuilder

StringBuilder可以看成是一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率

构造方法
public StringBuilder()-----创建一个空白可变字符串对象，不含有任何内容
public String Builder(String str)----根据字符串的内容，来创建可变字符串对象

常用方法
public String Builder append(任意类型)----添加数据，并返回对象本身
public StingBuilder reserse()-----反转容器中的内容
public int length()----返回长度(字符出现的个数)
public String toString()----（通过toString（）就可以实现把StringBuilder转换为String）

StringBuilder sb = new StringBuilder("abc");
sb.append(1);
sb.append(2.3);
sb.append(true);
System.out.println(sb);
//打印：
//因为StringBuilder是java已经写好的类
//java在底层对他做了一些特殊处理
//打印对象不是地址值而是属性值

链式编程：
当我们在调用一个方法的时候，不需要用变量接受他的结果，可以继续调用其他方法

int len=getString().substring(1).replace(target:"A",replacement:"Q").length();
System.out.println(len);

StringJoiner

StringJoiner和StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的
提高字符串的操作效率，而且代码编写的特别简洁，但是目前市场上很少有人用

int[] arr={1,2,3};
StringJoiner sj= new StringJoiner(",","[","]");
for(int i=0;i<arr.length;i++){
	sj.add(arr[i]+"");
}
System.out.println(sj);//[1,2,3]

构造方法
public StringJoiner(间隔符号)----创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner(间隔符号，开始符号，结束符号)----创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号

成员方法
public StringJoiner add()----添加数据，并返回对象本身
public int length()----返回长度（字符出现的个数）
public String toString()----返回一个字符串（该字符串就是拼接之后的结果）

小总结

1、string
表示字符串的类，定义了很多操作字符串的方法
2、StringBuilder
一个可变的操作字符串的容器。
可以高效的拼接字符串，还可以将容器里面的内容反转
3、StringBuilder
JDK8出现的一个可变的操作字符串的容器，可以高效、方便的拼接字符串。
在拼接的时候，可以指定间隔符号，开始符号，结束符号

字符串原理

1、字符串存储的内存原理
直接复制会复用字符串常量池中的
new出来不会复用，而是开辟一个新的空间
2、==号比较
基本数据类型比较数据值
引用数据类型比较地址值
3、字符串拼接的底层原理
拼接的时候没有变量，都是字符串
触发字符串的优化机制
在编译的时候就已经是最终结果了

String s = "a"+"b"+"c";
System.out.println(s);

上述文件编译成class文件

String s = "abc";
System.out.printIn(s);

字符串拼接的时候有变量参与：

String s1="a";
String s2 = s1 + "b";
String s3 = s2 + "c";

在内存中创建了很多兑现那个
浪费空间，时间也非常慢

结论：
如果很多字符串变量拼接，不要直接+。在底层会创建多个对象，浪费时间，浪费性能。
如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串。
如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存。

4、StringBuilder提高效率原理图

StringBuidler sb = new StringBuilder();
sb.append("a");
sb.append("b");
sb.append("c");
System.out.println(sb);

所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存。

5、StringBuilder源码分析
默认创建一个长度为16的字节数组
添加的内容长度小于16，直接存
添加的内容大于16会扩容（原来的容量*2+2）
如果扩容之后还不够，以实际长度为准

容量：最多装多少
长度：已经装了多少

StringBuilder sb = new StringBuilder();
System.out.println(sb.capacity());//获取容量
System.out.println(sb.length());//获取长度

常见面试题

String s1="abc";//记录的是串池中的地址值
String s2="ab";
String s3=s2+"c";//新new出来的对象
System.out.println(s1==s3);//false

JDK8以前：系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成拼接
拼接后，再调用其toStirng方法转换成Sting类型，而toString方法的底层是直接new了一个字符串对象。
JDK8版本：系统会预估要字符串拼接之后的总大小，把要拼接的内容都放在数组中，此时也是产生一个新的字符串。

String s1="abc";//记录串池中的地址值
String s2="a"+"b"+"c";//复用串池中的字符串
System.out.println(s1==s2);//true

集合

数组的长度固定，而集合的长度可变，自动扩容
数组能存储我基本数据类型和引用数组类型，而集合可以存引用数据类型，但是如果放入基本数据类型需要将其转换为包装类

//创建集合的对象
//泛型：限定集合中存储数据的类型
ArrayList<String> list = new ArrayList<String>();
//or
//此时我们创建的是ArrayList的对象，而ArrayList是java已经写好的一个类
//这个类在底层做了一些处理
//打印对象不是地址值，而是集合中存储的数据内容
//在展示的时候会拿【】把所有的数据进行包裹
ArrayList<String> list = new ArrayList<>();

增：boolean add（E e）----添加元素，返回值表示是否添加成功
删：boolean remove（E e）----删除指定元素，返回值表示是否删除成功
E remove （int index）----删除指定索引的元素，返回被删除的元素
改：E set（int index，E e）----修改指定索引下的元素，返回原来的元素
查：E get（int index）----获取指定索引的元素
int size（）----集合的长度，也就是集合中元素的个数

ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("aaa");
list.add("bbb");
list.add("ccc");
//删除元素
//删除值
boolean result1 = list.remove(o:"aaa");
System.out.println(result1);//true

boolean result2 = list.remove(o:"ddd");
System.out.println(result2);//false
//索引值删除
String str=list.remove(index:0);
System.out.println(str);//aaa

//修改元素
String result =list.set(1,"ddd");
System.out.println(result);//aaa

//查询元素
String s = list.get(0);
System.out.println(s);//aaa

//遍历
for(int i=0;i<list.size();i++){
	String str = list.get(i);
	System.out.println(str);
}

包装类
byte----Byte
short----Short
char----Character
int----Integer
long----Long
float----Float
double----Double
boolean----Boolean

练习

定义一个集合，添加字符串，并进行遍历
遍历格式参照：【元素1，元素2，元素3】。

ArrayList<String> list = new ArrayList<>();
list.add("点赞了吗？");
list.add("收藏了吗？");
list.add("投币了吗？");
list.add("转发了吗？");

System.out.print("[");
for(int i=0;i<list.size();i++){
    if(i==list.size()-1){
        System.out.print(list.get(i));
    }else{
        System.out.print(list.get(i)+",");
    }
}
System.out.print("]");

定义一个集合，添加数字，并进行遍历
遍历格式参照：【元素1，元素2，元素3】。

ArrayList<Integer> list =new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.print("[");
for(int i=0;i<list.size();i++){
    if(i==list.size()-1){
        System.out.print(list.get(i));
    }else{
        System.out.print(list.get(i)+",");
    }
}
System.out.print("]");

需求：定义一个集合，添加一些学生对象，并进行遍历
学生类的属性为：姓名，年龄。

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 void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

import java.util.ArrayList;
public class Test {
    public static void main (String[] args){
        ArrayList<Student> list = new ArrayList<>();
        Student s1=new Student("zhangsan",23);
        Student s2=new Student("lisi",24);
        Student s3=new Student("wangwu",25);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        for (int i = 0; i < list.size(); i++) {
            Student stu=list.get(i);
            System.out.println(stu.getName()+","+stu.getAge());
        }
    }
}

需求：定义一个集合，添加一些学生对象，并进行遍历
学生类的属性为：姓名，年龄。
要求：对象的数据来自键盘录入

import java.util.ArrayList;
import java.util.Scanner;

public class Test {
    public static void main (String[] args){
        ArrayList<Student> list = new ArrayList<>();
        Scanner sc =new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            Student s=new Student();
            System.out.println("请输入学生的姓名");
            String name=sc.next();
            System.out.println("请输入学生的年龄");
            int age=sc.nextInt();
            s.setName(name);
            s.setAge(age);
            list.add(s);
        }
        for (int i = 0; i < list.size(); i++) {
            Student stu=list.get(i);
            System.out.println(stu.getName()+","+stu.getAge());
        }
    }
}

类（现小结）

javabean类
用来描述一类事物的类。比如，Student，Teacher，Dog，Cat等
测试类：
用来检查其他类是否书写正确，带有main方法的类，是程序的入口
工具类：
帮助我们做一些事情的，但是不描述任何事物的类（类名见名知意，私有化构造方法，方法定义为静态）