使用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的指定位置并返回;

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值