14天学java-firstDay

一:Java的三种架构:

(1)JAVAEE：java platForm for enterprise Edition,开发企业环境下的应用程序,主要针对web

应用程序。

(2)JAVASE:Java platForm for Standard Edition,完成桌面应用程序的开发,是其他两者的基础。

(3)JAVAME:JAVA plateForm for Micro Edition,开发电子消费产品和嵌入式设备,如手机中的程序。

二:JDK,JRE,以及环境变量配置:JAVA_HOME,class_path,path

三:javac编译.java文件为.class（字节码）文件,java启动jvm,加载所需类库,并对.class文件进行执行。一个文件要被运行，都有一个执行的起点,这个起点就是main函数。

四:JAVA语法基础:

1,关键字:某种语言赋予了特殊含义的单词。保留字:其实还没赋予特殊含义,但是准备日后使用的单词。

2,标识符:程序中自定义的名词,比如类名,变量名,函数名。包括0-9,a-z,$,_等

3,常量;程序中不会变化的数据

4,变量:其实就是内存中的一个储存空间,用于储存常量数据

作用:方便与运算。特点:变量空间可以被重复使用

变量空间开辟3要素:变量类型 变量名称 变量初始值

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

生命周期:

变量从定义的位置开始再内存中存活,变量到达他所在的作用域就在内存中消失了

数据类型:

1:基本数据类型:byte,char,short,int,long,float,double,boolean

2:引用数据类型:数组，类，接口。

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

自动类型转换,由低级到高级,强制类型转换:由高级到低级,问题：精度丢失

运算符号:

(1)算数运算符: + -  *  /  % ++ --

(2)赋值运算符: = += -=  *= /= %=

(3)比较运算符: > < = >=  <= ==

(4)逻辑运算符: & | ! && || ^

^:异或，两边结果一样就为false,两边结果不一样就为true

&和&&的区别,&&当左边为假,则不再解析

（位运算符）:用于操作二进制位的运算符

语句

条件语句: if switch 

循环语句:for,while,do...while

while和do...while的区别：while先判断后执行,do...while()先执行后判断

while和for可以互换:

        区别在于:如果需要定义变量,控制循环次数,建议用for，因为for循环完毕,变量在内存中释放

continue:只作用与循环结构,用于继续循环用的。结束本次循环,开始下次循环

6:函数为了提高代码的复用性,可以将其定义成一个单独的功能,该功能的体现就是java中的函数。函数就是其中体现之一

java中的函数定义格式:

修饰符 返回值类型 函数名(参数类型 参数类型1,参数类型,参数类型2...){

        执行语句

        return 返回值

}，当函数没有具体的返回值时,返回值类型用void关键字表示,如果番薯返回值类型时void，return语句可以不写,系统会自动帮你加上。return 作用,结束函数，返回数据。

函数作用:定义功能,封装代码,提高代码的复用性，函数中只能调用函数,不能定义函数。

主函数：{
        1:保证该类的独立运行

        2：因为他是程序的入口

        3:因为他在jvm中被调用        
}

重载:在一个类中,如果出现过两个或两个以上同名函数,只要他们的参数个数,或者参数类型不同即可称之为函数重载（只看参数列表,不看返回值）

7：数组：用于储存同一类型数据的一个容器。表现数组的两种形式：

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

2）、元素类型[] 变量名 = {元素1,元素2...}

内存小知识:

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

栈：储存的都是局部变量（函数中定义的变量,函数上的参数，语句中的变量），只要数据运算所在区域结束,该数据就会被释放。

堆：用于储存数组和对象,也就是实体。实体:用于封装多个数据的

每个实体都有内存首地址值,堆内存中的变量都有默认初始化值，因为数据类型不同,值也不一样。垃圾回收机制

三：面向对象：将复杂的事情简单化，面向对象将以前剁成中的执行者变成了指挥者,面向对象这种思想符合现在人们的一种思考方式

匿名对象使用场景：当对方法只进行一次调用，可以使用匿名对象。

当对象对成员进行多次调用,不能使用匿名对象，必须给对象取名字

