使用java理解程序编程

 第一章：
System.out.println（）; // ln下一行换行\ n直接换行\ t

 

程序运行3步骤：
1
，编写源程序2，编译源程序
3，运行

 

 第二章：<<变量>>（内存中的一块存储空间）

 

8种基本数据类型：
整数
  整数类型字节1字节（8位）
    短2字节（16位）
    int 4字节（32位）
    长8字节（64位）
  小数类型flout 4字节（32位） ）  bouble
    8字节（64位）
布尔类型布尔图/假
  字符类型字符2字节（16位）

 

使用变量的3步骤：
1，声明变量：数据类型变量名;
2，赋值：变量名=值;
3，使用：变量名;

 

命名规范：
a。赋值运算符：=
b。算术运算符：+， - ，*，/;
前++， - （先赋值再运算）;后++， - （先运算再赋值）
c 。比较运算符：>，<，> =，<=，！=，==;
d。逻辑运算符：&&，||，!;
e。条件运算符（三元运算符）：条件？结果1 ：结果2;（当条件为真时，得到结果1，否则得出结果2）

 

f。位运算符:(计算机所有二进制都是用补码进行计算）
0111 1111是二进制最大的数; 1111是二进制最小的数。
  源码反码补码
正数（3）0000 0011 0000 0011（正数与源码相同）[二进制的第一位是符号位] 0000 0011（与反码相同）
负数（-3）1000 0011 1111 1100（除符号位不变，其余位数和源码相反）1111 1101（在反码基础上加1）
计算：3 +（ - 3）= 0
  0000 0011
+ 1111 1101
  0000 0000
<<：左移，将2进制左移，低位产生空位用0补齐（如何将2用最高效率变成8？答：将2左移2位。（2 << 2）== 0000 0010--0000 1000）
>>：带符号右移（16 << 2：0001 0000--0000 0010）
>> >：无符号右移

 

***运算符优先级：算术>比较>逻辑>赋值>位运算符

 

数据类型转换：自转（两种类型相互兼容，目标类型精确度大于源类型）
强转（目标类型精确度小于源类型。）例子：
double d = 0.1;
int a =（int）d;

 

分解获得各个数：
int no = 12;
int shiwei = no％10/10;

 

 第三章：<<选择结构2 >>

 

产生0 - n随机数的语法：
int random =（int）（Math.random（）* n）+1;

 

流程图：

 

if（条件1）{
   代码块1
} else {
   代码块2
}

 

嵌套，如果：
如果（条件1）{
    如果（条件1）{
     代码块1
 }否则{
      代码块2
 }
}否则{
    代码块2
}
多重如果：
如果（条件1）{
   代码块1
}否则如果（条件2）{
   代码块2
} else {
   代码块n
}

 

 第四章：<<选择结构2 >>

 

switch后常量值可以是：int short byte char String枚举等类型.case
后接：int short byte char String枚举等类型。

 

switch（常量值）{
 case值1：
 代码块1
 break;
案例值2：
 代码块1
 break;
案例值3：
 代码块1
 break;
默认：
    代码块
    突破;
}
开关与多重如果区别：
      如果
不同等值判断区间判断
相同都用于多重分支条件结构

 

第五章：<<循环结构>>

 

循环四要素：
初始值
循环条件：为布尔类型
循环行业释义体育
迭代变量

 

while循环条件（
while
    循环体
    迭代变量）while- 循环体迭代变量
}
do-while循环（先执行再判断）while
{
    循环体
    迭代变量
} while循环条件

 

程序调试：1分析错误，设置断点
   2.启动调试，单步执行
   3.观察变量，发现问题

 

 第六章：“为循环”

 

对于（初始值;循环条件;迭代变量）{
 循环体
}

 

break：结束整个循环
continue：跳出本次循环进入下一次
return：
3种循环语句比较：
   while循环：先判断再执行
do-while循环：先执行在判断
     循环：先判断再执行，循环次数确定

 

 第8章：<<数组>>

 

数组：一组相同数据类型的数据

 

使用数组4步骤：
1，声明数组：数据类型[]数组名;
2，分配空间：数组名= new数据类型[大小];
  数据类型[]数组名= new数据类型[大小];
3，赋值：数组名[下标] =值;
4，使用：数组名[下标]（数组下标从0开始）

 

数组排序：Arrays.sort（
数组名）; Arrays.binarySearch：
A。向数组插入元素：

 

包装;

 

import java.util.Scanner;

 

public class test {
 
