Java面向过程的编程

Posted 2023-04-10 不已再是少年

Java语言基础

一.注释及注释的使用

1.java规范的三种注释 单行注释 多行注释 文档注释（java特有的） 2.注释的作用： 1.对所写的程序进行解释说明，增强可读性。方便自己观看 2.调试所写的代码 3.注释了的内容不参与编译。编译以后生成的.class的字节码文件中 不包含注释掉的信息

3.文档注释（java特有的） 格式：/** */ 注释内容可以被JDK提供的工具Javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档 .

4.多行注释不能嵌套使用

二.java基础知识点

2.1 关键字与保留字

关键字：

定义：被java语言赋予了特殊含义，用作专门用途的字符串

特点：关键字中所有的字母都为小写

保留字：

现有的Java版本尚未使用，但以后的版本可能会作为关键字使用。必须避开命名 goto，const

2.2 标识符

标识符：Java对各种变量，方法和类等要素命名时使用的字符序列称为标识符

通俗点讲：凡是可以自己命名的地方都叫标识符。

2.3变量

变量：

1. 内存中的一个存储区域

2. 该区域的数据可以在同一类型范围内不断变化

3. 变量是程序中最近基本的存储单元，包含变量类型，变量名和存储的值

作用：用于在内存中保存数据

注意：

• java中的每个变量需先声明，后使用

• 使用变量名来访问这块区域的数据

• 变量的作用域：其定义所在的一对（）内

• 变量只有在其作用域内才有效

• 同一个作用域内，不能定义重名的变量

数据类型：

整数类型

1. 整型 int 如int a；

2. long型 如long a；long b=56000L，c=280L；

3. byte型 byte没有常量的表示方法。变量的定义格式：byte 变量名[=值]

4. short型 short没有常量的表示方法。变量的定义格式：short 变量名[=值]

   浮点类型

5. float型 32位单精度

6. double型 64位双精度

布尔数据类型

逻辑值 ture / false

格式：boolean 变量名[=值]

boolean a;
a = false ;
boolean b=ture;

字符型

char char 变量名[=值]；

char a=\'b\';
char b=\'中\' ,c=\'x\';

转义字符

1. \\ \\ 表示反斜杠；

2. \\r 表示回车；

3. \\n表示换行；

4. \\f表示走纸换页；

5. \\t表示横向跳格；

6. \\b表示退格。

2.4运算符

运算符的种类：

1. 赋值运算符

• 简单赋值运算符

int a =100 ;

int b=a+10;

• 复合赋值运算符

运算符	用法	等价于
+=	op1+=op2	op1=op1+op2
-=	op1-=op2	op1=op1-op2
*=	op1*=op2	op1=op1*op2
/=	op1/=op2	op1=op1/op2
%=	op1*=op1%op2	op1=op1%op2

2. 算数运算符

• 一元运算符 ：+ - ++ --

• 二元运算符 ： + - * / %

int a=10,b=4;
System.out.ptintln("a%b="+a%b);

3. 关系运算符

   比较大小关系的二元运算符，大于，等于，不等于返回值为布尔值。

int a=3,b=5;
boolean c=(a>b);

注意等于运算符（==）不要与赋值运算符（=）混淆。

4. 逻辑运算符

    

运算符	实际操作	范例
！	非	!a
&	与	a&b
|	或	a|b
^	异或	a^b
&&	短路与	a&&b
||	短路或	a||b

5. 条件运算符

条件运算符是三元运算符，格式如下：

布尔表达式 ？表达式1 ：表达式2

例如：

public class ConditionDemo
         public static void main(String[] agrs)
            int scorel=68,score2=59;
            String result1=scorel1>=60?"pass":"down";
            String result2=scorel2>=60?"pass":"down"
         

6. 位运算符

同二进制运算一样，如下表

运算符	名称	举例	功能
~	按位取反	~a	a的每位二进制取反
&	与	a&b	对应位与运算
|	或	a|b	对应位或运算
^	异或	a^b	对应位异或运算
<<	左移	a<<b	对a左移b位，低位用0补（右补0）
>>	右移	a>>b	对a右移b位，高位用原高位补充（左补原符号位）
>>>	逻辑右移	a>>>b	对a右移b位，高位用0填充（左补0）

public class BitDemo
       public static void main(string[] args)
         int a=123 ,b=198;
         System.out.println("a & b ="+ (a&b)+";"+ "a | b ="+ (a|b));
         System.out.println("a ^ b ="+ (a&b)+";"+ "~a =" +(~a));
         System.out.println("a << 2="+ (a<<2)+";"+ "a >> 2 ="+ (a>>2));
       

2.5流程控制控制语句

1. 顺序语句，如下代码：

public class OrderDemo
     public static void main(string[] args)
        int x=125 ,y=5, z=0;
        z=x/y;
        System.out.println("z="+z);
     

结果为25，可见代码按照从上到下，从左到右依次执行。

2. 条件语句

• if语句

if(布尔表达式)
   语句块 1 

eg：
if(sorce>=60)
     System.out.println("pass");

若if只有一个语句，可以不加。

if-else语句

if(布尔表达式) // 语句组1 else // 语句组2

eg：判断物理成绩合格

import java.unil.Scanner;
public class ScoreLevel
      public static void main(string[] agrs)
          Scanner sc=new Scanner(System.in);
          System.out.println("plass take you physics number");
          int physics=sc.naxtInt();
          if (physics >= 60)
              System.out,println("pass");
      else
          System.out.println("down");
      

if-else if:多重if-else结构

