java第一周学习笔记

1
Java中最基本的组成单位是类
类的定义格式
public class 类名{
/这是main方法 是程序的入口方法 代码的执行是从main方法开始的/
public static void main（String[ ] args{
//这是输出语句，“里面的内容可以改变”
System.out.println(“hello world”);//println是单行输出
}
}
2
注释可用来调试代码：即注释后整个代码无错误，就是注释的那行代码除了错

即单行注释与多行注释都不参与编译

注释分为
1单行注释
2多行注释
3文档注释

3
关键字
1被java语言赋予了特别含义的单词
2全部小写
3有特殊的颜色标识
4 50个左右

4
常量
字符串
System.out.println(“hello world”)；
整数
System.out.println(666)；
System.out.println(-88)；
System.out.println(“---------”);

小数常量
System.out.println(13.14);
System.out.println(-5.21);
字符常量
System.out.println(‘A’);
System.out.println(‘我’);
System.out.println(‘0’);
布尔常量
System.out.println(ture);
System.out.println(false);
Ture and false 是关键字
空常量
关键字 且不能直接输出
System.out.println(null);

5
数据类型
复盘
(计算机的存储单元
位（bit）（b）计算机最小的信息单元
字节（byte）（B）计算机最小的存储单元 1B=8b
)

类似c语言

6
变量
在程序运行过程中，其值可以发生改变的量
是内存中的一小块区域
格式：数据类型 变量名=变量值
Int a=10;
取值与修改值
取值格式：a
修改格式：a=20；（类似c语言）

public class work1{
	 public static void main(String[ ] args){
int a=10;
double b=1.34;
//输出变量
System.out.println(a);
//修改变量 
a=20;
}
}

变量使用的注意事项

public class work2{
	public static void main(String[ ] args){
byte b=10;
System.out.println(b);
Short s=100;
System.out.println(s);
int i=10000;
System.out.println(i);
double d=3.14;
System.out.println(d);
char c=’a’;
 System.out.println(c);
bloolean t=ture;
System.out.println(t);
long l=1000000000L;
//默认会int，末尾要加L
System.out.println(l);
float f=3.14F;
//默认会 double，末尾要加F
System.out.println(f);
}
}

即名字不能重复
先定义后使用
Long 后面加L
Float 后面加F

7标识符
概述
给类 方法 变量齐名的符号
数字字母下划线美元夫
不能是关键字（大小写严格区分eg Class） 不能以数字开头

常见命名约定


小驼峰针对于方法和变量命名
大驼峰命名法针对于类命名

8
类型转换
自动类型转换
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量

public class work3{
	public atatic void main(String[ ] args){
double d=10;
System.out.println(d);
byte b=10;
short s=b;
int i=b;
//char c=b;
//这个不行类型不兼容
}
}

强制类型转换
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
格式：目标数据类型 变量名=（目标数据类型）值或者变量
范例：int k=(int)88.88;

public class work3{
	public atatic void main(String[ ] args){
double d=10;
System.out.println(d);
byte b=10;
short s=b;
int i=b;
//char c=b;
//这个不行类型不兼容
int k=(int)88.88;
System.out.println(k);
//输出结果是88，出现数据丢失
}
}

9运算符
把常量或者变量进行操作的符号
连接 并符合Java语法
eg int a=10;
int b=20;
int c=a+b;
±*/%
格式：定义变量
加减乘除取余
输出
整数相除只能得到整数，可以.0让浮点型参与并进行自然转换

字符+操作

public class work4{
	public static void main(String[ ] args){
int 1=10;
char c=’A’;
Systemout.println(i+c);
/*老阿斯克码了
‘A’65   ‘a’97   ‘0’48
*/
//Char ch=i+c; 
//char类型会自动提升为int类型
int j=i+c;
System.out.println(j);
double d=10+13.14;
}
}

字符串+操作


10
赋值运算符
类似c的操作直接截图
拓展
i += 20;
i=i+20;
把左边和右边的数据加法操作，结果赋值给左边
但1的形式包含了强制转换为默认的int模式
2会发生不兼容的类型
即
Short s=20;
S+=20;等同于s=(short)(s+20);
因为默认输出为int型

11自增自减运算符

