JAVA编程基础

程序的意义
数据
存储数据	内存	变量	大小
处理数据	CPU	命令	快慢

数据种类

数字：整数、小数
布尔值：true、false
字符串：几乎所有的内容都是字符串

存数据的变量类型

整数：int
小数：double
布尔值：boolean
字符串：String

如何把一个数据存起来

申明变量类型：分配内存
取变量名：记录内存位置
用=：往变量指向的内存放数据，专业名词：赋值符
数据：要存储的事情
“;”：命令行结束

如何把一个数据存起来

int age=18
double money=8888.88
String company=”上海果芽软件科技有限公司”;
String type=”RMB”;
密码：String password=”123456”;
String pwd=”123456”;
订单金额：double amount=99.99;
点灯是否开着：boolean isLight=true;

如何存一批数据

1个变量(基本数据类型)：存1个数据
多个变量（引用变量类型）：容器

容器种类

数组Array：个数固定、数据含义相同、单个值
链表ArrayList：动态增加、数据含义相同、单个值
HashSet：动态增加、数据含义相同、单个值、自动去重
HashMap：个数变化、数据含义不同、数据需要给含义，一对一对的数据，键值对/key=value
JavaBean：个数固定、数据含义不同、数据需要给含义，一对一对的数据，键值对

数据的操作

增、删、改、查、统计
变量的增删改查统计
界面功能的增删改查统计：支付、学生信息、面试信息
组织一次活动的增删改查统计：聚餐

单个变量的增删改查统计

增：int age=18;
删：方法执行结束，系统会自动回收内存
// int age = 18;
/* int age = 18; */
改：age=38;
查/取：age

数组的增删改查统计11

新建容器：int[] ages=new int[30];
增：下标 ages[0]=18; ages[8]=28; ages[29]=38; ages[30]=48;
删：ages[8]=null;
改：ages[29]=20;
查/取：ages[8]
统计：ages.length返回数组大小
int[] scores={100,10,60,79};
等价
int[] scores=new int[4];
scores[0]=100;
scores[1]=10;

ArrayList的新建/增/删/改/查/统计

新建容器：List<int> ages=new ArrayList<int>();
List：接口，定义实现类要写什么内容
ArrayList：实现类
<>：泛型
()：构造方法
增：ages.add(18); ages.add(28);
删：
改：
查/取：ages.get(2); ages.get(4);
统计：ages.size();返回大小

报错/异常日志

image.png

HashSet的新建/增/删/改/查/统计

新建容器：Set<Integer> ages=new HashSet<Integer>();
Set：接口，定义实现类要写什么内容
HashSet：实现类
<>：泛型
()：构造方法
增：ages.add(18); ages.add(28);
删：
改：
查/取：
统计：ages.size();返回大小

HashMap的新建/增/删/改/查/统计

新建容器：Map<String,String> phones=new HashMap<String,String>();
Map：接口，定义实现类要写什么内容
HashMap：实现类
<>：泛型
()：构造方法
增：phones.put("王慧硕", "1232321231");
删：
改：phones.put("王慧硕", "8765432123");
查/取：phones.get("王慧硕")
统计：phones.size();返回大小

main方法：编写

main

alt+/

enter ******* public static void main(String[] args) {

}

syso

alt+/ ******** System.out.println("测试");
enter

image.png

main方法：执行方式1

image.png

main方法：执行方式2

image.png
image.png

main方法：作业提交截图样例

image.png

变量和容器练习

使用变量和不同的容器，存储登录界面的数据。
用户名：userName
密码：password
校验码：checkCode

image.png

变量和容器练习：流程

1. 每个练习选一个人上台直播写，下边说，上边写

2. 所有练习学生轮流直播写一轮后，开始正式全员动手写

3. 演示截图样例

4. 使用上传总结界面，每道题全部通过后，进行下一道题，先做完的辅导分派到其它组进行指导

5. 全员动手写一遍后，复习动口一轮

6. 再选人直播写一遍

变量和容器练习：使用变量存储

    String userName= "lilei";
    String password="123466";
    String checkCode="1234";

变量和容器练习：使用数组存储

    String[] datas=new String[3];
    datas[0]="李磊";
    datas[1]="123466";
    datas[2]="1234";

变量和容器练习：使用ArrayList存储

    List<String> list = new ArrayList<String>();
    list.add("lilei");
    list.add("123456");
    list.add("1234");

变量和容器练习：使用HashMap存储

    Map<String, String> map = new HashMap<String,String>();
    map.put("userName", "lilei");
    map.put("password", "123466");

类和JavaBean新建类

1. 类名：首字母大写，驼峰命名法

   
   image.png
   image.png

工程结构：java三大特性之一：封装

1. project工程

2. package包

   包名
   “.”
   查看文件夹路径

3. class类
   .java后缀:源文件
   .class后缀:源文件编译后的文件

4. field字段

5. method方法

   
   image.png

方法的结构

1. 权限:public/private

2. 返回值类型:void不返回

3. 方法名method

4. ()参数列表

5. 入参类型 入参变量名

6. {}方法体

为什么返回只需要写类型,
但是入参需要些类型
和变量名?
public void test(){
System.out.println("test");
}

public void sayHello(String name){
System.out.println("hello");
}

public String answer(String question){
return "答案";
}

public String answer(String question,int a){
return "答案";
}

类的作用

打包封装：字段和方法

方法的作用

打包封装：命令

main方法的作用

代表一个程序：

1个程序只有一个main方法

所有代码可以全部写在一个main方法里面

