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方法的类，是程序的入口
工具类：
帮助我们做一些事情的，但是不描述任何事物的类（类名见名知意，私有化构造方法，方法定义为静态）
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