public class work1 {
    public static void main(String [ ] args){
        int i=10;
        System.out.println("i:"+1);
        int j=i++;
        System.out.println("i:"+i);	//11
        System.out.println("j:"+j); //10
        int x=++i;
        System.out.println("x:"+x); //12
    }
}

12
关系运算符

注意：
1输出结果都是布尔类型的值
即ture 或者 flase
2
可以使用>= 和<=的符号

13逻辑运算符

	public ststic void main(String [ ] args){
System.out.println(i>j)&(i>k);  //false & false		f
System.out.println(i<j)&(i>k);  //ture& false		f
System.out.println(i>j)&(i<k);  //false&false  	f
System.out.println(i<j)&(i<k);  //true&true         t
//即一假即假 同真即真
}
}

短路逻辑运算符
结论一致；
但




14三元运算符




15数据输入

import java.util.Scanner;
public class work7{
	public static void main(String[ ] args){
	Scanner sc=new scanner(System.in);
int x=sc.nextInt();
System.out.println(“x:”+x);
}
}

eg案例：三个和尚升级版

package com.demo;
import java.util.Scanner;
        public class work8{
    public static void main(String[ ] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个和尚的身高：");
        int h1=sc.nextInt();
        System.out.println("请输入第er个和尚的身高：");
        int h2=sc.nextInt();
        System.out.println("请输入第san个和尚的身高：");
        int h3=sc.nextInt();
        int th=h1 > h2 ? h1 : h2;
        int maxh=th>h3?th:h3;
        System.out.println("这三个和尚中最高的是："+maxh+"cm");
    }

16

流程控制
顺序 选择 循环


选择

```java
package com.demo;

public class work9 {
    public static void main(String[] args){
        System.out.println("开始");
        //定义两个变量
        int a=10;
        int b=20;
        //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
        if(a==b){
            System.out.println("a等于b");
        }
        int c=10;
        if(a==c){
            System.out.println("a等于c");
        }
        System.out.println("结束");
    }
}

流程控制

案例
奇偶数

导包 创建对象 接收数据

package com.demo;
import java.util.Scanner;
public class work11 {
public static void main(String [] args){
Scanner ac=new Scanner(System.in);

    System.out.println("请输入一个整数：");
    int num=ac.nextInt();
    if(num%2==0){
        System.out.println(num+"是偶数");

    }else{
        System.out.println(num+"是奇数");
    }


}

}
if语句格式三

If(){
Else if{
}
Else{
}
}
案例考试奖励

package com.demo;
import java.util.Scanner;
public class wrok15 {
public static void main(String[]args){
Scanner ac=new Scanner(System.in);
int score=ac.nextInt();
if(score<=100&&score>95){
System.out.println(“上帝自行车一辆”);
}
else if(score<=95&&score>90){
System.out.println(“游乐园随意玩”);
}
else if(score>=80&&score<90){
System.out.println(“变形金刚”);
}
else {
System.out.println(“胖揍一顿”);

    if(score>100||score<0){
        System.out.println("你输入的成绩有误");//体现程序的健壮性
        // 数据测试：正确数据，边界数据，错误数据
    }

    }
}

}

Swich语句

package com.demo;
import java.util.Scanner;
public class work16 {
public static void main(String[] args) {
System.out.println(“开始”);
Scanner ac = new Scanner(System.in);
System.out.println(“请输入一个星期数（1-7）：”);
int week =ac.nextInt();
switch (week) {
case 1:
System.out.println(“星期一”);
break;
case 2:
System.out.println(“星期二”);
break;
case 3:
System.out.println(“星期三”);
break;
case 4:
System.out.println(“星期四”);
break;
case 5:
System.out.println(“星期五”);
break;
case 6:
System.out.println(“星期六”);
break;
case 7:
System.out.println(“星期七”);
break;
default:
System.out.println(“你输入的星期有误”);
break;
}
}
}
ps 主函数主函数主函数重要的事情说三遍
直接输入main回车编译器可帮助输入public static void main(String[] args)
所以记住主函数里的s是string而不是system
查bug真是世界上最痛苦的事

案例
春夏秋冬

package com.demo;
import java.util.Scanner;
public class work17 {
public static void main(String[] args) {
System.out.println(“输入月份：”);
Scanner sc=new Scanner(System.in);
int month=sc.nextInt();
switch (month){
case 1:
System.out.println(“冬季”);
break;//无break时case穿透
case 2:
System.out.println(“冬季”);
break;
case 3:
System.out.println(“春季”);
break;
case 4:
System.out.println(“春季”);
break;
case 5:
System.out.println(“春季”);
break;
case 6:
System.out.println(“夏季”);
break;
case 7:
System.out.println(“夏季”);
break;
case 8:
System.out.println(“夏季”);
break;
case 9:
System.out.println(“秋季”);
break;
case 10:
System.out.println(“秋季”);
break;
case 11:
System.out.println(“秋季”);
break;
case 12:
System.out.println(“冬季”);
break;
default:
System.out.println(“你输入的月份有误”);
//break; 这里break无所谓
}
}
}
case穿透

package com.demo;

import java.util.Scanner;

public class work18 {
public static void main(String[] args) {
System.out.println(“输入月份：”);
Scanner sc=new Scanner(System.in);
int month=sc.nextInt();
switch (month){
case 1:
case 2:
case 12:
System.out.println(“冬季”);
break;//无break时case穿透
case 3:
case 4:
case 5:
System.out.println(“春季”);
break;
case 6:
case 7:
case 8:
System.out.println(“夏季”);
break;
case 9:
case 10:
case 11:
System.out.println(“秋季”);
break;
default:
System.out.println(“你输入的月份有误”);
//break; 这里break无所谓
//利用case穿透简单化
}
}

}

For循环

复习与回顾
尚硅谷
P40
1编写编译运行
2在一个java源文件中可以写多个类class但只有最多有一个声明为public（封装性）而且要求声明为public的类名要与源文件名相同
3 再次练手
Public class work1{
Public static void main(String[ ]args){//可以直接main输入回车
System.out.println(“hello world!”);//单行输出=先输出后换行 也可以print不加ln不换行
System.out.print(“hello world !”);//不换行
System.out.println(“”);//只换行不输出
}
}
4程序的入口是main（）方法。格式是固定的
args可变 为别的参数名，方括号可以交换位置
5 每个执行语句都以“；”结束
6编译的过程中；会生成有一个字节码或多个字节码文件他们的文件名与java源文件中的类名相同（有几个类就有几个字节码文件）
\n换行符同样使用

关键字与保留字
关键字所有字母全为小写

保留字 尽量避开使用 goto const
标识符

命名规范

int myNumber=1001;
最好见名知意

变量名在同一个作用域内不能重名
byte

声明long型变量时必须以l或L结尾
一般使用int定义整型变量

float占用空间4字节和表数范围比long大但是精度较低
定义float时要以f F结尾
通常使用double定义浮点型变量
字符类型
一个字符2个字节
‘’定义一个char型变量

表示方式
1声明一个字符
2转移字符

布尔类型只有两个值ture or false
在条件判断和循环结构中使用
基本数据类型之间的运算规则
自动类型提升；
强制类型转换；
byte short int long float double

当byte char short做运算时编译不能通过
强制类型转换
自动类型的逆运算
强转符

public class work20 {
public static void main(String[] args) {

    double d1=12.3;
    int i1=(int)d1;//截断操作损失精度
    System.out.println(i1);
}

}
注意
long float不加标识的时候会默认int double去定义
1 String属于引用数据类型，翻译为字符串
2声明string类型变量时，使用一对“”
3 可以和八种基本数据类型计算且运算只能是连接运算
4运算仍是String类型
5在string中的+号都是连接符

public class work21 {
public static void main(String[] args) {
/* String s1=“hello world”;
System.out.println(s1);

    String s2="a";
    String s3="";
int num=1001;
String numStr="学号:";
String info=numStr + num;
boolean b1=true;
String info1= info + b1;
System.out.println(info1);*/

//*****************************
/char c=‘a’;
int num=10;
String str=“hello”;
System.out.println(c+num+str);//107hello
System.out.println(c+str+num);//ahello10
System.out.println(c+(num+str));//a10hello
System.out.println((c+num)+str);//107hello
System.out.println(str+num+c);//hello10a/
System.out.println("* ");
System.out.println(’’+’\t’+’’);//93
System.out.println(’’+"\t"+’’);//第二个是string表示连接
System.out.println(’’+’\t’+"");//51
System.out.println(’’+(’\t’+""));//* *

小练习
第一题
逻辑或
x++时先将x赋值再加1
x++结果是1！=2 左边为false
右边y先加1后代入2等于2为ture
整体为false
所以输出
x=2 y=2
第二题
x++==2 false短路运算符
直接输出x=2 y=1
第三题
x++==1 ture
|或运算符 后面y=2为false
整体为ture
x=7 y=2
第四题
x++=1 ture
后面短路
x=7 y=1整体ture

位运算符
1 位运算符操作的都是整形的数据
2 <<在一定范围内 每想左移1位 相当于*2
3 >>在一定范围内，没向右移一位，相当于/2

了解即可
21
21<<2

优先级

流程控制
顺序结构
（选择结构） 分支结构
循环结构
44
z++==40 //ture z=41
y=ture //ture赋值
执行if里 z=42
下一条里 前false 后面判断先加加后判断位=为ture
z++等于44;
x<0 ? :
String s1
String s2
String temp=s1;
s1=s2;
s2=temp;
位运算符
<< >> >>>
多加提示输出bulabulabula

package com.demo;
import java.util.Scanner;/导包/
public class work22 {
public static void main(String[] args) {

    Scanner scan=new Scanner(System.in);/*scanner的实例化*/
    System.out.println("请输入你的姓名");
    String name=scan.next();
    System.out.println(name);
    int num =scan.nextInt();/*调用scanner类的相关方法来获取指定类型的变量
     */
    System.out.println("请输入你的年龄");
    System.out.println(num);
    System.out.println("请输入你的体重");
    double weight=scan.nextDouble();
    System.out.println(weight);

    System.out.println("你是否相中我了呢？(true/false)");
    boolean isLove = scan.nextBoolean();
    System.out.println(isLove);
    //对于char型的获取，scanner没有提供相关的方法。只能获取一个字符串
    String gender = scan.next();//"男"
    char genderChar =gender.charAt(0);//获取索引为0位置上的字符
    System.out.println(genderChar);
}

}

package com.demo;
import java.util.Scanner;
public class work23 {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);

System.out.println("请输入月晓鹏的成绩");
int score =scan.nextInt();
if(score==100){
    System.out.println("奖励一辆bmw");
}
else if(score > 80&& score<=99)
{
    System.out.println("奖励一台iphone");
}
else if (score >60&&score<=79)
{
    System.out.println("啥也不是");
}
else {
    System.out.println("一顿臭揍");
}
}

}
//

package com.demo;
import java.util.Scanner;
public class work25 {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(“请输入第一个整数”);
int num1=scan.nextInt();
System.out.println(“请输入第二个整数”);
int num2=scan.nextInt();
System.out.println(“请输入第三个整数”);
int num3=scan.nextInt();

    if (num1>=num2)
    {
        if (num3 >= num1) {
            System.out.println(num2 + "," + num1 + "," + num3);
        } else if (num3 <= num2) {
            System.out.println(num3 + "," + num2 + "," + num1);
        } else {
            System.out.println(num1 + "," + num2 + "," + num3);
        }
    }
    else
    {
       if (num3>=num2)
       {
           System.out.println(num1+","+num2+","+num3);
        }
       else if(num3<=num1){
           System.out.println(num3+","+num1+","+num2);
       }
       else {
           System.out.println(num1+","+num3+","+num2);
       }
    }
}

}
良好的书写格式是尼玛的写代码的优点
嵌套超三层立马重新构思

第一个atguigu第二个b 能cpackage com.demo;import java.util.Scanner;public class work26 { public static void main(String[] args) { Scanner scan=new Scanner(System.in); double gl=scan.nextInt(); if (gl>=0&&gl<=2){ System.out.println(“相对于人的年龄:”+gl10.5); }else if(gl>2){ System.out.println(“相当于人的年龄:”+210.5+(gl-2)4); } else { System.out.println(“狗狗还没出生呢!”); } }}狗子年龄随机数package com.demo;//获取一个随机数:10~99public class work27 { public static void main(String[] args) { int value =(int)(Math.random()90+10); System.out.println(value); //[0.0,1.0)–>[0.0,90.0)—>[10.0,100.0)—>[10,99] //公式:[a,b] :(int)(Math.random()(b-a+1)+a)//[9,99]:(int)(Math.random()(99-9+1)+a) }}package com.demo;import java.util.Scanner;public class work28 { public static void main(String[] args) { Scanner scan=new Scanner(System.in); System.out.println(“请输入2019年的month:”); int month =scan.nextInt(); System.out.println(“请输入2019年的day”); int day =scan.nextInt(); int sumDays =0; /方式一if (month == 1) { sumDays =day; }else if () / /方式二switch (month){ case 1: sumDays=day; / switch(month){ case 12: sumDays +=31; case 11: sumDays+=30; case 10: sumDays+=31; case 9: sumDays+=31; case 8: sumDays+=31; case 7: sumDays+=30; case 6: sumDays+=31; case 5: sumDays+=30; case 4: sumDays+=31; case 3: sumDays+=28; case 2: sumDays+=31; case 1: sumDays+=day; } System.out.println(“2019年”+month+“月”+day+“日是当年的第”+sumDays+“天”); } }特殊的不加breakforp111做题3 三元可转if switch可转if 可三元可switch的不用if else4 导包 创建对象 赋值import java.util.Scaner;Scanner scan =new Scanner(System.in);int id=scan.nextInt();String info=scan.next();5跳出循环break跳出整个循环continue跳出本次循环return跳出整个方法（包括循环）数组是多个相同类型的数据按一定顺寻排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理2数组概念数组名 元素 下标 数组长度 3数组的特点：有序4数组元素可以是任何数据类型（包括基本数据类型和引用数据类型）5内存里连续的空间 数组名是首地址6长度一旦确定，就不能修改7用索引的方式调用指定为设置的元素8数组是属于引用数据类型。数组的元素可以是基本数据类型一维数组1声明和初始化2如何调用数组的指定位置元素3如何获取数组的长度4遍历数组5数组元素默认初始化值6数组的内存解析6 二维数组嵌套数组一个数组的元素又是 一个数组多维数组 行列二维数组的使用1理解嵌套数组2最后二维数组内存解析引用类型的变量要么null要么地址值数据结构1数据与数据的逻辑关系：集合 一对一 一对多 多对多2数据的存属结构：线性表：顺序表（比如数组）、链表、栈、队列 树形结构：二叉树图形结构：算法：排序搜索数组复习 二维数组数组笔记package com.demo;public class 二维数组理解 {public static void main(String[] args) {// 1二维数组的声明与初始化int arr[]=new int[]{1,2,3};//静态初始化int arr1[][]=new int[][]{{1,2,3},{4,5},{6,7,8}};//个数不要求一致//动态初始化String arr2[][]=new String[3][2];//行列//一个栈对应堆空间里有三个数组，而每个数组有两个元素String arr3[][]=new String[3][];//一个栈对应堆空间里三个数组里有个确定各元素//类型推断int arr4[]={1,2,3,4,5};// 2调用二维数组指定位置的元素System.out.println(arr1[0][1]);//2System.out.println(arr2[1][1]);//null//报错System.out.println(arr3[1][0]);arr3[1]=new String[4];//栈里a3对应堆里三个全空创出来后有了对应的//位置，能找到了System.out.println(arr3[1][0]);//*//3获取数组的长度System.out.println(arr1.length);//3//栈a4指堆只有三组里面无所谓，好像a4就是个一维数组一样System.out.println(arr1[0].length);//3System.out.println(arr1[1].length);//2// ///4如何遍历数组for (int i=0;i<arr1.length;i++){for (int j=0;j<arr1[i].length;j++){System.out.print(arr1[i][j]);}System.out.println();}//****************************}}就是存放数组首地址的数组叫做二维数组package com.demo;public class 二位数组理解2part {public static void main(String[] args) {// 数组元素的默认初始化值// 规定 外层数组arr[0] 行// 内层数组arr[0][1]列int arr[][] = new int[4][3];//动态初始化System.out.println(arr[0]);//地址值[I@5fd0d5ae //解释[表示一维数组后面是个十六进制的数System.out.println(arr[0][0]);//0 //解释为为数组元素默认值0System.out.println(arr);//地址值[[I@2d98a335 //解释[[表示2维数组后面是个十六进制的数float arr1[][] = new float[4][3];System.out.println(arr1[0][0]);//0.0 //解释为为数组元素默认值0String arr2[][] = new String[4][2];System.out.println(arr2[1][1]);//null //解释为为数组元素默认值0System.out.println(arr2[1]);//地址值[Ljava.lang.String;@5f184fc6 解释为一维数组double arr3[][] = new double[4][];System.out.println(arr3[1]);//null //默认值System.out.println(arr3[1][0]);//报错}}//针对与初始化方式一：比如int[] []arr=new int [][];// 外层地址值// 与一维数组初始化情况相同// 针对初始化方式二 int[][]arr=new int[4][];// 外层初始化值为null// 内层元素的初始化值为：蹦年调用，否则报错/****** /package com.demo;public class 数组的赋值反转查找线性二分 {public static void main(String[] args) {int [] arr1,arr2;arr1=new int[]{2,3,5,7,11,13,17,19};//显示arr1for(int i=0;i<arr1.length;i++){System.out.print(arr1[i]+"\t");}System.out.println();// 赋值arr2等于arr1// 不能成为数组的复制，类似于创建了一个快捷方式arr2=arr1;// 修改arr2的偶索引元素，使其等于索引值// （如arr[0]=0,arr[2]=2）for (int i=0;i<arr2.length;i++){if(i%2==0){arr2[i]=i;}}//打印arr1for (int i=0;i<arr1.length;i++){System.out.print(arr1[i]+"\t");}}}/arr1与arr2的地址值相同，都指向了堆空间的唯一一个实体 /定义三个量 选一个值pivot再定义两个指针low high比较选定值和指针的量 （low<p ；high>p），若出现不满足的情况停止查找，等待另一半也停止，然后两者对调交换，再次按序查找，遍历，最后出现两部分选定值在正中间，左边是比选定值小的，右边是比选定值大的数越多越快，指数型增长//快排堆排序和归并排序不讲了找算法书完事了排序基本一种也不用写，了解怎么实现即可package com.demo;public class array常见异常 {public static void main(String[] args) {// 1.数组角标越界的异常：ArrayIndexOutOfBoundsExcetionint[] arr = new int[]{1, 2, 3, 4, 5};// for (int i=0;i<=arr.length;i++){// System.out.println(arr[i]);// System.out.println(arr[-2]);//这俩都是越界for (int i = 0; i < arr.length; i++)System.out.print(arr[i] + “\t”);//正确遍历// 2. 空指针异常：NullPointerException//情况1int []arr1=new int[]{1,2,3};arr1=null;//空指针报错,相当于把之前的数指针抹掉了，没有指针了，空指针System.out.println(arr1[0]);//1//情况二int[][]arr2=new int[4][];System.out.println(arr2[0]);//默认初始化值是null//情况三String[]arr3=new String[]{“AA”,“BB”,“CC”};arr3[0]=null;System.out.println(arr3[0].toString());}}数组总结直接开二维package com.demo;public class 二维数组理解 {public static void main(String[] args) {// 1二维数组的声明与初始化int arr[]=new int[]{1,2,3};//静态初始化int arr1[][]=new int[][]{{1,2,3},{4,5},{6,7,8}};//个数不要求一致//动态初始化String arr2[][]=new String[3][2];//行列//一个栈对应堆空间里有三个数组，而每个数组有两个元素String arr3[][]=new String[3][];//一个栈对应堆空间里三个数组里有个确定各元素//类型推断int arr4[]={1,2,3,4,5};// 2调用二维数组指定位置的元素System.out.println(arr1[0][1]);//2System.out.println(arr2[1][1]);//null//报错System.out.println(arr3[1][0]);arr3[1]=new String[4];//栈里a3对应堆里三个全空创出来后有了对应的//位置，能找到了System.out.println(arr3[1][0]);//****//3获取数组的长度System.out.println(arr1.length);//3//栈a4指堆只有三组里面无所谓，好像a4就是个一维数组一样System.out.println(arr1[0].length);//3System.out.println(arr1[1].length);//2// ///4如何遍历数组for (int i=0;i<arr1.length;i++){for (int j=0;j<arr1[i].length;j++){System.out.print(arr1[i][j]);}System.out.println();}//************************************}}package com.demo;public class 二位数组理解2part {public static void main(String[] args) {// 数组元素的默认初始化值// 规定 外层数组arr[0] 行// 内层数组arr[0][1]列int arr[][] = new int[4][3];//动态初始化System.out.println(arr[0]);//地址值[I@5fd0d5ae //解释[表示一维数组后面是个十六进制的数System.out.println(arr[0][0]);//0 //解释为为数组元素默认值0System.out.println(arr);//地址值[[I@2d98a335 //解释[[表示2维数组后面是个十六进制的数float arr1[][] = new float[4][3];System.out.println(arr1[0][0]);//0.0 //解释为为数组元素默认值0String arr2[][] = new String[4][2];System.out.println(arr2[1][1]);//null //解释为为数组元素默认值0System.out.println(arr2[1]);//地址值[Ljava.lang.String;@5f184fc6 解释为一维数组double arr3[][] = new double[4][];System.out.println(arr3[1]);//null //默认值//System.out.println(arr3[1][0]);//报错}}//针对与初始化方式一：比如int[] []arr=new int [][];// 外层地址值// 与一维数组初始化情况相同// 针对初始化方式二 int[][]arr=new int[4][];// 外层初始化值为null// 内层元素的初始化值为：蹦年调用，否则报错/****** //

这个里定义布尔类型的方法真不错值得学习

package com.demo;

public class 数组的二分法查找 {
public static void main(String[] args) {
int[]arr2=new int []{-98,-34,2,34,54,66,79,105,210,333};
int dest1=-98;
int head=0;
int end=arr2.length-1;
boolean isFlag1=true;
while (head<=end){
int mid=(head+end)/2;
if (dest1==arr2[mid]){
System.out.println(“找到了指定的元素,位置为：”+mid);
isFlag1=false;
break;
}else if (arr2[mid]>dest1){
end=mid-1;
}else{head=mid+1;
}
}
if (isFlag1)
System.out.println(“很遗憾没有找到啦”);
}
}

package com.demo;

public class 数组的赋值与复制 {
public static void main(String[] args) {
int [] arr1,arr2;
arr1=new int[]{2,3,5,7,11,13,17,19};
//显示arr1
for(int i=0;i<arr1.length;i++){
System.out.print(arr1[i]+"\t");
}
System.out.println();
// ********************** *******************************************************
/* 赋值arr2等于arr1
// 不能成为数组的复制，类似于创建了一个快捷方式
arr2=arr1;/
//********************************************************************
//真复制 重新new的
arr2=new int[arr1.length];
for (int i=0;i<arr2.length;i++){
arr2[i]=arr1[i];
}

// **************** *************************************************
// 修改arr2的偶索引元素，使其等于索引值
// （如arr[0]=0,arr[2]=2）
for (int i=0;i<arr2.length;i++)
{
if(i%2==0){
arr2[i]=i;
}
}
//打印arr1
for (int i=0;i<arr1.length;i++){
System.out.print(arr1[i]+"\t");}
}
}
/*arr1与arr2的地址值相同，都指向了堆空间的唯一一个实体
*
*
*
*
*
*
*
*
*

• */

package com.demo;

public class 数组算法巩固数值型 {
public static void main(String[] args) {
int[]arr=new int[10];
for (int i=0;i<arr.length;i++){
arr[i]=(int)(Math.random()*((99-10+1)+10));
//Math.random()该值>=0.0且<=1.0返回一个大于0的double类型数据
}

for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();

//max min sum arg
//max
int max=arr[0];
for (int i=1;i<arr.length;i++){
if (max<arr[i]){
max=arr[i];
}
}
System.out.println(“max\t”+max);

//min
int min=arr[0];
for (int i=1;i<arr.length;i++){
if (min>arr[i]){
min=arr[i];
}
}
System.out.println(“min\t”+min);

//sum
int sum=0;
for (int i=0;i<arr.length;i++)
{
sum+=arr[i];
}
System.out.println(“sum\t”+sum);
//avg
int avg=sum/arr.length;
System.out.println(“avg”+avg);
}
}

package com.demo;

public class 数组翻转 {
public static void main(String[] args) {
//区别于数组变量的赋值
//arr1=arr
String[]arr=new String[]{“aa”,“bb”,“cc”,“dd”,“ee”};
String[]arr1=new String[arr.length];
for (int i=0;i<arr1.length;i++){
arr1[i]=arr[i];
System.out.print(arr[i]+"\t");
}
System.out.println();
/数组的反转方法一
for (int i=0;i<arr1.length/2;i++){
String temp=arr[i];
arr[i]=arr[arr.length-i-1];
arr[arr.length-i-1]=temp;
}
//遍历
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}/
//方法二
/for (int i=0,j=arr.length-1;;i++,j–){
String temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;/
for (int i=0,j=arr.length-1;i<j;i++,j–){
String temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;}
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}

scanner类的练习键盘输入二维数组
package com.demo;
import java.util.Scanner;
import java.util.Stack;
public class 纯粹代码练习 {
public static void main(String[] args) {
System.out.println(“二维数组的行列数：”);
Scanner scan = new Scanner(System.in);
int r = scan.nextInt();
int c = scan.nextInt();
int[][] matrix = new int[r][c];
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
matrix[i][j] = scan.nextInt();
System.out.print(matrix[i][j] + “,”);
}
System.out.println("");
}
}
}

面向对象
奔着安卓去就完事
面向对象开始了

内容较多
1java类及类的成员
属性，方法 构造器 代码块 内部类
2 面向对象的三大特征 封装性 继承性 多态性（抽象性）；

3 关键字 this super static final abstract interface package import
面向对象编程思想
1面向过程，强调的是功能的行为，以函数为最小单位，考虑怎么做

2面向对象，强调的是功能的队形，以类 对象为最小单位，考虑谁来做。

高于面向过程

3面向对象的两个要素
类 对一类事物的描述，是抽象的，概念上的定义
对象 是实际存在的该类十五的每个人体，也称为实例
类=抽象概念的人： 对象=实实在在的某个人
面向对象程序设计的重点是类的设计
其实就是类成员的设计

package com.demo;

import java.util.Scanner;

/*
1 设计类其实就是设计类的的成员

属性=成员变量=field=域、字段
行为=成员方法=函数=method

创建类的对象=类的实例化=实例化类

*/
//22222类和对象的使用
//1创建类 设计类的成员 scanner用的自带的 图纸
//2创建类的对象 产品
//3通过”对象。属性“或对象。方法 来调用对象的结构 使用

//三 如果创建了一个类的多个对象，每个对象都独立的拥有一套独立的类的属性（非static）
// 意味着 如果我偶们修改一个对象的属性a，则不影响另外一的属性a的值

//测试类
public class 类成员 {
public static void main(String[] args) {
//创建person类的对象
Person p1=new Person();
//Scanner sc=new Scanner(System.in);
//调用对象的结构
// 调用属性和方法
// 调用属性：“对象.属性”
p1.name=“tom”;
// p1.isMale=ture;
System.out.println(p1.name);

// 调用方法
// 调用方法 对象.方法
p1.eat();
p1.sleep();
p1.talk(“Chinese”);

// *********************************
Person p2=new Person();
System.out.println(p2.name);
//不是tom 不报错
// 是null 说明属性有默认初始化值
System.out.println(p2.isMale);
// *********************************
Person p3=p1;
System.out.println(p3.name);//tom

p3.age=10;
System.out.println(p1.age);//10
}
}

/类/class Person{

//属性 类的成员变量
String name;
int age=1;
boolean isMale;
//方法 类的成员方法（行为）(函数)
public void eat(){
System.out.println(" “);
}
public void sleep(){
System.out.println(” ");
}
public void talk(String language){
System.out.println(“人可以说话，使用的是”+language);
}
}

面向对象
注重对象的交互
1.1类与对象
*
属性-描述该事物的信息，一般是事物上面的名词
*
行为-描述该事物能做什么，一般是动词

类（最基本单位）=成员变量+方法

对学生 类的定义

对象是类的一个

对象的创建和使用

方法体就是大括号里的内容
成员变量：写在类体的里面，方法体的外面，声明时可以不进行初始化值，可以被本类或其他类的方法进行调用。
局部变量：写在方法体的里面，声明时可以不初始化，但是在使用前一定要初始化，只能在声明局部变量的方法内进行调用。

JVM图解

如果堆里面的对象没有被指向，Java里面有个垃圾回收器会将对象进行回收。开发时不需要手动设置为null，垃圾回收器会自动回收。

封装性
什么是封装？
封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
隐藏代码的实现细节，提高安全性

定义调用时不同，独立的，每个类都有自己的一套属性
定义调用