不在main方法里面的内容不会执行

main方法的命令可以封装成方法打包调用

Main方法的内容

快捷写法:
main
alt+/
enter

2. 手工写
   public static void main(String[] args){

   }
   权限:public
   静态的static
   返回值类型:void
   方法名:main
   参数列表()
   入参是一个数组:String[] args
   方法体:{}

程序只会执行main方法里面的内容. 其他方法要想被执行,只能加到main方法里面

方法的作用:封装(重构)--高手必经之路(把屎一样的代码写得像诗一样)

image.png
image.png

一个程序最少的构成元素

1个工程

1个包

1个类

1个main方法
把1个main方法的命令拆分封装成很多个可复用的方法

把1个类拆分封装成很多个子类

把1个包里的很多个类拆分封装成很多个子包

把1个工程里的很多业务拆分成很多个子工程

把1个公司的业务拆分成很多个专项子公司

从无到有
从有到优

人无我有
人有我优
人优我转

封装的目的

代码简单
复用

image.png
image.png

用main方法实现加法运算

1. 变量可以复用

2. 加法和打印命令重复了好多次

   
   image.png

对重复代码进行重构（封装）

image.png
image.png
image.png

“+”运算符

数字+数字: 1+2=3
字符串+字符串: “abc”+”def”=“abcdef”
数字+字符串: 231+”def”=“231def”
字符串+变量: int a=231; ”def”+ c =“def231”

算术运算符：取余

有一批学生，从学号1开始报数，每4个唱首歌

用1个变量存放学号
int no=0;

no=1;

if( no % 4 == 0 ){
System.out.println(“唱歌”);
}

no=2;
if( no % 4 == 0 ){
System.out.println(“唱歌”);
}

算术运算符：自增

有一批学生，从学号1开始报数，每4个唱首歌

用1个变量存放学号
int no=0;

no++;

if( no % 4 == 0 ){
System.out.println(“唱歌”);
}

no++;
if( no % 4 == 0 ){
System.out.println(“唱歌”);
}

赋值运算符

=	int a=1	a=1
+=	a+2=2	a=a+2;a=3
-=	a-=3	a=a-3;a=0
*=	a*=3	a=a*3;a=0
/=
%=	a=7;a%=3	a=a%3;a=1

逻辑运算符

&&	int a=5; a>3 && a<10; true	a>6 && a<10; false
	int a=5; a>6		a<10; true
!	int a=5; int b=6; a!=6 true
boolean result = 2==3		1==1;

boolean result ;
2==3 false
1==1 true
false || true result=true

条件运算符

variable x = (expression) ? value if true : value if false
int a = (age <= 18) ? 少年: 大叔;
int a = (sex == 0 ) ? 美女 : 野兽;

分支结构

媳妇让你去买6个包子，如果看到西瓜，买一个。

最后只买了1个包子

分支结构：if 语句

if(布尔表达式)
{
//如果布尔表达式为true将执行的语句
}
public static void main(String args[]){
int x = 10;

  if( x < 20 ){
     System.out.print("这是 if 语句");
  }

}

分支结构：if...else语句

if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
public static void main(String args[]){
int x = 30;

  if( x < 20 ){
     System.out.print("这是 if 语句");
  }else{
     System.out.print("这是 else 语句");
  }

}

分支结构：if...else if...else 语句

if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
public static void main(String[] args){
int x = 30;

  if( x == 10 ){
     System.out.print("Value of X is 10");
  }else if( x == 20 ){
     System.out.print("Value of X is 20");
  }else if( x == 30 ){
     System.out.print("Value of X is 30");
  }else{
     System.out.print("这是 else 语句");
  }

}

分支结构：嵌套的 if…else 语句

if(布尔表达式 1){
////如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
////如果布尔表达式 2的值为true执行代码
}
}
public class Test {

public static void main(String[] args){
int x = 30;
int y = 10;

  if( x == 30 ){
     if( y == 10 ){
         System.out.print("X = 30 and Y = 10");
      }
   }
}

}

循环结构 for循环

int i=0;

if(i<30){
System.out.println(“唱歌”);
i++;
}

if(i<30){
System.out.println(“唱歌”);
i++;
}

if(i<30){
System.out.println(“唱歌”);
i++;
}

---

for(int i=0;i<30;i++){
System.out.println(“唱歌”);
}
for：for循环控制器

()：循环的条件

int i=0：初始值

i<30：最大值

i++：增量为1（i+=2：增量为2）

{}：要循环执行的命令

循环结构：while 循环

while( 布尔表达式 ) {
//循环内容
}

---

while可以替换for循环

但是for循环不能完全替换while循环

---

public static void main(String args[]) {
int x = 10;
while( x < 20 ) {
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}
}

循环结构：break关键字

break; 终断
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};

  for(int x : numbers ) {
     // x 等于 30 时跳出循环
     if( x == 30 ) {
        break;
     }
     System.out.print( x );
     System.out.print("\n");
  }

}

循环结构：continue关键字

continue; 当前的结束，继续下一个
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};

  for(int x : numbers ) {
     if( x == 30 ) {
    continue;
     }
     System.out.print( x );
     System.out.print("\n");
  }

}

循环结构：增强 for 循环

for(声明语句 : 表达式)
{
//代码句子
}
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};

  for(int x : numbers ){
     System.out.print( x );
     System.out.print(",");
  }
  System.out.print("\n");
  String [] names ={"James", "Larry", "Tom", "Lacy"};
  for( String name : names ) {
     System.out.print( name );
     System.out.print(",");
  }

}