《程序设计基础》学习总结

Java程序设计基础学习总结

1. 梳理总结学习过的知识点（自行总结，内容不限于下列）

1.1 数据类型、表达式

Java有八种基本数据类型：

Byte，short，int，long，float，double，boolean，char

概念：

byte

8位、有符号的以二进制补码表示的整数

min :    -128（-2^7）

max:   127(2^7-1)

default: 0

对应包装类：Byte

short

16位、有符号的以二进制补码表示的整数

min :    -32768（-2^15）

max:   32767（2^15 - 1）

default: 0

对应包装类：Short

int

32位、有符号的以二进制补码表示的整数

min :    -2,147,483,648（-2^31）

max:   2,147,483,647（2^31 - 1）

default: 0

对应包装类：Integer

long

64位、有符号的以二进制补码表示的整数

min :    -9,223,372,036,854,775,808（-2^63）

max:   9,223,372,036,854,775,807（2^63 -1）

default: 0

对应的包装类：Long

float

单精度、32位、符合IEEE 754标准的浮点数

float 在储存大型浮点数组的时候可节省内存空间

浮点数不能用来表示精确的值

default: 0.0f

对应的包装类：Float

double

双精度、64位

浮点数的默认类型为double类型

double类型不能表示精确的值

default: 0.0d

对应的包装类：Double

char

char类型是一个单一的 16 位 Unicode 字符

最小值是 \u0000（即为0）

最大值是 \uffff（即为65,535）

char 数据类型可以储存任何字符

对应的包装类：Character

boolean

boolean数据类型表示一位的信息

只有两个取值：true 和 false

这种类型只作为一种标志来记录 true/false 的情况

对应的包装类：Boolean

表达式：

所谓的表达式就是运用操作数和运算符组成的，比如以下表达式：

Int a=10;

a=a+10;

1.2 程序结构：

Java程序的基本结构大体可以分为包、类、main()主方法、标识符、关键字、语句和注释等等。

比如以下代码：

package pta;//pta就是包名

import java.util.Scanner;

public class Main {

