第三周周报

学习内容
1.java基础
2.链表：使用插入函数实现乱序输入顺序输出

1.java基础

本周是学习java的第一周，通过视频了解了java的一些最基本的知识。
摘要如下：
一：java概述：

1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。

2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。

3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

环境变量的配置：
1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin

2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin

要知道java是分两部分的：一个是编译，一个是运行。
javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。
java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.
一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数.

二：java语法基础：
1，关键字：其实就是某种语言赋予了特殊含义的单词。
保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。

2，标示符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。包含 0-9、a-z、$、_ ；
注意：
   1），数字不可以开头。
   2），不可以使用关键字。

3，常量：是在程序中的不会变化的数据。

4，变量：其实就是内存中的一个存储空间，用于存储常量数据。
   作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。
   特点：变量空间可以重复使用。

什么时候定义变量？只要是数据不确定的时候，就定义变量。

变量空间的开辟需要什么要素呢？
  1，这个空间要存储什么数据？数据类型。
  2，这个空间叫什么名字啊？变量名称。
  3，这个空间的第一次的数据是什么？ 变量的初始化值。

变量的作用域和生存期:

变量的作用域：
  作用域从变量定义的位置开始，到该变量所在的那对大括号结束；

生命周期：
  变量从定义的位置开始就在内存中活了；
  变量到达它所在的作用域的时候就在内存中消失了；

数据类型：
1）：基本数据类型：byte、short、int、long、float、double、char、boolean
2）：引用数据类型: 数组、类、接口。

**级别从低到高为：**byte,char,short(这三个平级)–>int–>float–>long–>double

自动类型转换：从低级别到高级别，系统自动转的；

强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；

运算符号：
1）、算术运算符。
   + - * / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。
   +:连接符。
   ++,–

2）、赋值运算符。
   = += -= *= /= %=

3）、比较运算符。
  特点：该运算符的特点是：运算完的结果，要么是true，要么是false。

4）、逻辑运算符。

& | ^ ! && ||

逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。

&: 只有两边都为true结果是true。否则就是false。

|:只要两边都为false结果是false，否则就是true

^:异或：和或有点不一样。
    两边结果一样，就为false。
    两边结果不一样，就为true.
  & 和 &&区别： & ：无论左边结果是什么，右边都参与运算。
       &&：短路与，如果左边为false，那么右边不参数与运算。
  | 和|| 区别：|：两边都运算。
       ||：短路或，如果左边为true，那么右边不参与运算。
5）、位运算符:用于操作二进制位的运算符。
  & | ^
  & << >> >>>(无符号右移)
  5，语句。
  If switch do while while for
  这些语句什么时候用？
  1）、当判断固定个数的值的时候，可以使用if，也可以使用switch。
  但是建议使用switch，效率相对较高。

switch(变量){
   case 值:要执行的语句;break;
   …
  default:要执行的语句;
  }

工作原理：用小括号中的变量的值依次和case后面的值进行对比，和哪个case后面的值相同了
  就执行哪个case后面的语句，如果没有相同的则执行default后面的语句；

细节：a：break是可以省略的，如果省略了就一直执行到遇到break为止；
     b：switch 后面的小括号中的变量应该是byte,char,short,int四种类型中的一种；
      c：default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。
  2）、当判断数据范围，获取判断运算结果boolean类型时，需要使用if。
  3）、当某些语句需要执行很多次时，就用循环结构。 while和for可以进行互换。
区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。

break:作用于switch ，和循环语句，用于跳出，或者称为结束。

break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。

continue:只作用于循环结构，继续循环用的。

作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。

6，函 数（视频里称之为方法）：为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数就是体现之一。

java中的函数的定义格式：
   修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数1，…){
      执行语句；
     return 返回值；
  }没有具体的返回值时，返回的返回值类型用void关键字表示。

如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。

return的作用：结束函数。结束功能。

如何定义一个函数？

函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成：

