java笔记
java语言发展史：java5 java8力度最大
计算机进制转换：计算机全部采用二进制表示 只包含0、1两个数逢二进一
计算机程序员：Hex=16进制； DEC=10进制； OCT = 8进制； BIN = 2进制；
位（bit）： 一个数字0或者一个数字1，代表一位。
字节（Byte），每逢8位是一个字节，这是数据存储的最小单位。
1 Byta = B bit 1KB=1024Byta 1MB=1024KB 1GB=1024MB 1TB=1024GB
我们想要运行一个已有的java程序，你们必须安装JRE即可。
我们想要开发一个全新的java程序，那么必须安装JDK.
常量的概念和分类
1.字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例：”abc“
2.整数常量：直接写上的数字，没有小数点。例：100、200、0。
3.浮点数常量：直接写上的数字，有小数点。例：53.1、25.4、-3.14、0.0
4.字符常量：凡是用单引号引起来的单个字符，就叫做字符常量。例：‘A','7'、'中'。
5.布尔常量：只有两种取值。true（真）、false（假）
6.空常量：null，代表没有任何数据。
基本数据类型
数据类型 关键字
字节型 byte
短整形 short
整形 int
长整型 long
单精度浮点数 float
双精度浮点数 double
布尔类型 boolean使用变量的注意事项:
1．如果创建多个变量，那么变量之间的名称不可以重复。
2．对于float和long类型来说，字母后缀F和L不要丢掉。
3．如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型
4．没有进行赋值的变量，不能直接使用;一定要赋值之后，才能使用。
5．变量使用不能超过作用域的范围。
【作用域】:从定义变量的一行开始，一直到直接所属的大括号结束为止。
ASCII值运用
0：48 A ：65 a ：97
public static void main(String[] args){
char zifu1 = '1';
System.out.println(zifu1+0); //49
char zifu2 = 'A'; //其实底层保持的数字是65数字
char zifr3 = 'c';
// 左侧是int类型，右边是char类型，
// char --> int ,确实是从小到大
// 发生了自动类型转换
int num = zifu3;
System.out.println(num); // 99
}四则运算当中的加号"+" 常见的三种用法:
1．对于数值来说，那就是加法。
2．对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符，和int类型数字，之间的对照关系表:ASqUI、Unicode
3．对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。任何数据类型和字符串进行连接的时候，结果都会变成字符串
自增自减运算符
基本含义:让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式:写在变量名称之前，或者写在变量名称之后。例如:++num，也可以num++
使用方式:
1．单独使用:不和其他任何操作混合，自己独立成为一个步骤。
2．混合使用:和其他操作混合，例如与赋值混合，或者与打印操作混合，等。使用区别:
1．在单独使用的时候，前++和后++没有任何区别。也就是:++num;和num++;是完全一样的。
2.在混合的时候,有【重大区别】
A．如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。【先加后用】
B．如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。【先用后加】
注意事项:
只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
复合赋值运算符
| += | a +=3 | 相当于 | a = a+3 |
|---|---|---|---|
| -= | b -=4 | 相当于 | b = b-4 |
| *= | c *=5 | 相当于 | c = c*5 |
| /= | d /=6 | 相当于 | d = d/6 |
| %= | e %=7 | 相当于 | e = e%7 |
注意事项：
1.只有变量才能使用赋值运算符，常量不能进行赋值
逻辑运算符
1.与（并且) && 全都是true，才是true;否则就是false
2.或（或者) || 至少一个是true，就是true;全都是false，才是false
3.非（取反) ! 本来是true，变成false;本来是false，变成true
与“&&”，或"||“，具有短路效果:如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。
三元运算符
一元运算符:只需要一个数据就可以进行操作的运算符。例如:取反!、自增++、自减--
二元运算符:需要两个数据才可以进行操作的运算符。例如:加法+、赋值=
三元运算符:需要三个数据才可以进行操作的运算符。
格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
流程：
首先判断条件是否成立:
如果成立为true，那么将表达式A的值赋值给左侧的变量;
如果不成立为false，那么将表达式B的值赋值给左侧的变量;二者选其一。
注意事项:
1．必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2.三元运算符的结果必须被使用。
public static void main(String[] args){
int a = 10;
int b = 20;
//数据类型 变量名称 =条件判断 ? 表达式A:表达式B;
int max = a > b ? a : b;//判断a > b是否成立，如果成立将a的值赋值给max;
//如果不成立将b的值赋值给max。二者选其一
System.out.println("最大值" + max); // 20
}
switch语句
swith（表达式）{
case 常量值1： 例 case 1：
语句体1； System.out.println("今天星期一")
break；
....
default：
System.out.println("数据不合理")
break；
}1.多个case后面的数值不可重复
2.switch后面小括号当中只能是下例数据类型：
基本引用类型: byte/short/char/int
引用数据类型：String字符串、enum枚举
for循环
1.初始化语句： 在循环开始最初执行，而且只做唯一一次。 int i = 1；
2.条件判断： 如果成立，循环继续，如果不成立，循环退出。 i <= 10;
3.循环体： 重复要做的事情内容，若干行语句。 System.out.println(".............")；
4.布进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。 i ++
public static void main (String[] args){
//for (初始化语句;条件判断;布进表达式);
for (int i = 1; i <= 10; i++);
System.out.println("我错了" + i);
}while循环
拓展格式：
初始化语句；
while（条件判断）{
循环体；
布进语句；
}
public static void main(String[] args) {
int i = 1;//1.初始化语句
while(i <= 10){//2.条件判断
System.out.println("我错了！" + i);// 3. 循环体
i++;// 4.布进语句
}
}do-while循环
拓展格式：
初始化语句
do{
循环体；
布进语句；
}
public static void main(String[] args) {
int i = 1; // 1.初始化语句
do {
System.out.println("我错了" + i);//3.循环体
i++;//4.布进语句
}while (i <=10); //2.条件判断
}三种循环的区别
1.如果条件判断没有满足过，那么for循环和while循环会执行0次，但是do-while循环会执行至少一次。
2.for循环的变量在小括号当中定义，只有循环内部才可以使用，while和do-while循环初始化语句本来就在外面
所以出来循环之后可以继续使用。
public static void main(String[] args){
for(int i= 1; i < 0; i ++){
System.out.println("Hello");
}
//System.out.println(i);//这一行是错误写法! 因为变量i定义在for循环小括号内，只有for循环自己才能用
System.out.println("=================");
int i = 1;
do{
System.out.println("Hello");
i++;
}while (i < 0);
//现在已经超出了do-while循环的范围，我们仍然可以使用变量i
System.out.println(i)//2
}break语句
1.可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
2.还可以在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环。
continue语句
循环控制语句是continue关键字。
一旦执行，立刻跳过当前次循环内容，马上开始进行下一次循环。
public static void main(String[] args){
for(int i = 1;i <=10; i++){
if(i == 4){//如果当前是第四层
continue;//那么跳过当前次循环，马上开始下一次循环
}
}
}IDEA常用快捷键
| 快捷键 | 功能 |
|---|---|
| Alt+Eentrt | 导入包，自动修正代码 |
| Ctrl+Y | 删除光标所在行 |
| Ctrl+D | 复制光标所在行的内容，插入光标位置下行 |
| Ctrl+Alt+L | 格式化代码 |
| Ctrl+/ | 单行注释，再按取消注释 |
| Ctrl+Shift+/ | 选中代码注释，多行注释，再按取消注释 |
| Alt+lns | 自动生成代码，toString,get,set等方法 |
| Alt+Shift+/ | 移动当前代码行 |
| Shift+F6 | 参数同步更换 |
方法的三种调用格式
1.单独调用 ，方法名称(参数)；
2.打印调用，System.out.println(方法名称 (参数) )
3.赋值调用，数据类型 变量名称 = 方法名称(参数)
方法的重载
多个方法的名称一样，但是参数列表不一样
好处：只需要记住唯一一个方法名称
public static void main(String[] args){
System.out.println(sum(a:5,b:20));
System.out.println(sum(a:10,b:20，c:30));
}
public static int sum(int a,int b) {
System.out.println("有2个参数的方法执行！");
return a + b;
}
public static int sum(int a,int b,int c) {
System.out.println("有3个参数的方法执行！");
return a + b + C;
} 方法的重载与下列因素相关
1.参数的个数不同
2.参数类型不同
3.参数的多类型顺序不同
方法的重载与下列因素无关
1.与参数的名称无关
2.与方法的返回值类型无关
数组
数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
俩种常见的初始化方式：
1.动态初始化(指定长度)
2.静态初始化(指定内容)
动态初始化数组的格式：
数据类型[] 数据名称 = new 数据类型[数组长度]；
解析含义：
左侧数据类型:也就是数组当中保存的数据，全都是统一的什么类型左侧的中括号:代表我是一个数组
左侧数组名称:给数组取一个名字右侧的new:代表创建数组的动作
右侧数据类型:必须和左边的数据类型保持—致
右侧中括号的长度:也就是数组当中，到底可以保存多少个数据，是一个int数字
静态初始化数组的格式：
数据类型[] 数据名称 = new 数据类型[] {元素1，元素2，.......}
省略格式：
数据类型[] 数据名称 = {元素1，元素2，.......}
注意事项：
1．静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
2．静态初始化标准格式可以拆分成为两个步骤。 3．动态初始化也可以拆分成为两个步骤。 4．静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。 使用建议: 如果不确定数组当中的具体内容，用动态初始化;否则，已经确定了具体的内容，用静态初始化。
public static void main(String[] args) {
// 省略格式的静态初始化
int[] arrayA = {10,20,30};
//静态初始化的标准格式，可以拆分成为两个步骤
int[] arrayB;
arrayB = new int[] {11,21,31}
//动态初始化也可以拆分成为两个步骤
int[] arrayC;
arrayc = new int[5]
//静态初始化的省略格式不能拆分成为两个步骤
}访问数组元素的格式：
数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号。
【注意】索引值从0开始，一直到”数组的长度-1“为止。
public static void main(String[] args){
//静态初始化的省略格式
int[] array = {10,20,30};
System.out.ptintln(array);// [I@7f31245a 地址值
System.out.println(array[0]);//10
System.out.println(array[1]);//20
System.our.println(array[3]);//30
int num = array[1];
System.out.println(num);//20
}默认值
使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下:
如果是整数类型，那么默认为0;
如果是浮点类型，那么默认为0.0;
如果是字符类型，那么默认为‘\u0000' ;
如果是布尔类型，那么默认为false;
如果是引用类型，那么默认为nuLl。
注意事项:
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
Java的内存需要划分成为5个部分
1.栈 (Stack):存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。
局部变量:方法的参数，或者是方法0内部的变量
作用域：一旦超出作用域，立刻从栈内存当中消失
2.堆 (Heap):凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值:16进制
堆内存里面的数据，都有默认值。
3.方法区(Method Area):存储.class相关信息，包含方法的信息。
4.本地方法柱(Native Method Stack):与操作系统相关。
5.寄存器(pe Register): 与CPU相关。
数组索引越界异常:
ArrayIndexOutOfBoundsException
原因：索引编号写错了
空指针异常：
NullPointerException
原因：忘了 new
如何获取数组的长度
格式： 数组名称.length
public static void main(String[] args)
int[] arrayA = new int[3] //动态初始化数组
int[] arrayB = {10,56,5,6,64,9,2,9,6,6,5,5,44,995}; //静态初始化数组
int len = arrayB.length;
System.out.println("arrayB的数组长度是："+len);
数组的遍历输出
public static void main(String[] args){
int[] arrayA = {5,64,2,6,454,646,64,66,94,23};
for (int i = 0;i < arrayA.length;i++){
System.out.println(arrayA[i]);
}
}求数组中最大值
public static void main(String[] args){
int[] array = {10,65,364,3196,6313,9415};
int max = array;
for(int i = 0; i < array.length;i++){
//如果当前元素，比max更大，就替换
if(array[i] > max){
max = array[i]
}
}
System.out.println("最大值："+max);
}数组元素反转
public static void main(String[] args){
int[] array ={10,20,5,60,40,66};
for(int min = 0,max = array.length -1; min < max; min++,max--){
array temp = array[min];
array[min] = array[max];
array[max] = temp;
}
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
}数组作为方法的参数__传递地址
数组可以作为方法的参数：
当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。
三要素：
返回值类型：只是进行打印而已，不需要进行计算，也没有结果。 用void
方法名称：printlarray
参数列表：必须给我数组，我才能打印其中的元素。 int[] array
public static void main(String[] args){
int [] array= {10,30,10,356,100};
System.out.println(array);//地址值
System.out.println("==========================");
printarray(array);//传递进去的就是array当中保持的地址值
}public static void printarray(int[] array){
System.out.println("printarray方法收到的参数是:");
System.out.println(array);//地址值
for (int i = 0; i < array.length;i++){
System.out.println(array[i]);
}
}
}
数组作为方法返回值__返回地址
任何数据类型都能作为方法的参数类型，或者返回值类型。
数组作为方法的参数，传递进去的其实是数组的地址值。
数组作为方法的返回值，返回的其实也是数组的地址值。
public static void main(String[] args) {
int[] result = Dexter(5,40,30);
System.out.println("main方法接收到的返回值数组是：");
System.out.println(result);
System.out.println("总和："+result[0]);
System.out.println("平均数："+result[1]);
}public static int[] Dexter(int a, int b, int c){
int sum = a + b + c;
int agv = sum / 3 ;
int [] array = {sum,agv};
System.out.println("Dexter方法内部是：");
System.out.println(array);
return array;
}
}面向对象
面向过程：当需要实现一个功能的时候，每一个步骤都要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。
public static void main(String[] args) {
int[] array = {10, 20, 30, 40, 50, 60};
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.println(array[i] + "]");
} else {
System.out.print(array[i] + ", ");
}
System.out.println("============");
//使用面向对象
//找一个jdk给我们提供和的Arrays类
//其中有一个toString的方法，直接就能把数组变成想要的格式的字符串
System.out.println(Arrays.toString(array));
}
}
}类和对象的关系
1.类是对一类事物的描述，是抽象的。
2.对象是一类事物的实例，是具体的。
3.类是对象的模板，对象是类的实体。
类的定义
注意事项：
1.成员变量是直接定义在类当中，在方法外边.
2.成员方法不要写static 关键字.
public class Student {
//成员变量
String name;
int age;
//成员方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void study(){
System.out.println("学习");
}
}public class da {
public static void main(String[] args){
//格式：类名称 对象名 = new 类名称();
Student Dexter = new Student();
Dexter.name ="彭于晏";
Dexter.age =20;
System.out.println(Dexter.name);
System.out.println(Dexter.age);
Dexter.eat();
Dexter.sleep();
Dexter.study();
}
}对象类型作为方法的参数
public static void main(String[] args){
Student Dexter = new Student();
Dexter.name ="张艺兴";
Dexter.age =20;
me(Dexter);
}
private static void me(Student dexter) {
System.out.println(dexter.name);
System.out.println(dexter.age);
}
}对象类型作为方法的返回值
public static void main(String[] args){
Student two = Dexter();
System.out.println(two.name);
System.out.println(two.age);
}
public static Student Dexter(){
Student one = new Student();
one.name = "张子枫";
one.age = 20;
return one;
}
}局部变量和成员变量区别
1.定义的位置不一样【重点】
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
2.作用范围不一样【重点】
局部变量：只有方法当中才可以使用，出了方法就不能用
成员变量：在方法的外部，直接写在类当中
3.默认值不一样【重点】
局部变量：没有默认值。如果要想使用，必须手动进行赋值
成员变量: 如果没有赋值，会有默认值，规则和数组一样
4.内存的位置不一样{了解}
局部变量：位于栈内存
成员变量：位于堆内存
private关键字的作用及使用
public class Student {
//成员变量
String name;
private int age;
public void Dexter(){
System.out.println("我叫：" +name +".年龄"+age);
}
//这个成员方法，专门用于向age设置数据
public void setAge(int num){
if(num < 100 && num >= 0){
age = num;
}else{
System.out.println("数据不合理");
}
}
//这个成员方法，专门用于获取age的数据
public int getAge(){
return age;
}
} public static void main(String[] args) {
Student one = new Student();
one.name = "张子枫";
one.setAge(20);
one.Dexter();
}
}对于基本类型当中的boolean值，Getter方法一定要写成为isxxx的形式，而setxxx规则不变。
public class da {
private String name;
private int age;
private boolean male;
public void setName(String a){
name = a;
}
public String getName(){
return name;
}
public void setAge(int b){
age = b;
}
public int getAge(){
return age;
}
public void setMale(boolean c){
male = c;
}
public boolean isMale(){//boolean值，Getter方法一定要写成为isxxx的形式，而setxxx规则不变。
return male;
}this使用：
①当方法的局部变量和类的成员变量重名的时候，根据就近原则，优先使用局部变量，
若想访问本类中的成员变量，要写 this . 成员变量名
注：通过谁调用的方法，谁就是this
构造方法也是可以进行重载的。
重载：方法名称不同，参数列表不同
public class Dexter {
//成员变量
private String name;
private int age;
//无参构造方法
public Dexter(){
System.out.println("无参构造方法执行！");
}
//全参构造方法
public Dexter(String name,int age){//局部变量
this.name = name;
this.age = age;
System.out.println("全参构造方法执行！");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}public class Demo {
public static void main(String[] args){
Dexter a = new Dexter();//无参构造
System.out.println("================");
Dexter b = new Dexter("彭于晏",20);
System.out.println("姓名："+ b.getName() + "年龄："+ b.getAge());
}
}引用类型的一般使用步骤
1.导包
import 包路径.类名称;
如果需要使用的目标类，在当前类位于同一包下，则可以省略导包语句不写。
只有java.lang包下的内容不需要导包，其他的包需要import语句。
2.创建
类名称 对象名 = new 类名称();
3.使用
对象名.成员方法名()
Scann的使用步骤
package Demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);//System.in(从键盘输入)
int num = sc.nextInt();
System.out.println("你输入的int数字是：" + num);
String str = sc.next();
System.out.println("你输入的字符串是："+str);
}
}
匿名对象
package Demo;
public class Demo02 {
public static void main(String[] args){
person one = new person();
one.name = "彭于晏";
one.showName();
System.out.println("=================");
//匿名对象
new person().name = "张子枫";
new person().showName();
}
}
=======================================================
package Demo;
public class person {
String name;
public void showName(){
System.out.println("我叫："+name);
}
}package Demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args){
//普通使用方式
// Scanner sc = new Scanner(System.in);
// int num = sc.nextInt();
//匿名对象方式
// int num =new Scanner(System.in).nextInt();
// System.out.println("输入的是："+num);
//使用一般写法传入参数
// Scanner sc = new Scanner(System.in);
// methodParam(sc);
//使用匿名对象来进行传参
// methodParam(new Scanner(System.in));
//使用匿名对象来进行返回值
Scanner sc = methodReturn();
int num = sc.nextInt();
System.out.println("输入的是："+num);
}
public static void methodParam(Scanner sc){
int num = sc.nextInt();
System.out.println("输入的是："+num);
}
public static Scanner methodReturn(){
// Scanner sc = new Scanner(System.in);
// return sc;
return new Scanner(System.in);
}
}目录
package Demo;
import java.util.Random;
public class Demo03 {
public static void main(String[] args) {
Random random = new Random();
int num = random.nextInt();
System.out.println("随机数是：" + num);
}
}
====================================================
//Randon生成指定范围的随机数
package Demo;
import java.util.Random;
public class Demo03 {
public static void main(String[] args) {
Random random = new Random();
for(int i = 0; i < 10; i++){
int num =random.nextInt(10);// 0~9
System.out.println(num);
}
}
}package Demo;
import java.util.Random;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Random r = new Random();
int randomNum = r.nextInt(100)+1;
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的数字");
int guessNum = sc.nextInt();
if(guessNum > randomNum){
System.out.println("太大了，请重试");
}else if(guessNum < randomNum){
System.out.println("太小了，请重试");
}else{
System.out.println("恭喜你，答对啦！");
}
}
}
417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