  public static void main(String[] args){//此方法就是main主方法

注释：可以提高程序的可读性，注释包含的文字不会对程序产生任何影响，在Java中，代码注释主要有以下几种：

　　1. 单行注释　　

　　“//”为单行注释标记，从“//”开始到换行为止的所有内容均被注释而被编译器忽略。

// 这是一条单行注释

　　2. 多行注释

　　“/* /”为多行注释标记，符号“/”与“/”之间的所有内容均为注释内容，可以换行。

/ 注释内容1 注释内容2 … /

　　3. 文档注释

　　“/* /”为文档注释标记。符号“/**”与“/”之间的内容均为文档注释内容。格式与多行注释相同。

顺序结构：

按照代码的书写顺序从下往上依次执行。大部分代码都按照此结构执行。

选择结构

1.if......else二选一的结构

if(条件){

    条件为真执行的代码

}else{

    条件为假执行的代码

}

2. if......else if.....else多选一的结构

 if(条件1){

    条件1为真执行的代码

}else  if(条件2){

    条件2为真执行的代码

}else  if(条件3){

    条件3为真执行的代码

else{

    条件为假执行的代码

    }

循环结构

1.do while

开始/初始条件；

do{

 重复执行的代码；

 迭代条件

}

2.while(判断/结束条件)

注意：先执行后判断，至少会执行一次

3.for循环

for(开始条件；判断/结束条件；迭代条件){

    重复执行的代码

}

跳转语句

1.break

结束循环，break可以用于循环，switch选择结构，函数

2.continue

立即跳出本次循环，继续下一次循环（本次循环体continu 之后的 代码 就都少执行这一次），只能用于循环中

3.循环嵌套

①循环可以相互嵌套，内存循环放在外层循环的{}，常用的的是双重循环

②外层循环变量走一个，内层循环的变量要从头到尾走一遍

1.3数组应用：

概念

数组就是存储数据长度固定的容器，多个数据的数据类型要一致。 数组初始化

数组的两种常见初始化方式：

动态初始化（指定长度）

静态初始化（指定内容）

方式一：动态初始化

格式：

数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[数组长度];

数组存储的数据类型 数组名字[ ] = new 数组存储的数据类型[数组长度];

数组定义格式：

数组存储的数据类型： 创建的数组容器可以存储什么数据类型。

[] : 表示数组。

数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。

new：关键字，创建数组使用的关键字。

数组存储的数据类型： 创建的数组容器可以存储什么数据类型。

[长度]：数组的长度，表示数组容器中可以存储多少个元素。

定义可以存储3个整数的数组容器，代码如下：

int[] arr = new int[3];  

int   arr[] = new int[3];

//可以拆开：

int[] arr;

arr = new int[3];

方式二: 静态初始化

格式：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};

举例： 定义存储1，2，3，4，5整数的数组容器。

int[] arr = new int[]{1,2,3,4,5}; 

// 一样可以拆 

int[] arr;

arr = new int[]{1,2,3,4,5};

方式三 ：静态初始化格式

数据类型[] 数组名 = {元素1,元素2,元素3…};

举例：

定义存储1，2，3，4，5整数的数组容器

int[] arr = {1,2,3,4,5};

数组又分为静态和动态：

静态：int[] a = {1,2,3};

动态：int[] a = new int[10] a[0]=1; a[1]=2;

区别：数组创建时间不同，静态的是一定义出来就创建了，动态的则是定义时不创建，使用时才创建，一定意义上节省了内存空间。

数据的应用实例：

冒泡排序：（代码如下）

import java.util.Scanner;

public class 冒泡排序 {

   public static void main(String[] args) {

       Scanner reader = new Scanner(System.in);

       int i, n, t, j, m, b, temp;

       t = reader.nextInt();

       int a[] = new int[110];

       for (m = 0; m < t; m++) {

           b = 0;

           n = reader.nextInt();

           for (i = 0; i < n; i++) {

               a[i] = reader.nextInt();

           }//应用循环和数组存放输入的数据

           for (i = 0; i < n - 1; i++) {

               for (j = 0; j < n - 1 - i; j++) {

                   if (a[j] > a[j + 1]) {

                       b++;

                       temp = a[j];

                       a[j] = a[j + 1];

                       a[j + 1] = temp;

                   }

               }

           }

           System.out.print(b);

           if (m != t - 1) {

               System.out.println();//没有进行输出

           }

       }

   }

}

冒泡排序就是通过运用数组存放数据和运用元素下标进行不断交换进行大小排序的一个具体实例

1.4 类、方法

类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）；

对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。

可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。，

在Java中定义类，使用关键字class完成。语法如下：

class 类名称 {

        属性 (变量) ;

        行为 (方法) ;

}

范例：定义一个Person类

class Person {     // 类名称首字母大写

   String name ;

   int age ;

   public void tell() {        // 没有static

         System.out.println("姓名：" + name + "，年龄：" + age) ;

        }

}

类定义完成之后，无法直接使用。如果要使用，必须依靠对象，那么由于类属于引用数据类型，所以对象的产生格式（两种格式）如下：

（1）格式一：声明并实例化对象

类名称 对象名称 = new 类名称 () ;

（2）格式二：先声明对象，然后实例化对象：

类名称 对象名称 = null ;

对象名称 = new 类名称 () ;

对象.属性：表示调用类之中的属性； 

对象.方法()：表示调用类之中的方法。

范例：使用对象操作类

package com.wz.classandobj;

class Person { 

   String name ;

   int age ;

   public void get() {

       System.out.println("姓名：" + name + "，年龄：" + age);

   }

}

public class TestDemo {

       public static void main(String args[]) {

           Person per = new Person() ;// 声明并实例化对象

           per.name = "张三" ;//操作属性内容

           per.age = 30 ;//操作属性内容

           per.get() ;//调用类中的get()方法

       }

}

2. PTA实践总结

选择不少于两个程序示例进行说明，需要发布源代码、测试用例。

谈一下在线刷题的个人感受。

2.1示例1

import java.util.Scanner;

public class 倒序存放 {

   public static void main(String[] args) {

       Scanner sc = new Scanner(System.in);

       int n = sc.nextInt();

       int[] a = new int[n];

       for (int i = 0; i < a.length; i++) {

           a[i] = sc.nextInt();

       }

       int sum;

       for (int j = 0; j < a.length/2; j++) {

           sum = a[j];

           a[j] = a[a.length-1-j];

           a[a.length-1-j] = sum;

       }

           for (int k = 0; k < a.length; k++) {

               System.out.print(a[k]+" ");

       }

   }

}

输出结果：

4

1 3 2 4

4 2 3 1 

以上就是运用了数组和循环对输入数字进行一个倒叙输出的一个操作程序

首先通过创建一个数组存储·输入的若干数字，然后利用数组元素下标进行对首位和末位元素交换，然后是第二位与倒数第二位元素进行交换，再利用for循环进行若干次如上操作，即可实现数组元素的倒叙输出。

2.2示例2

import java.util.Scanner;

public class 累加器 {

   public static void main(String[] args) {

       Scanner sc = new Scanner(System.in);

       int sum=0;

       int n = sc.nextInt();

       int[] a = new int[n];

       for (int i = 0; i < a.length; i++) {

           a[i] = sc.nextInt();

       }

       for (int j = 0; j < a.length; j++) {

          sum=sum+a[j];

       }

       System.out.println(sum);

   }

}

输出结果：

4

1 4 6 7

18

以上是一个简单的加法程序，通过for循环对输入数字进行若干次加法运算的操作。

首先创建一个数组存储输入的若干数字，然后利用数组中的元素下标进行加法运算，并将每次的结果赋予给创建的sum中存储起来，最后进行结果输出。

2.5在线评测系统使用感受

能够非常方便实时将自己编写的程序代码进行运行测试，检测自己的代码是不是可以符合题目要求，如果符合便可以直接提交，感觉不方便的就是不能知道自己错哪里了，导致有时候会因为不知道哪个测试点而去修改代码，但却查不出错误的地方，有时候非常浪费时间，但总体来说还是非常方便实用的。

3. 改进学习方法、措施落实情况（内容可扩展，至少包括以下项）

3.1 除课堂外，遇到不会的问题时会到哪个平台搜索

度娘，csdn，qq平台询问老师，bilibili

3.2 根据记录2个月的每天代码时长，利用excel绘制统计表

不会制作Excel表格，但平均每天一个小时，节假日后会出现松懈，会出现几天不想敲代码的心情低落感。

3.3 感觉个人的哪些方法还存在不足？哪些方面需要改进？等

   ...知识点不够丰富，做作业有一点拖拉，敲代码不够细心，上课应该提前预习并且下课后进行课外拓展，在面对题型的时候不能够快速理解题目要求，着落点不能够快速切入

4. 你知道csdn么，结合使用情况表述他的优点与不足

知道，上面有很多的大神对java知识点进行讲解，通俗易懂，也可以与他们实时交流问题，解答自己的困惑，暂时没有感到有什么地方不好用

4.1 csdn给你的直观感受是什么？

大神多，有不会的问题可以去查找

4.2 csdn你感觉最不舒服的地方是什么？

有许多种语言代码，有时候会分不清

4.3 你还利用了哪些平台学习编程知识，他们是哪些网站或资源，优点是什么？

哔哩哔哩，有博主进行视频讲解，可以更方便的理解java，可以帮助自己理解上课没听懂的知识点和错过的知识点

5. 你认为影响你学习编程的主要阻力是什么？如何克服！

自身的懒惰和拖延症，学习java应该勤奋敲题目，才能够面对难题时临危不乱。

6. 其它（针对课程的学习，请发挥）