1）、明确该功能的运算完的结果，其实是在明确这个函数的返回值类型。

2）、在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数列表(参数类型&参数个数)。

函数的作用：

1）、用于定义功能。

2）、用于封装代码提高代码的复用性。

注意：函数中只能调用函数，不能定义函数。

主函数：

1）、保证该类的独立运行。

2）、因为它是程序的入口。

3）、因为它在被jvm调用。

函数定义名称是为什么呢？

答：1）、为了对该功能进行标示，方便于调用。

2）、为了通过名称就可以明确函数的功能，为了增加代码的阅读性。

重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。

如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。

7，数 组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。

如何在java中表现一个数组呢？两种表现形式。

1）、元素类型[] 变量名 = new 元素类型[元素的个数]；

2）、元素类型[] 变量名 = {元素1，元素2…}；

元素类型[] 变量名 = new 元素类型[]{元素1，元素2…}；

java分了5片内存

1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。

栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；

只要数据运算完成所在的区域结束，该数据就会被释放。

堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。

1：每一个实体都有内存首地址值。

2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。

3：垃圾回收机制。

栈：存放的都是方法中的局部变量。方法的参数，或者方法内部的变量。
方法的运行一定要在栈当中。
堆：new出来的东西都在堆里面，每个东西都有一个地址值：16进制。
方法区：存储.class的相关信息，包含方法的信息。

三：面向对象：★★★★★

特点：1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想是符合现在人们思考习惯的一种思想。

过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。


类是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
对象是一类事物的具体表现，对像是类的一个实例。

调用一个方法时，首先根据地在方法区里面找到相应的成员方法，然后让该方法进栈（压栈），方法执行完之后就会自动出栈（弹栈）。就比如main方法执行时运行到one.call方法。该方法会先进栈，压在main方法上面（压栈）运行完之后会自动出栈，然后main方法重见天日，再运行接下来的程序。当main方法也运行完之后栈的内存就清空了。

使用对象类型作为方法的参数时，传递进去的实际上是一个地址值，因为new出来的东西都存放在堆里面，而且都有一个地址。
就比如这个代码里面的变量one，保存的是对象的地址。
内存情况如图所示：

局部变量和成员变量的区别：

成员变量定义在方法的外面，再类的内部。局部变量定义在方法的内部。
成员变量在整个类当中都能使用，局部变量只能在方法中使用。
成员变量都有默认值，而局部变量没有默认值，必须初始化之后才能使用。

面向对象的三大性质：

1.封装

封装就是将一些细节信息隐藏起来，对于外界不可见。

private

的作用就是避免一些不合理的操作出现，使用了private后，该变量不能直接在其他的类当中使用。
如果要使用就必须要用到getter/setter方法。

this：

用来解决方法的局部变量和成员变量重名的问题。

通过谁调用的方法，谁就是this.
比如该代码中：sout(this)的值==sout(person)的值：都是这个类的地址。
this.name就代表成员变量的name。

2.链表

上个星期也了解了许多链表的操作。
这个星期学了个新的：通过插入函数实现链表的乱序输入顺序输出。
学习自许瑶的博客。
内容如下：

#include
# include
struct f
{
     
	int data;
	char name[11];
	struct f *next;
};  
int insert(struct f *head)
{
     
	struct f *p;
	p=(struct f *)malloc(sizeof(struct f));
	printf("请输入要加入的学生的学号和姓名\n");
	scanf("%d %s",&p->data,p->name);
    while(head->next!=NULL&&head->next->data<p->data)
    head=head->next;  
    if(head->next!=NULL&&head->next->data==p->data)
    {
         
    	free(p);
    	return 0;
    }
    p->next=head->next;   
   head->next=p;
    return 1;
}
int Delete(struct f*head)
{
     
	int num;
	struct f *p; 
	p=head->next;
	if(p==NULL)
	return 0; 
	printf("请输入要删除的学生学号\n");
	scanf("%d",&num);
	while(p!=NULL)
	{
     
		if(p->data==num)
		 {
     
		     head->next=p->next;
		     free(p);
		     return 1; 
		 }
		 head=p;
		 p=p->next; 
	}
	return 0; 
} 
struct f *find(struct f *head)
{
     