 public static void main（String [] args）{
  Scanner input = new Scanner（System.in）;
  int no [] = new int [3];
  无[0] = 9;
  无[1] = 6;
  int index = no.length;
  的System.out.println（ “请输入要增加的元素：”）;
  int num = input.nextInt（）;
  //找到数组插入的位置
  for（int i = 0; i <no.length; i ++）{
   if（num> no [i]）{
    index = i;
    打破;
   }
  }
  //输出原数组
  的System.out.println（ “原数组元素为：”）;
  for（int j = 0; j <no.length; j ++）{
   System.out.println（no [j] +“\ t”）;
  }
  //元素后移
  for（int i = no.length-1; i <index;
   i-- ）{ no [i] = no [i-1];
   

  无[索引] = NUM; //插入数据
  的System.out.println（ “插入成绩的下标为：” +指数）;
  的System.out.println（ “插入后的成绩为：”）;
  for（int i = 0; i <no.length; i ++）{
   System.out.println（no [i] +“\ t”）;
  }
   }
}
B.删除数组中的元素：
包和;

 

import java.util.Scanner;

 

public class test {
 
 public static void main（String [] args）{
  Scanner input = new Scanner（System.in）;
  int no [] = new int [3];
  无[0] = 9;
  无[1] = 6;
  无[2] = 3;
  int index = 0;
  的System.out.println（ “原数组元素为：”）;
  for（int j = 0; j <no.length; j ++）{
   System.out.println（no [j] +“\ t”）;
  }
  的System.out.println（ “请输入要删除的元素：”）;
  int del = input.nextInt（）;
  //找到数组删除的位置
  for（int i = 0; i <no.length; i ++）{
   if（del == no [i]）{
    index = i;
    打破;
   }
  }
  的System.out.println（ “删除成绩的下标为：” +指数）;
  //输出原数组
  
  
  //元素后移
  for（int i = index; i <no.length-1; i ++）{
   no [i] = no [i + 1]; // index下标开始的元素后移
   
  }
  System.out.println（“删除后”的成绩为：“）;
  for（int i = 0; i <no.length-1; i ++）{
   System.out.println（no [i] +“\ t”）;
  }
   }
}

 

