java内存划分
Java的内存划分为5个部分：
1.栈 (Stack) : 存放的都是方法中的局部变量，方法的运行一定要在栈当中
局部变量: 方法的参数，或者是方法()内部的变量
作用域: 一旦超出作用域，立刻从栈内存当中消失
2.堆(Heap): 凡是new出来的东西，都是在堆当中
堆内存里面的东西都有一个地址值：16进制
堆内存里面的数据，都有默认值，规则：
整数 默认值0
浮点数 默认值0.0
字符 默认值'\u0000'
布尔 默认值false
引用类型 默认值null
3.方法区(Method Area)：存储class相关的信息，包含方法的信息
4.本地方法栈(Native Method Stack): 于操作系统相关
5.寄存器 (pc Register): 与CPU相关
局部变量和成员变量
局部变量和成员变量：
1.定义的位置不一样
a.局部变量：在方法的内部
b.成员变量：在方法的外部，直接写在类当中
2.作用范围不一样
a.局部变量：只有方法当中才可以使用，出了方法就不能再用
b.成员变量：整个类全都可以通用
3.默认值不一样
a.局部变量：没有默认值，如果想想用，必须手动进行赋值
b.成员变量：如果没有赋值，会有默认值，规则和数组一样
4.内存的位置不一样
a.局部变量：位于栈内存
b.成员变量：为于堆内存
5.生命周期不一样
a.局部变量：随着方法进栈而诞生，随着方法出栈而消失
b.成员变量：随着对象 创建而诞生，随着对象被垃圾回收机制回收而消失
构造方法
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
public 类名(参数类型 参数){
}
主要事项：
1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一致
2.构造方法没有返回值，void也不写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法，那么编辑器会默认增加一个构造方法
5.构成方法也是可以重载的
标准类
一个标准的类通常要拥有下面四个组成部分：
1.所有的成员变量都要用private关键字修饰
2.为每一个成员变量编写一对Getter和Setter
3.编写一个无参的构造方法
4.编写一个有参的构造方法
private
private 定义的成员属性，只能在本类中访问，超出本类就不能访问了
间接访问private成员变量，就是定义一对Getter/Setter
必须叫setxxx或者getxxx命名规则
对于Getter来说，不能有参数，必须有返回值，返回值类型必须和成员变量类型一致
对于Setter来说，不能有返回值，必须有参数，参数类型必须和成员变量类型一致
数组概念
数组概念：是一个容器，可以同时存放多个数据值
数组的特点：
1.数组是一种引用数据类型
2.数组当中的多个数据类型必须一致
3.数组的长度在程序运行期间不可改变
两种常见的初始化方式：
1.动态初始化（指定长度）
2.静态初始化（指定内容）
动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度]
静态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，...}
注意事项：
1.静态初始化没有直接指定长度，但是任然可以自动推算的到长度
2.静态初始化标准格式可以拆分成为两个步骤
3.动态初始化也可以拆分为两个步骤
4.静态初始化一旦时候省略号，就不能拆分为两个步骤
使用建议：
如果不确定数组当中的具体内容，用动态初始化，否则，已经确定了具体的内荣，用静态初始化
ArrayList集合
数组的长度是不可以改变的
但是ArrayList集合的长度是可以随意改变的
对于ArrayList来说，有一个尖括号<E>代表泛型
泛型：也就是装在集合当中的所有元素，全都是统一什么类型
注意：泛型只能是应用数据类型，不能是基本数据类型
注意事项：
对于ArrayList集合来说，直接打印得到的不是地址，而是内容
如果内容是空，得到的是空的括号[]
ArrayList当中的常用方法有：
public boolean add(E e); 向集合当中添加元素，参数的类型和泛型一致;返回值代表添加是否成功
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可以不用
但对于其他集合来说，add添加动作不一定成功
public E get(int index); 从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素
public E remove(int index); 从集合当中删除元素，参数索引编号，返回值就是被删除出掉的元素
public int size();获取集合的尺寸长度，返回值是集合中包含的元素个数
如果希望向集合ArrayList集合当中存储基本数据类型，必须使用基本类型对的"包装类"
基本类型 包装类 （应用类型 包装类都位于Java.lang包下）
byte Byte
int Integer
short Short
long Long
float Float
double Double
char Character
boolean Boolean
从JDK1.5开始，支持自动装箱、自动拆箱
自动装箱：基本类型 --> 包装类型
自动拆箱：包装类型 --> 基本类型
public class DemoArrayList {
public static void main(String[] args) {
//创建了一个ArrayList集合，集合的名称是arrList,里面装的全都是String类型的字符串数据
//备注：从JDK1.7开始，右侧的尖括号内部可以不写内容，但是<>本事还是要写的
ArrayList<String> arrList = new ArrayList<>();
System.out.println(arrList);
//向集合中添加数据
arrList.add("123");
arrList.add("马三");
boolean success = arrList.add("王五");
System.out.println(arrList);
System.out.println(success);
//从集合中获取元素，get
String str = arrList.get(1);
System.out.println(str);
//从集合中删除元素 remove
String whoRome = arrList.remove(2);
System.out.println("被删除的人："+whoRome);
System.out.println(arrList);
//size(),获取集合的长度
int len = arrList.size();
System.out.println(len);
//遍历集合
for (int i = 0; i < arrList.size(); i++) {
System.out.println(arrList.get(i));
//定义一个可用存储int类型的数组
ArrayList<Integer> listC = new ArrayList<>();
listC.add(1);
listC.add(2);
listC.add(3);
System.out.println(listC);
int num = listC.get(1);
System.out.println(num);
}
}
}
static关键字
如果一个成员变量使用了static关键字，那么这个变量不在属于对象自己，而是属于所在的类，多个对象共享一份数据
如果一个成员方法使用了static关键字，那么这个方法不在属于对象自己，而是属于所在的类，多个对象共享一个发方法
如果有了static关键字，那么不需要创建对象，直接就用类名来使用它
无论是成员变量，还是成员方法，如果有了static关键字，都推荐使用类名称进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
注意事项：
1.静态不能直接访问非静态
原因：因为在内存当中是先有静态内容，后有非静态内容
2.静态方法当中不能用this关键字
原因:this代表当前对象
3.根据类名称访问静态变量的时候，全程和对象没有关系，只和类有关系
静态代码块的格式：
public class 类名称{
static {
代码块类容
}
}
特点：当第一次用到本类时，静态代码块执行唯一的一次
静态内容总是优先于非静态内容，所以静态代码块比构造方法先执行
静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值
继承
局部变量：直接写变量名
本类的成员变量：this.成员变量名
父类的成员变量：super.成员变量名
重写：(Override) 方法的名称一样，参数列表也一样
注意事项：
1.必须保证父子类之间方法的名称相同，参数列表也相同
@Override(注解):写在方法前面，用来检测是不是有效的正确覆盖重写
2.子类方法的返回值必须小于等于父类方法的返回值范围
3.子类方法的权限必须大于等于父类方法的权限修饰符
public > protected > (default) > private
使用场景:
共性抽取
继承关系中，父子类构造方法的访问特点:
1.子类构造方法当中有一个默认隐含的"super()"调用，所以一定是先调用的父类构造方法，后执行的子类构造方法
2.子类构造可以通过super关键字来调用父类重载构造方法
3.super的父类构造调用，必须是子类构造方法的第一句，不能一个子类构造多次调用super构造
总结：
子类必须调用父类构造方法，不写则赠送一个super()；写了则用写的指定的super()调用，super只能有一个，还必须是第一个
super关键字的三种用法：是用来访问父类内容的
1.在子类的成员方法中，访问父类的成员变量
2.在子类的成员方法中，访问父类的成员方法
3.在子类的构造方法中，访问父类的构造方法
this关键字是的用法：是用来访问本类的内容
1.在本类的成员方法中，访问本类的成员变量
2.在本类的成员方法中，访问本类的另一个成员方法
3.在本类的构造方法中，访问本类的另一个构造方法；例如：无参构造调用有参构造
注意：
1.this(...)调用也必须是构造方法的第一个语句，唯一一个
2.super和this两种构造调用，不能同时使用
重载：(Over) 方法名称一样，参数个数或者参数类型不一样
String字符串以及比较
java.lang.String类代表字符串
程序中所有的双引号字符串，都是String类的对象（就算没有new 也是一样的）
字符串的特点：
1.字符串的内容永远不可变
2.正是因为字符串不可改变，所以字符串是可以共享使用的
3.字符串效果相当于char[]字符数组，但是自层原理byte[]字节数组
创建字符串的常见方式
1.public String();创建一个空白字符串，不含任何内容
2.public String(char[] array);根据字符数组的内容，创建对应的字符串
3.public String(byte[] array);根据字节数组的内容，创建对应的字符串
字符串常量池：程序中直接写上的双引号字符串，就在字符串常量池中
对于基本类型来说：==是进行数值的比较
对于应用类型来说：==是进行地址值的比较
==是进行对象的地址值的比较，如果确实需要进行字符串的内容比较，可以使用以下两种方法：
public boolean equals(Object obj) 参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false
注意事项：
1.任何对象都可以用Object进行比较
2.equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样
3.如果比较双方一个是常量一个是变量，推荐把常量字符串写在前面
推荐："abc".equals(str) 不推荐：str.equals("abc")
public boolean equalsIgnoreCase(String str) 忽略大小写，进行内容比较
public class DemoString02 {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "hello";
char[] charArray = {'h','e','l','l','o'};
String str3 = new String(charArray);
System.out.println(str1.equals(str2));
System.out.println(str2.equals(str3));
//当str3为null时，str3.equals("hello")会报错，NullPointerException
System.out.println("Hello".equals(str3));
System.out.println("Hello".equalsIgnoreCase(str3));
// System.out.println(str3.equals("hello"));
}
}
字符串的获取常用方法
String 当中与获取相关的常用方法有：
public int length(): 获取字符串当中含有的字符个数，拿到字符串长度
public String concat(String str): 将当前字符串和参数字符串拼接成为返回新的字符串
public char charAt(int index): 获取指定索引位置的单个字符。索引从0开始
public int indexOf(String str): 查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-1
public class DemoString03 {
public static void main(String[] args) {
//获取字符串长度
int length = "fdlsafjdsafdsjafld".length();
System.out.println("字符串长度："+length);
System.out.println("======================");
//拼接字符串
String str1 = "Hello";
String str2 = "World";
String str3 = str1.concat(str2);
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println("======================");
//获取指定索引位置的单个字符
char ch = "Hello".charAt(1);
System.out.println("索引位置为1的字符为:"+ch);
System.out.println("======================");
//查找字符串在本字符串中首次出现的位置
String str4 = "helloWorld";
int index = str4.indexOf("ll");
System.out.println("第一次出现索引的位置："+index);
//字符串不存在时，返回-1
System.out.println("helloWorld".indexOf("add"));
}
}
字符串的截取常用方法
public String substring(int index): 截取从参数位置一直到字符串结尾，返回新字符串
public String substring(int begin, int end): 截取从begin开始，一直到end结束，中间的字符串
备注：[begin,end)
public class DemoString04 {
public static void main(String[] args) {
String str = "HelloWorld";
String str1 = str.substring(5);
System.out.println(str);
System.out.println(str1);
String str3 = str.substring(4,7);
System.out.println(str3);
/*
下面这种写法，字符串的内容任然是不变的
下面两个字符串："Hello"和"Java"
str4当中保存的是地址值
本来的地址值是Hello的0x666
后来地址值变成了Java的0x999
*/
String str4 = "Hello";
str4 = "Java";
System.out.println(str4);
}
}
字符串转换常用方法
public char[] toCharArray();将当前字符串拆分成为字符数组作为返回值
public byte() getBytes();获取当前字符串底层的字节数组
public String replace(CharSequence oldSting, CharSequence newString)
将所有出现的老字符串替换为新的字符串，返回替换之后的结果新字符串
public class DemoStringConvert {
public static void main(String[] args) {
char[] chars = "Hello".toCharArray();
System.out.println(chars[0]);
System.out.println(chars);
System.out.println(chars.length);
//转换成为字节数组
byte[] bytes = "abc".getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);
}
//字符串替换
String str1 = "How do you do?";
String str2 = str1.replace("o", "@");
System.out.println(str1);
System.out.println(str2);
}