在类中定义其实都成为成员,成员有两种：成员变量：对应事务的属性和成员函数：对应事物的行为，所以其实定义类，其实是在定义成员变量和成员函数。但在定义之前,必须要对事物进行属性和行为分析,才能用代码来体现。私有访问权限最低，只有在本类中的访问才有效，私有仅仅是封装的一种体现形式而已

私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的属性访问方式来完成对私有的访问，可以通过对外提供函数的形式对外提供访问。好处：可以在其中加入逻辑判断,对数据进行判断等操作

总结：开发时，属性是用来储存数据的，直接被访问，容易出现安全隐患。所以，类中的属性通常被私有化，并对外提供公共的访问方法。这个方法一般有两个，规范写法：对于属性xxx,可以使用setXXX()和getXXX()对其进行操作

类中怎么没有定义主函数呢？注意：主函数的存在，仅为该类是否独立运行，如不需要,主函数是不用定义的

主函数的解释：保证所在类的独立运行,是程序的入口,被jvm调用

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

1：成员变量直接定义在类中。局部变量定义在方法中,参数上，语句中

2：成员变量只在这个类中有效。局部变量只在自己所属的大括号内有效，大括号结束,局部变量失去作用域

3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。局部变量存在于堆内存中,随着对象的产生而存在,消失而消失,局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

构造函数：用于给对象进行初始化,是给与之对应的对象进行初始化，他具有针对性,函数的一种

特点：

        1：该函数所在名称和所在类的名称相同

        2：不需要定义返回值类型

        3：该函数没有具体的返回值

所有对象创建时,都需要初始化才可以使用

注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化,如果在函数中自定义了构造函数,那么默认构造函数就没有了

一个类中,可以有多个构造函数，因为他们的函数名称都相同，所以只能通过参数列表来区分。所以，如果一个类中出现多个构造函数,他们的存在是以重载的体现的

构造函数和一般函数有什么区别呢？

1：两个函数定义格式不一

2：构造函数是在对象创建时就被调用,用于初始化,而且初始化动作只执行一次。一般函数，是对象创建后，需要调用才执行，可以被调用多次

什么时候使用构造函数呢？分析事物时，发现事物一出现,就具备了一些特征，就将这些特征定义到构造函数内

构造代码块和构造函数区别：构造代码块：给所有的对象进行初始化,也就是说,所有的对象都会调用一个代码块，只要对象一建立，就会调用这个代码块。构造函数：是给与之对应的对象进行初始化,它具有针对性。

Person p = new Person();

创建一个对象都在内存中做了什么事情：

1：先将硬盘上指定位置的Person.class文件加载进内存

2: 执行main方法时,在栈内存中开辟main方法的内存（压栈-进栈），然后在main方法的栈区分配了一个变量p

3：在堆内存中开辟了一块内存空间,分配了一个内存首地址值,new

4:在该实体空间中进行属性的空间分配,并进行默认初始化

5：对空间中的属性进行显示初始化

6：进行实体的构造代码块初始化

7：调用该实体对应的构造函数,进行构造函数初始化

8：将首地址赋值给p,p就引用了该实体(指向该对象)

封装：(面向对象特征之一)：是指隐藏对象的属性和实现细节,仅对外提供公共的访问方式

好处：将变化隔离,便于使用,提高重用性,安全性。封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问。

this代表对象,就是函数所属对象的引用。

this用于构造函数的调用,调用格式：this(实际参数)

this对象后面跟上.调用的是成员属性和成员方法(一般方法)

this对象后面跟上()调用的是本类中对应参数的构造函数。

注意:用this调用构造函数,一定要定义在构造函数的第一行，因为构造函数用于初始化的，所以初始化动作一定要执行，否则编译失败。

static：关键字，是一个修饰符，用于修饰成员（成员变量和成员函数）

特点：

1：想要实现对象中的共享数据中的对象共享,可以将这个数据进行静态修饰

2：被静态修饰的成员，可以直接被类名所调用,也就是说，静态的成员多了一种调用方式。类名.静态方式

3:静态随着类的加载而加载，而且优先于对象存在

弊端：

1：有些数据是对象特有的数据,是不可以被静态修饰的,因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出现了问题。所以，在定义静态时,必须要明确，这个数据是否被对象所共享的。