if(布尔表达式1)
        语句块1
else if(表达式2)
        语句块2
else
        语句块3
 

• switch语句

             switch是多选一的语句，可以替代多个if else语句

switch(表达式)
       case 常量1;
            语句1;
            break;
            ...
       case 常量n;
            语句块n；
            break;
       default:
           语句;
           break;

3. 循环语句

while循环语句

while (循环条件)
         循环体

eg：求1~10000的和

pubilc class Getsum
     public  static void main(String[] args)
            int x =1;
            int sum=0;
            whilc(x<10000)
                sum += x;
                x++;
            
            System.out.println(sum);
     

do while语句

do
    //循环体
while(循环条件);

while 与 do while的区别

public class cycle
     public static void main(String[] args)
         int a=1 ,b=1;
         //while 循环，先判断后循环。
         while(a<1)
            a++;
         
         //do while  先循环后判断。
         do
             b++;
         while(b<1)
          System.out.println("a ="+a+",b="+b);
    

//运行结果  ： a =1 ； b =2

for循环语句

for(表达式1,表达式2,表达式3)
          //循环体

eg：用for循环求10以内的所有偶数的乘积。
public class CirculateFor
     public static void main(String[] args)
         int sum=1;
         for(i = 2;i<=10;i+=2)
                sum *=i;
         
         System.out.println(sum);
     

结果：3840

4. 跳转语句。

break语句

break;//终止break所在的循环，转去执行当前循环后的第一条语句。

continue语句

continue;//continue语句在while，for或者do...while结构中执行时跳过该循环体的剩余代码，循环体的条件测试部分进入下一轮循环

eg：输出100以内的奇数
public class ContinueDemo
        public static void main(String[] args)
           int i=0;
           while(i<100)
               i++;
               if(i%2 == 0)
                    continue;
               
               System.out.println(i +" ");
           
        

return语句

return 表达式;
public String toString()
     return "中华人民共和国万岁";

//关于循环语句的几个练习：
//1.九九乘法表
//2.100以内质数

//1.九九乘法表
class NNTest
    public static void main(string[] args)
        int i , j;   //定义变量i ，j
        int a;      // 定义积
        for(i=1;1<10,i++)   //外循环 从一开始到九
            for(j=1,j<10,j++)  // 内循环从一开始到就
                a = i*j;
                System.out.println(i+"*"j"="+a "\\t");
            
    
//不标准的九九乘法表，重复使用i ，j的值。
    //更正：
   class NNtest
    public static void main(String[] args)
        int i,j;     
        for(i=1;i<10;i++)
            for(j=1;j<=i;j++)  //重点在这，i ，j 不能重复使用。
                System.out.println(j+"*" + i + "=" + j*i+ "\\t");
            
            System.out.println();
        
    

2.100以内质数。

class PrimeNumberTest
  public static void main(String[] args)
      int i, j ;  // 定义变量
      boolean  k = true ; //确定一个布尔值k，用来判断i是否被j除尽，一旦除尽，修改其值。
      for(i=2;i<=100;i++)  //遍历100以内的数
          for(j=2;j<i;j++)   //再次遍历小于i的数
              if(i % j ==0)   //用小数j 去除j 
                  k = false;   //如果除尽了，返回值为false
              
              
            if( k == true)    //如果没除尽返回true
                System.out.println(i);  //输出没有被j除尽的数也就是质数
          
          k =true;   //重置k
      
  

优化代码：

class PrimeNumberTest
  public static void main(String[] args)
      int i, j ;  // 定义变量
      boolean  k = true ; //确定一个布尔值k，用来判断i是否被j除尽，一旦除尽，修改其值。
      for(i=2;i<=100;i++)  //遍历100以内的数
          for(j=2;j<i;j++)   //再次遍历小于i的数  优化2：Math.sqrt(i)  :根号i，对本身是自然数，优化程序进程。
              if(i % j ==0)   //用小数j 去除j 
                  k = false;   //如果除尽了，返回值为false
                  break;   // 优化一 节省非质数的对j的取余数。 
              
              
            if( k == true)    //如果没除尽返回true
                System.out.println(i);  //输出没有被j除尽的数也就是质数
          
          k =true;   //重置k
      
  

//利用long  start = System.currentTimeMillis(); 
//long  start = System.currentTimeMillis();来计算程序运行的时间。 
//利用continue进行最后的优化：代码如下：
class primeNumberTest2
     public static void main(String[] args)
           label:for(i=2;i<=100;i++)
               for(j=2;j<Math.sqrt(i);j++)
                      if( i % j==0)
                        continue label;
               
           
           System.out.println("质数为"+I);
     

面向对象编程和面向过程编程

1、面向过程（Procedure Oriented 简称PO ：像C语言）：

    面向过程注重过程的。当解决一个问题的时候，面向过程会把事情拆分成： 一个个函数和数据（用于方法的参数） 。然后按照一定的顺序，执行完这些方法（每个方法看作一个个过程），等方法执行完了，事情就搞定了。

2、面向对象（Object Oriented简称OO ：像C++，JAVA等语言）：

    面向对象注重对象的。当解决一个问题的时候，面向对象会把事物抽象成对象的概念，就是说这个问题里面有哪些对象，然后给对象赋一些属性和方法，然后让每个对象去执行自己的方法，问题得到解决。

3、两者的区别

    面向对象是将事物高度抽象化，而面向过程是一种自顶向下的编程

4、两者各自的优缺点

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 
缺点：没有面向对象易维护、易复用、易扩展

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护 
缺点：性能比面向过程低