01--java概述、环境变量配置
1、Java概述软件开发
1. 软件：一系列按照特定：顺序组织的计算机数据和指令的集合。
1. 常用软件
4. 系统软件：DOS、Windows、Linux、Mac
4. 应用程序：扫雷、迅雷、QQ
1. 什么是开发
软件制作就是开发
1. 人机交互
1. 软禁的出现实现了人与计算机之间的更好交互
1. 交互方式：
1、图形化界面(Graphical User Interface，GUI)这种方式简单直观，使用者易于接受，容易上手操作。
2、命令行方式(Command Line Interface，CLI)需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记住一些命令。
1. 命令行方式
1. dir:列出当前目录下的所有文件和文件夹
1. md:创建目录
1. rd:删除目录(不能有文件的目录)
1. cd:进入指定目录
1. cd .. :退回到上一级目录
1. del:删除文件
1. exit:退出dos界面
1.1什么是计算机语言
1. 语言：是人与人之间用于沟通的一种方式。
例如：中国人与中国人用中文交流。
而中国人要和韩国人交流，就要学习韩文。
1. 计算机语言：人与计算机交流的方式
1. 如果人要与计算机交流，那么久要学习计算机语言。计算机语言有很多种，如C，C++，JAVA等。这里我们选择其中的一种：Java。
1.2 Java语言概述
1. 是SUN（Stanford University Network），斯坦福大学网络公司1995年推出的一门高级编程语言。
1. 是一种面向Internet的编程语言。
1. 随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。
1. 是简单易学，完全面向对象，安全可靠，与平台无关的编程语言。
1.2.1 Java语言的三种技术架构
1. J2EE（Java 2 Platform Enterprise Edition）企业版
1. 是为开发企业环境下的应用程序提供的一套解决方案。
1. 该技术体系中包含的技术如 Serviet Jsp等，主要针对Web应用程序开发。
1. J2SE（Java 2 Platform Standard Edition）标准版
1. 是为开发普通桌面和商务应用程序提供的解决方案。
1. 该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发。
1. 比如java版的扫雷。
1. J2ME（Java 2 Platform Micro Edition）小型版
1. 是为开发电子消费产品和嵌入式设备提供的解决方案。
1. 该技术体系主要应用小型电子消费类产品，如手机中的应用程序等。
1. Java5.0版本后，更名为JAVAEE、JAVASE、JAVAME
1.2.2 Java语言的特点：跨平台性
1. 因为有了JVM，所以同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。也称为Java具有良好的可移植性。
1.3 Java语言的环境搭建
1.3.1 什么是JRE、JDK
1. JRE(Jave Runtime Environment ，Java运行环境)
1. 包括Java虚拟机(JVM，Java Virtual Machine)和java程序所需的核心类库等，如果想运行一个开发好的Java程序，计算机只需要安装JRE即可。
1. JDK（Java Development Kit，Java开发工具包）
1. JDK是提供给Java开发人员使用的，其中包含了Java的开发工具包，也包含了JRE。所以安装JDK，就不用在单独安装JRE了。
1. 其中的开发工具：编译工具(javac.exe)、打包工具(jar.exe)等。
1. 简单而言：使用JDK开发完成的java程序，交给JRE去运行。
1.3.2 下载JDK
1. 、java.sun.com官方网站上可下载最新版本
1.3.3 安装JDK
1. 傻瓜式安装，下一步即可。
1. 建议：安装路径不要有中文或者特殊符号，如空格等。
1. 当提示安装JRE时，可以选择不安装。
1.3.4 配置JDK环境变量技巧
1. XP系统：
46. 右键我的电脑—高级—环境变量—系统变量—新建变量—输入变量名：JAVA_HOME--地址D:Javajdk1.7.0_09—确定。
46. 选择PATH—在变量值最左边输入%JAVA_HOME%bin;--确定—重新打开dos界面测试。
1. Win7系统:
47. 右键计算机—高级设置—环境变量—系统变量—新建变量—输入变量名：JAVA_HOME—地址：D:Javajdk1.7.0_09—确定。
47. 选择PATH—在变量值最左边输入%JAVA_HOME%bin;--确定—重新打开dos界面测试。
1. 临时设置环境变量
1. 命令行set查看所有变量
49. set path=d:jdk-1.7bin回车(临时设置完成，关闭dos界面后恢复)
1.4 Java程序开发体验—Hello World
1、将Java代码编写在扩展名为.java的文件中。
2、通过javac命令对该java文件进行编译。
3、通过java命令对生成的class文件进行运行。
1、编写简单测试java小程序hello world.java
代码如下：
class HelloWorld{
public static void main (String[] args){
System.out.print("Hello World!");
}
}
2、编译java文件
命令行 javac "hello world.java"
1. 运行编译程序
java HelloWord
0. 结果
显示Hello World！
2、Java语言基础组成
2.1、关键字
· 关键字的定义和特点
· 定义：被java语言赋予了特殊含义的单词。
· 特点：关键字中所有字幕都为小写。
· 用于定义数据类型的关键字
· class
· interface
· byte
· short
· int
· long
· float
· double
· char
· Boolean
· void
· 用于定义数据类型的关键字
· true
· false
· null
· 用于定义流程控制的关键字
· if
· else
· switch
· case
· default
· while
· do
· for
· break
· continue
· return
· 用于定义访问权限修饰符的关键字
· private
· protected
· public
· 用于定义类，函数，变量修饰符的关键字
· abstract
· final
· static
· synchronized
· 用于定义建立实例及引用实例，判断实例的关键字。
· extends
· implements
· 用于定义类和类之间关系的关键字
· new
· this
· super
· instanceof
· 用于异常处理的关键字
· try
· catch
· finally
· throw
· throws
· 用于包的关键字
· package
· import
· 其他修饰符关键字
· native
· strictfp
· transient
· volatile
· assert
2.2、标识符(类名)
· 在程序中定义的一些名称
· 由26个英文字母大小写，数字：0-9，符号：_$组成
· 定义合法标识符规则：
1. 数字不可以开头
1. 不可以使用关键字
1. Java中严格区分大小写
1. 注意：在起名字的时候，为了提高阅读性，要尽量有意义。
Java中的名称规范：
1. 包名：多单词组成时所有字母都小写。
19. xxx.yyy.zzz
1. 类名接口名：多单词组成时，所有单词的首字母大写。
20. XxxYyyZzz
1. 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。
21. xxxYyyZzz
1. 常量名：所有字母都大写。多单词时每个单词用下划线连接。
22. XXX_YYY_ZZZ
2.3、注释
1. 单行注释
23. 要注释的文字前面加入//，如 //这是一个HelloWorld简单程序。
1. 多行注释（多行注释中不能有多行注释）
24. 在注释的文字前后添加/* … */,如/*这是一个HelloWorld简单程序。*/
1. 文档注释
25. 在注释的文字前后添加/**…*/，如/**这是一个HelloWorld简单程序*/
02--常量变量,数据类型,运算符
2013年4月9日
8:47
2.4 常量和变量
2.4.1 常量
* 常量是不能改变的数值.
* java中常量的分类:
1)整数常量,所有整数.
2)小数常量,所有小数.
3)布尔型常量,只有两个数值:true和false.
4)字符常量,将一个数字.字母或者符号用单引号标识('2' '中')
5)字符串常量,将一个或者多个字符用双引号标识
6)null常量,只有一个数值就是:null
* 对于整数:有四种表现子形式
1)二进制,0,1 满2进1
2)八进制:0-7,满8进1,用0开头表示
3)十进制:0-9,满十进一
4)十六进制:0-9,a-f,满16进1,用0x开头.
2.4.2 进制转换
* 进制的基本转换
1)十进制二进制互转
十进制转二进制,除以2去余数
二进制转十进制.乘以2的幂数
2)十进制八进制互转
十进制转八进制,除以8去余数
八进制转十进制,乘以8的幂数
3)十进制16进制互转
十进制转16进制,除以16去余数
16进制转十进制,乘以16的幂数
4)负数的二进制表现形式:
对应的整数二进制取反加1
2.4.3 变量
* 变量的概念
内存中的一个存储区域
定义该区名称,类型,变量值
该区域的数据可以在同类型范围内不断变化
* 使用变量注意事项:
1)变量的作用范围在{}之间有效
2)初始化值
* 定义变量的格式
数据类型 变量名 = 初始化值;
注意:格式是固定的,记住格式,以不变应万变.
* 理解:变量如同数学中的x未知数.
2.4.4 变量分类
* 按照声明的位置划分:
1)局部变量:方法或语句块内部定义的变量
2)成员变量:方法外部类的内部定义的变量
注意:类对应的大括号外面不能定义变量
* 按照所属的数据类型划分:
1)基本数据类型变量
2)引用数据类型变量
* 注意:成员变量可以不赋值,因为java虚拟机会给成员变量赋默认值
局部变量必须赋值,否则会出现编译错误.
2.5 数据类型
* Java语言是强类型语言,对于每一种数据都定义了明确的数据类型,
在内存中分配了不同大小的内存空间
* 基本数据类型取值范围占用内存大小及默认值
默认情况:整数是int型,浮点数都是double型.
2.5.1 数据转换
* 自动类型转换(也叫隐式类型转换)
* 强制类型转换(也叫显式类型转换)
* 类型转换的原理
所有的byte型、short型和char型的值将被提升为int型。
如果一个操作数是long型，计算结果就是long型。
如果一个操作数是float型，计算结果就是float型。
如果一个操作数是double型，计算结果就是double型。
* 数据参与运算
1)整型,字符型,浮点型的数据混合运算中相互转换时都遵循以下原则:
容量小的类型与容量大的类型进行计算,默认转换为容量大的数据类型.
数据类型按容量从小到大的排序为:
Byte<short<char<int<long<float<double
Byte,short,char之间不会互相转换,计算时首先转换为int类型
2)强制转换符
格式(数据类型) (要被转换的数据) byte b =(int)(130);
3) 思考：
byte b1=3,b2=4,b;
b=b1+b2;//编译失败,因为变量是不确定的值,所以无法计算后赋值
b=3+4;//编译通过,常数检查没有查过数据类型的最大值就可以赋值
2.6 算术符
2.6.1 算数运算符
2.6.2赋值运算符
符号：
= , +=, -=, *=, /=, %=
示例：
int a,b,c; a=b=c =3;
int a = 3; a+=5;等同运算a=a+5;
思考：
short s = 3;
s=s+2;// 编译失败，因为s会被提升为int类型
运算后的结果还是int类型。无法赋值给short类型。
s+=2;// 编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。
2.6.3 比较运算符
* 符号
== 相等于
!= 不等于
< 小于
> 大于
<= 小于等于
>= 大于等于
Instanceof 检查是否是类的对象
注意:
1)比较运算符的结果都是boolean型，也就是要么是true，要么是false
2)比较运算符"=="不能误写成"="
2.6.4 逻辑运算符
符号
& 与(and) 有一个是false最后结果为false
| 或(or) 有一个是true最后结果为true
^ 异或(XR) 两个相同的值最后结果为false
! 非 值是结果相反的
&& 双或 第一个值为false就不运算第二个值
|| 双与 第一个值为true就不运算第二个值x
2.6.5 位运算符(位运算是直接对二进制进行运算)
符号
<< 左移 移几位就乘以2的几次幂
>> 右移 移几位就除以2的几次幂
>>> 无符号右移 被移位二进制最高位无论是0或者是1，空缺位都用0补
& 与运算 二进制位进行&运算，只有1&1时结果是1，否则是0
| 或运算 二进制位进行 | 运算，只有0 | 0时结果是0，否则是1
^ 异或运算 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
~ 反码
二进制1就是true，0就是false
对两个整数变量的值如何进行互换(不需要第三方变量)
int a = 5;
int b = 7;
a = a ^ b;
b = a ^ b;
a = b ^ a;
2.6.6 三元运算符
格式
(条件表达式)?表达式1：表达式2
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
int x=3,y=4,z;
z=(x<y)?x:y //z的值是3
2.6.1 判断结构
if语句三种格式
1)if (条件表达式){
执行语句;
}
2)if(条件表达式){
执行语句;
}else{
执行语句;
}
3)if(条件表达式){
执行语句;
}else if(条件表达式){
执行语句;
}
if语句和三元运算符的区别:
1)三元运算符可以称之为if语句的简写形式,只要简写就会有一定的弊端.
2)三元运算符,是一种运算符号,也就是说每次执行后,必须有结果.
3)if..else是语句,只要是控制流程,执行后不一定有结果
4)if..else里面可以有语句,并输出结果,三元运算符不可以.
if语句的使用情况
1)当对值进行判断的时候
2)当对数据区间进行判断的时候
3)当结果是布尔类型的时候
03--判断,选择,循环结构
2013年4月9日
8:46
2.7 判断
if语句特点：
a,每一种格式都是单条语句。
b,第二种格式与三元运算符的区别：
三元运算符运算完要有值出现。好处是：可以写在其他表达式中。
c,条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;
2.8 选择
switch语句
格式：
switch(表达式){
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}
switch语句特点：
1) switch语句选择的类型只有五种：
byte，short，int ， char。1.7版本可以接收String字符串。
2) case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
3) 结束switch语句的两种情况：遇到break，执行到switch语句结束。
4) 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，
运行可以执行的语句，直到遇到break或者switch结尾结束。
switch与if的区别
1) 如果对几个具体的值进行判断，可以使用switch，也可以使用if，
但是建议使用switch效率会更高一些。
2) 如果是对区间进行判断或者多boolean结果的判断，只能用if。
因为switch里面不接收boolean的值.
2.9 循环结构
代表语句：while ， do while ， for
while语句格式：
while(条件表达式){
执行语句；
}
do while语句格式：
do
执行语句；
}while(条件表达式);
do while特点：
是条件无论是否满足，循环体至少执行一次。
定义循环的前提条件:1)明确循环条件2)控制循环次数
if与while区别:if是对条件进行一次判断,while是对条件进行多次判断
for格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式){
执行语句；(循环体)
}
1)for里面的每个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2)while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
3)最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
可以用输出语句System.out.println();调试程序，看到循环中的每一步的输出
转义符号：
t：制表符
n：换行符
r：回车符
' 单引号字符
" 双引号字符
\ 反斜杠字符
注：windows里面的回车换行是由两个符号组成rn
Linux的回车符n组成的
转义字符需要写在单引号或双引号里用+号连接
转义字符代表的是一个字符可以放在char里
其他控制流程语句
break(跳出)语句：应用范围：选择结构和循环结构。
continue(继续)语句：应用于循环结构。
注：
1),这两个语句离开应用范围，存在是没有意义的。
2),这个两个语句单独存在下面都不可以有语句，因为执行不到。
3),continue语句是结束本次循环继续下次循环。
4),标号的出现，可以让这两个语句作用于指定的范围。
语句总结:
1) 当对某几个值进行判断的时候，可以使用if语句，或者switch语句，建议switch，但是，使用switch要注意，它只能操作四种类型的值，byte short，int，char，String如果是五种类型以外的值，需要使用if。
2) 如果对数据区间进行判断，或者对运算结果是boolean类型的进行判断。使用if语句。
3) 当需要某些语句执行很多次的时候，使用循环结构。如果定义变量只为循环增量存在时，可以使用for语句。如果对一个条件进行判断使用if，如果对该条件进行多次判断，使用while。
4) 如果要结束循环，可以控制循环条件，或者通过break语句完成。如果要控制循环的流程，是否该继续执行，可以通过continue或者break来完成。
04--函数、数组概述
3、函数
3.1 函数的定义
函数就是类中发具有特定功能的一段独立小程序，也叫方法。
格式：修饰符 返回值类型 函数名(参数类型 名称....)
{
执行语句;
return 返回值;
}
例:
public static int Test1(int test) //返回整数型
public static void Test2(int test) //不返回值
使用方式:
直接写函数名,传递相应的参数参数有顺寻使用变量,接收返回值.
3.2 函数的特点
1)定义函数可以将功能代码进行封装
2)增加代码的复用性
3)函数只有在被调用的时候才会被执行
4)便于该功能的复用性
5)对于函数没有具体指的情况下,返回值类型用关键字void表示,
该函数中的return语句如果在最后一行可以省略不写.
注意事项:
1)不允许将函数定义到另一个函数中
2)函数之间可以互相调用
3)返回值类型,必须和return返回的数据类型一致
4)返回值类型是void的函数不可以放在输出语句打印
5)修饰符可以不写public,但是必须要写static
6)不要化蛇添足
3.3 函数的应用
实例:
需求:
定义一个功能,实现两个整数的加法运算.
思路:
1)定义该函数为int类型
2)定义两个未知数整型
3)最后return x+y返回相加的值
主要代码:
public static int sum(int x,int y)
{
return x+y;
}
3.4 函数的重载(overload)
同一个类型,多个重名函数,只要参数列表不一致就出现重载特性.
要求:顺序,类型,个数不一致
特点:返回值类型无关,只看参数列表,函数实现功能一致,细节不同,可以利用重 载特性来实现.
好处:代码量大大减少,错误率更低,方便阅读,优化程序设计
4、 数组
4.1数组的定义
数组就是一个容器,里面存储了同一种类型的数据.
好处:数组里的数据从0开始编号,方便操作这些数据.
声明一个变量就是在内存空间划出一块合适的空间.
声明一个数组就是在内存空间划出一串连续的空间
4.2 数组的格式:
格式1(一般不用)
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
int[] arr1 = new int[5];
格式2:
元素类型[] 数组名 = new 元素类型[] {元素,....};
元素类型[] 数组名 = {元素,元素,元素.....};(一般使用这个方法)
int arr1 = new int []{1,2,3,4...};
int arr1 = {1,2,3,4,5....};
4.3 数组的使用方法:
int[] arr1 = new int[6]; //声明数组开辟空间
arr1[0] = 6; //赋值
int sum = arr1[0]*10; //数据处理
System.out.println(sum); //输出
4.4 数组内存结构剖析
为了提高运算效率,java程序运行时需要在内存中进行了5个区域划分
分别是:栈内存,堆内存,方法区,本地方法栈,PC寄存器(程序计数器).
栈内存:
用于存储局部变量,当数据使用完自动释放.
堆内存:
1) 存储通过new建立的实例数组和对象
2) 每个实体都有内存地址值
3) 实体中的变量都有默认值(int-0,double-0.0,Boolean-false,char-u0000)
4) 实体不在被使用时,会在不确定的时间内被垃圾回收器回收.
数组创建,赋值过程图:
4.5 数组常见错误
1) int[] arr =new int[]; //没有注明数组的大小
2) int[] arr =new int[5;]
System.out.println(arr[5]);
ArrayIndexOutOfBoundsException //数组超出越界,数组从0开始计数
3) int[] arr;
arr ={1,2,3,4}; //创建数组并赋值必须在一条语句内完成.
4) int[] arr =null;
System.out.println(arr[0]);
NullPointerException //不能打印空值
4.6 数组使用注意事项:
1) 数组只能有一个标识符(名称)
2) 数组的长度固定,注意避免角标越界
3) 数组定义时,必须明确元素的类型
4) 数组定义时,必须明确元素的个数
4.7 数组知识点
1) 数组中的每一个元素都能通过下标来访问
2) 数组角标从0开始
3) 数组长度获取:变量名.length(数组长度是固定的)
4) 数组动态初始化: int[] arr =new int[5];
5) 数组静态初始化:int[] arr ={1,2,3,4};(经常使用的格式)
6) 当要对较多的同种数据类型变量操作时需要将这些数据进行存储
7) 好处:可以对数据进行存储,而且对数据进行编号,方便遍历和任意使用
05--数组应用、二维数组
2013年4月9日
8:45
4.8 数组的其他应用
1) 选择排序
无序列的数组,从小到大,顺序排列
原理:是从第一位数逐个跟后几位进行对比
代码:
for(int x =0;x<arr.length-1;x++){
for(int y =x+1;y<arr.length;y++){
if (arr[x]>arr[y]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
2) 冒泡排序
原理:两个相邻位置比较,最大值出现在最大下标
代码:
public static void bubbleSort(int[] arr){
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-1;y++)
{
if (arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] =temp;
}
}
}
//遍历数组
for(int x=0;x<arr.length;x++)
{
System.out.print(arr[x] +" ");
}
}
3) 反转
将数组内的值位置顺序倒转.
4) 二分查找法
进行对半对半的判断,提高计算效率,在不规律的数值时不适用.
5) 查表法
使用数组造表,通过需求找出对应的值
4.9 数组中的数组
二维数组[][]
格式1:int[][] arr =new int[3][3];
1) 定义了名称为arr的二维数组
2) 二维数组中的3代表有3个一堆数组
3) 每一个一维数组中有3一个元素
4) 一维数组的名称分别为:arr[0],arr[1],arr[2]
5) 赋值50给一维数组1脚标,写法:arr[0][1]=50;
格式2:int[][] arr = new int[3][];
1) 二维数组中有3个一维数组
2) 每个一维数组都是默认初始化值null
3) 可以对这个3个一位数进行初始化
arr[0] = new int[2]; //第一组初始化2个数值
arr[1] = new int[1]; //第二组初始化1个数值
arr[2] = new int[5;] //第三组初始化5个数值
格式3:int[][] arr ={{1,3,6},{,2,4},{2,3,1,45,6}}; //一般用这种格式,方便
1) 定义一个名称为arr的二维数组
2) 二维数组中的有三个一维数组
3) 每一个一维数组中具体元素也都已初始化
06--面向对象之封装、匿名对象、构造函数
2013年4月9日
8:45
5、面向对象
5.1 面向对象概念
解决现实生活中问题的处理思想和思维模式
思想和角色的转变,研究真实存在的具体事物,事物就看成对象
面向对象设计把握的一个重要经验:谁拥有数据,谁就对外提供操作这些数据的方法.
5.1.1 理解面向对象
1) 面向对象是相对面向过程而言
2) 面向对象和面向过程都是一种思想
3) 面向对象是基于面向过程
面向对象和面向过程区别:
面向过程强调的是功能行为
面向对象是将功能封装进对象,强调具备了功能的对象
5.1.2 面向对象的特点:
1) 是一种符合人们思考习惯的思想
2) 可以将复杂的事情简单化
3) 将程序员从执行者转换成了指挥者
4) 完成需求时:
* 先要去找具有所需的功能的对象来用
* 如果该对象不存在,那么创建一个具有所需功能的对象
* 这样简化开发并提高复用
5.1.3 面向对象开发,设计,特征
开发的过程:其实就是不断的创建对象,使用对象,指挥对象做事情.
设计的过程:其实就是在管理和维护对象之间的关系
面向对象的三大特征:
1) 封装(encapsulation)
2) 继承(inheritance)
3) 多态(ploymorphosm)
5.2 类与对象的关系
5.2.1 类的定义:
生活中描述事物无非就是描述事物的属性和行为
java中用类class来描述事物也是如此
1) 属性:对应类中的成员变量
2) 行为:对应类中的成员函数
定义类其实在定义类中的成员(成员变量和成员函数)
类是java语言用来面熟现实中存在的具体事物
例如:描述人(class Person),描述车(class Car)
5.2.2对象的定义
对象就是现实中确实存在的那个具体的事物
类是描述对象,对象是现实中的具体事物
类和对象的关系:
1) 类看做生产图纸
2) 对象看做根据图纸生产出存在的产品
5.2.3 成员变量(全局变量)和局部变量的区别
1)作用范围
成员变量:定义在类中,作用于整个类
局部变量:只在它所属的局部大括号中有效
2) 存储情况
成员变量:存储在堆内存中.随着对象的存在而存在,当对象变成垃圾回收时,该对象 中的成员变量会消失
局部变量:存储在栈内存中,当方法被调用或者语句被执行的时候,才存在
当方法运行完毕或者语句运行完毕时,局部变量会自动释放
3) 初始化情况
成员变量:在堆内存中有默认初始化值
局部变量:必须手动初始化后才可以被使用
5.2.4 成员变量和局部变量内存图
5.2.5 创建对象,使用对象
class Car//对Car这类事物进行描述
{
String color = "red";
int num = 4;
void show()
{
System.out.println("color="+color+"..num="+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
Car c = new Car();//建立对象
c.color = "black";//对对象的属性进行修改
c.show();//使用对象的功能。
}
}
5.2.6 对象内存结构
Car c1 = new Car();c1.color="blue";
Car c2 = new Car();
5.3匿名对象
匿名对象是对象的简化形式
匿名对象使用时需要注意的两种情况
1) 当对对象方法仅进行一次调用的时候
2) 匿名对象可以作为实际参数进行传递
5.3.1 new对象的详细过程
<1> 因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中
<2> 执行该类中的static代码块，如果有的话，给Person.class类进行初始化
<3> 在堆内存中开辟空间，分配内存地址
<4> 在堆内存中建立对象特有属性，并进行默认初始化
<5> 对属性进行初始化
<6> 对对象进行构造代码块初始化
<7> 对对象进行对应的构造函数初始化
<8> 将内存地址赋给栈内存中的p变量
6、面向对象之 封装(Encapsulation)
定义:指隐藏对象的属性和实现细节,仅对外提供公共访问方式
好处:
1) 将变化隔离,隐藏类的实现细节
2) 便于使用,可以方便加入控制逻辑,限制对属性不合理操作
3) 提高重用性,便于修改,增强代码的可维护性
4) 提高安全性
封装原则:
1) 将不需要对外提供的内容都隐藏起来
2) 把属性都隐藏,提供公共方法对其访问
3.3.1 private (私有)关键字
private关键字
1) 是一个权限修饰符。
2) 用于修饰成员(成员变量和成员函数)
3) 被私有化的成员只在本类中有效。
常用之一：
将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访 问的安全性
6.1 构造函数
特点:
1) 构造方法的方法名必须与类名相同
2) 构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。
3) 构造方法不能由编程人员调用，而要系统调用。
4) 一个类可以定义多个构造方法，也就是构造方法可以重载，以参数的个数，类 型，或排列顺序区分。
5) 如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认 构造器，这个构造器不执行任何代码。
作用：构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的 参数传给对象的域。
构造函数和一般函数的区别:
1从功能上的区别：
构造函数是给对象初始化的
一般函数是因为对象需要满足某种功能定义的
2从执行上的区别
构造函数，是对象创建的时候被执行，不用调用。
一般函数是什么时候调用，就什么时候执行，不调用就永远不执行。
6.2 this关键字
定义:Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM） 就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此， this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出 现this,(这在讲解Java关键字static、final中给出了明确解释。)并且this只和 特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。
简言之:哪个对象调用this所在的函数，this就代表哪个对象。
this关键字的作用
1) 第一、通过this调用另一个构造方法，用法是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。
2) 第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用"this.成员变量名"的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错，呵呵。
3) 第三、在函数中，需要引用该函数所属类的当前对象时候，直接用this。
4) 其实这些用法总结都是从对"this是指向对象本身的一个指针"这句话的更深入的理解而来的，死记不然容易忘记而且容易搞错，要理解！
局部代码块(定义在方法里面)
public void method(){
{
int x = 4;
System.out.println("x="+x);
}
}
这种写法开发并不常见,但是面试可能会出现,它的作用就是可以限定变量的生命周期.
初始化块（构造代码块）
定义在类里
{
System.out.println("我是初始化块")
}
1) 括号里的是初始化块，这里面的代码在创建java对象时执行，而且在构造器之前执行！
2) 其实初始化块就是构造器的补充，初始化块是不能接收任何参数的，定义的一些所有对象共有的属性、方法等内容时就可以用初始化块了初始化！！
3)好处是可以提高初始化块的复用，提高整个应用的可维护性。
还没有评论，来说两句吧...