	printf("请输入要查找的学生的学号！\n");
	int num;
	scanf("%d",&num);
	struct f *p;
	p=head->next; 
	while(p!=NULL)
	{
     
		if(p->data==num)
		return p;
		else
		p=p->next; 
	}
	return NULL;
}                                    //定义一个结构体//
struct f *creat(void)                  //链表的创建函数//
{
     
	struct f *head,*p,*end;
	int x; 
	head=end=(struct f*)malloc(sizeof(struct f));
	printf("请输入学号以及你的姓名！\n");
	p=(struct f*)malloc(sizeof(struct f));
	scanf("%d %s",&p->data,p->name);
	end->next=p;
	end=p;
	end->next=NULL;
	printf("请选择继续输入和退出，继续输出请输入1，退出输入0\n");
	while(scanf("%d",&x),x!=0)
	{
         
		insert(head);  
		printf("请选择继续输入和退出，继续输出请输入1，退出输入0\n"); 
	}
	return head; 
} 
void print(struct f*head)     //链表的输出函数//
{
     
	head=head->next;
	while(head!=NULL)
	{
     
		printf("%d %s\n",head->data,head->name);
		head=head->next; 
	}
} 
main()      //卑微主函数//
{
     
	struct f *head,*p;
	head=creat();
	print(head);
	if(insert(head))
	printf("插入成功！\n"); 
	else
	printf("插入失败！（有重名！！）\n"); 
	print(head);
	p=find(head);
	if(p)
	printf("找到学生 该生的信息是\n%d %s\n",p->data,p->name);
	else
	printf("没找到！\n"); 
	print(head); 
	if(Delete(head))
	printf("已删除\n");
	else
	printf("删除失败\n"); 
	print(head); 
}

里面的insert函数用到create函数里面就能实现该功能，以后写学生管理系统也会用到该方法。
我的代码：

# include
# include
typedef struct Node
{
     
	int data;
	struct Node * pnext;
}node,*pnode;
void insert(pnode phead)
{
     
	pnode head = phead;
	int val;
	printf("请输入要加入的数据：\n");
	scanf("%d",&val); 
	pnode pnew = (pnode)malloc(sizeof(node));
	pnew->data = val;
	while(head->pnext!=NULL&&head->pnext->data<val)
	head = head->pnext;
	pnew->pnext = head->pnext;
	head->pnext = pnew;
	
}
pnode createlist(void)
{
     
	int val;
	char i;
	pnode phead = (pnode)malloc(sizeof(node));
	pnode ptail = phead;
	ptail->pnext = NULL;
	printf("请输入数据：\n");
	scanf("%d",&val);
	pnode pnew = (pnode)malloc(sizeof(node));
	pnew->data = val;
	ptail->pnext = pnew;
	pnew->pnext = NULL;
	ptail = pnew;
	printf("是否继续？1/0\n");
	while(scanf("%d",&i),i==1)
	{
     
		int j;
		insert(phead);
		printf("是否还继续?是：1 /否：0\n");
	}
	
	return phead;
}

void traverselist(pnode phead)
{
     
	pnode p = phead->pnext;
	while(p!=NULL)
	{
     
		printf("%d ",p->data);
		p = p->pnext;
	}
	printf("\n");
}
int main(void)
{
     
	pnode phead = createlist();	
	traverselist(phead);	
	
	return 0;
}

注：insert函数里面的pnode head = phead;是为了找到比插入的值大的节点。
不能写成pnode temp = phead->pnext；
这样的话会漏掉第一个节点比插入的数据大的情况。

以上就是这个星期的学习内容。下个星期继续看java，啊哈算法也要开始学了。