2：静态方法只能访问静态成员,不可以访问非静态成员.

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员

3：静态中的方法不能使用this,super等关键字

因为this代表对象，静态方法加载时,可能没有对象,所以this无法使用

4：主函数是静态的

定义静态成员：成员分成员变量和成员方法,成员变量:该成员变量的数据是否所有对象都一样,如果是,该成员需要被static修饰，如果不是，说明这是对象的特有数据,需要储存到对象中。

定义成员函数：方法中没有引用特有变量就定义为静态，判断成员函数是否需要被static修饰，如果有访问特有变量，那么就不能被定义为静态方法

成员变量和静态变量的区别:

1、成员变量属于对象,所以也成为实例变量。静态变量属于类,也成为类变量

2、成员变量存在于堆内存中,静态变量存在于方法区中

3、成员变量随着对象的创建而存在,随着对象的回收而消失，静态变量随着类的加载而存在,随着类的消失而消失

4、成员变量只能被对象所调用,静态变量可以被对象调用,也可以被类名调用

所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据

静态的注意;静态的声明周期很长,

静态代码块：就是一个有静态关键字标识的一个代码块区域。定义在类中

作用：可以完成类的初始化。静态代码随着类的加载而执行,而且只执行一次(new 多个对象就只执行一次,如果和主函数在同一类,优于主函数执行)

public: 访问权限最大

static:不需要对象,直接类名即可

void:主函数没有返回值

main主函数特定名称

（String [] args）:主函数的参数，是一个字符串数组类型的参数,jvm带哦用，main方法时，传递的实际参数是new String[0]

jvm默认传递的是长度为0的字符串数组，我们在运行改类时,也可以指定具体的参数进行传递。可以在控制台,运行该类时,在后面加入参数,参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组的元素，进行存储。

静态代码块，构造代码块，构造函数同时存在时的执行顺序：静态代码块->构造代码块->构造函数

生成java帮助文档：命令格式：javadoc -d 文件夹名 -auther -version *.java

//格式

 

//格式

　　　　/**   

　　　　　*类描述

　　　　　*@author 作者名

　　　　　*@version 版本号

　　　　　*/

　　　　/**

　　　　　*方法描述

　　　　　*@param  参数描述

　　　　　*@return  返回值描述

　　　　　*/

设计模式：解决问题最行之有效的思想。是一套被反复使用,多数人知晓的,经过分类编目的/代码设计经验的总结。使用设计模式是为了一个重复可用、让代码更容易被他人理解,保证代码可靠性

java中有23种设计模式.

单例设计模式：解决问题：保证一个类在内存中的对象唯一性,比如：多程序读取一个配置文件时，建议配置文件封装成对象,方便配置文件封装成对象,会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象,就需要该配置文件在内存中的唯一。

Runtime()方法就是单例设计模式进行设计的

如何保证对象的唯一性：

思想：

1：不让其他程序创建改类对象

2：在本类中创建一个本类对象

3：对外提供方法,让其他程序获取这个对象

步骤：

1：因为创建对象都需要构造函数初始化,只要将本类中的构造函数私有化,其他程序就无法再创建该类对象；

2：就在类中创建一个本类的对象

3：创建一个方法，返回该对象，让其他程序可以通过方法得到本类对象。

代码体现：

1：私有化构造函数

2：创建私有并静态的本类对象

3：定义共有并静态的方法,返回该对象

饿汉式

　　class Single{

　　　　private Single(){}   //私有化构造函数。

　　　　private static Single s = new Single();  //创建私有并静态的本类对象。

　　　　public static Single getInstance(){   //定义公有并静态的方法，返回该对象。

　　　　　　return s;

　　　　}

　　}

懒汉式:延迟加载方式。

　　class Single2{

　　　　private Single2(){}

　　　　private static Single2 s = null;

　　　　public static Single2 getInstance(){

　　　　　　if(s==null)

　　　　　　s = new Single2();

　　　　　　return s;

　　　　}

　　}

继承：（面向对象特征之一）

好处：1：提高了代码复用性 2：让类与类之间产生了关系，提供了另一个特征多态的前提

父类的由来：多个类不断向上抽取共性内容而来