网站建设 昆山seo优化工具
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));}
}