 第九章：<<双重循环>>

 

for（初始值;循环条件;迭代变量）{
 for（初始值;循环条件;迭代变量）{
  循环体
 }
}
外层变量变动一次，内存循环执行一遍

 

打印九九乘法表：
package and;
public class test4 {
 public static void main（String [] args）{
  int rows = 9;
  //外部循环控制乘法表行数
  for（int i = 1; i <= rows; i ++）{
   for（int j = 1; j <= i; j ++）{
    System.out.print（j +“*” + i +“=”+ j * i +“”）;
   }
   的System.out.println（）;
  }
   
 }
}

 

打打菱形
包;

 

import java.util.Scanner;

 

public class test3 {
 public static void main（String [] args）{
    package and;

 

import java.util.Scanner;

 

public class test3 {
 public static void main（String [] args）{
  Scanner input = new Scanner（System.in）;
  的System.out.println（ “请输入菱形的行数：”）;
  int rows = input.nextInt（）;
  if（rows％2 == 0）{
   System.out.println（“请输入奇数：”）;
   行= input.nextInt（）;
    
  } else {
   //外层循环控制菱形上半部分的行数
   for（int i = 0; i <= rows; i ++）{
   //内层循环控制菱形上半部分每行空格个数
    for（int j） = 1; j <= rows-i; j ++）{
     System.out.print（“”）;
    }
    //内层循环控制菱形上半部分每行*个数
    为（int j = 1; j <= 2 * i-1; j ++）{
     System.out.print（“*”）;
    }
   的System.out.println（）;
   }
   //外层循环控制菱形上半部分的行数
   for（int i = 0; i <= rows; i ++）{
    //内层循环控制菱形上半部分每行空格个数
    for（int j = 1; j <= i-1; j ++）{
     System.out .print（“”）;
    }
    //内层循环控制菱形上半部分每行*个数
    为（int j = 1; j <= 2 *（rows-1）-2 *（i-1）; j ++）{
     System.out.print （ “*”）;
    }
   的System.out.println（）;
   }
     
   
    }
 }
}

 

 第十一章：<<类和对象>>

 

类和对象？
电脑怎么认识这个世界呢？
类：告诉电脑这个世界是什么构成的（分类）
对象:(类别中的具体实体）
面向对象的优点：
1。与人类思维一致
2.信息隐藏
3。提高程序可用性

 

类和对象的关系：
类是对象的抽象，对象是类实例
访问修饰符（public protected private）
 
访问修饰符类类名{

 

 //属性：特征
 //方法：行为或功能
}
方法的调用：
同一类中直接用：方法名（）
。不同类中需要创建对象，对象名方法名（）;

 

 第十二章<<类的无参方法>>

 

无参方法：不带条件的行为

 

访问修饰符返回值类型方法名（）{
 方法体;
}
返回值类型：void（无返回）所学过的数据类型（有返回，返回“返回值”）
类型值必须一致;调用有返回值的方法，必须定义一个变量接收这个返回值
方法的调用：对象名。方法名（）;
成员变量和局部变量的区别？
  成员变量局部变量
作用域不同类方法
初始值不同有初始值无初始值

 

 第十三章：<<带参数的方法>>

 

有参方法：带条件的行为
访问修饰符返回值类型方法名（参数列表）{形参：形容这个方法的条件是什么
 方法体;
}
实参：方法调用时传过去的值
形参状语从句：实参：类型一致，个数一致，harmony和谐顺序
数组作为参数的方法:(在数组中计算平均值，寻找最大值）
通过创建学生类

 

包书;

 

public class Student {
 
 public double Avg（int [] scores）{
 int sum = 0;
 
 double avg = 0.0;
 for（int i = 1; i <scores.length; i ++）{
  sum + = scores [i];
  
 }
 avg =（double）sum / scores.length;
 返回平均
}
 公众诠释最大（INT []分数）{
  INT最大=分数[0];
  for（int i = 1; i <scores.length; i ++）{
   if（max <scores [i]）{
    max = scores [i];
   }
  }
  返回最大值;
 }
}
测试类
包书;

 

import java.util.Scanner;

 

public class Test {
 public static void main（String [] args）{
  Scanner input = new Scanner（System.in）;
  学生s =新学生（）;
  int [] scores = new int [5];
  的System.out.println（ “请输入5位参赛者的成绩：”）;
  for（int i = 0; i <5; i ++）{
   scores [i] = input.nextInt（）;
   
  }
  double avg = s.Avg（得分）;
  的System.out.println（ “平均成绩为：” + AVG）;
  int max = s.Max（得分）;
  的System.out.println（ “平均成绩为：” +最大）;
  
 }
}

 

对象作为参数的方法：
package book1;

 

public class Student {
 //形式类
  int id;
  字符串名称;
  年龄;
  int得分;
  public void show（）{
   System.out.println（“学号\ t姓名\ t年龄\ t分数”）;
   的System.out.println（ID + “\ t” +名字+ “\ t” +年龄+ “\ t” +分数）;
}
  
}

 

//学生管理类
公共类StudentBiz {
 学生[] s =新学生[30];
 public void add（Student st）{//增加学生
  for（int i = 0; i <s.length; i ++）{
   if（s [i] == null）{
    s [i] = st;
    打破;
   }
  }
 }
 公共无效显示（）{//展示学生信息
  的System.out.println（ “本班学生列表：”）;
  for（int i = 0; i <s.length; i ++）{
   if（s [i]！= null）{
    s [i] .show（）;
  }
  }
  的System.out.println（）;
 }
}

 

//测试类
  public class Test {
   public static void main（String [] args）{
    Student s1 = new Student（）;
    s1.id = 1;
    s1.name = “ZRY”;
    s1.age = 11;
    s1.score = 95;
    学生s2 =新学生（）;
    s2.id = 2;
    s2.name = “RY”;
    s2.age = 11;
    s2.score = 80;
    StudentBiz stu = new StudentBiz（）;
    stu.add（S1）;
    stu.add（S2）;
    stu.show（）;;
  }
}

 

包：1。将类分成较小点单元，易于寻找
    2.防止命名冲突
    3.允许更广范围内保护类，数据和方法声明
：包包名

 

 第十五章：<<字符串>>

 

A.创建字符串对象的3种方式：
1.String s = new String（）;
2.String s =“你好”;
3，String s = new String（“hello”）;
B.字符串的长度：
s.length（）;
C，字符串的比较：
1.s.equals（s1）;
==：判断两个字符串对象在内存中的首地址是否相等，判断11是否是同一个字符串
的equals（）：判断两个字符串内容是否相等;
2.s.equalsIgnoreCase（S1）：忽略字符串大小写进行比较;
3.s.toLowerCase（）。equals（s1）.toLowerCase（）：转换为小写字母并且返回小写字母
4.s.toUpperCase（）。equals（s1）.toUpperCase（）：转换为大写字母并且返回大写字母
D.复杂字符串的处理：
1.字符串的连接：s.concat，（s1）;
2.字符串的提取和查询：
公众诠释的indexOf（int类型）：查询第一个出现的字符小号
公众诠释lastIndexOf（int类型）：查询最后一个出现的字符小号
公共字符串的子串（INT指数）：提取从指数字符开始及之后的字符
public String substring（int beginindex，int endindex）：提取从索引字符开始到endindex之间的
字符public String trim（）;返回不含空格的字符
E.字符串的拆分：s.split（String separator，int限制）;
separator：要拆分的字符
 limit：限制返回字符中的元素
F：StringBuffer：String的增强版（不仅可以是字符，还可以是int等类型）
  s.toString（）;将s转换成String类型并输出
  s.append（s2）：在s的后面追加s1的内容;
  s.insert（位置，参数）;将参数插入到s的指定位置并返回;