笔记

初识java 10/17
知识点
1、java项目目录结构
src目录：存放项目中源代码
JRE System Library java运行时环境的jar包
2、新建源文件
src目录中，new选择class，会生成.java的源文件
3、myeclipse中运行程序
代码区域-->右键-->tun as-->java application
程序运行后，输出结果，会显示在console（控制台中）

java注释 10/18
知识点：
1、java中的注释
java语言中，注释分三类：单行注释、多行注释、文档注释。
单行注释 //注释内容，主要是对单行代码，就变量进行解释说明。
多行注释 /*注释内容*/，可以一次对多行代码进行注释。
文档注释 /**注释内容*/，对类（class）进行说明，通过也可以
对方法进行说明，而且注释的内容会发生成API文档的信息。
2、注意点
①、类名使用public修饰
②、一行致谢一条语句
③、{}的使用及位置
④、代码缩进
3、MyEclipse中代码排版
快捷键 Ctrl+Shift+F
量的类型 10/19
整数类型：byte、short、int、long
浮点数类型：float、double
字符类型：char
布尔类型：boolean
知识点
1、数据类型
a.整数类型默认的类型是ing
b.定义long类型的数据，必须要在数据后面加上l或L
列：long a=100L;
c.浮点数类型默认的类型是double
d.定义float类型的数据，必须要在数字后面加上f或F
列：float a=10.21f;

e.double的时候后面可以加上d或D，一般省略
f.char表示字符类型，赋值的时候数据要放在‘值’（单引号）中
列：Char sex=‘男’;

g.String表示字符串类型，赋值的时候数据要放在"值"（双引号）中。
列：String name="张三";

 

变量、赋值、转换 10/20
1、变量的作用域
从定义变量地方开始，到当前"}"后结束。变量如果出了作用域就会被回收。

2、赋值运算符是
变量名=表达式/固定值
表达式举例：a=(b+3)+(b-1)

3、基本类型的转换
①自动转换（隐式类型转换）：从小类型到大类型可以自动完成
char->
byte->short->int->long->float->double 左到右，小到大 自动完成
②强制类型转换：从大类型到小类型需要强制转换符，会造成进度损失或溢出。
右到左，大到小 需要强制转换
强制转换举例：
double price=12.34;
int pri=(int)price;//转换类型的方法:+要转换的类型
System.out.println(pri);
控制台输出结果为：12; //损失

4、同类型参与运算（可能需要自动类型转换）。
返回同种类型（可能发生；上溢出和下溢出）。
byte、short、char三种类型在Java中是表象（假的），底层都是按照int运算的。

5、“+”的作用
+ 在算术运算符中表示做加法运算；
在字符串中，可以用来连接字符串，同时也可以和其他的数据类型的变量进行连接。
Scanner、运算符 10/21

1、关系运算符的作用，用来作比较运算比较的结果：boolean类型
boolean:类型的值；真true / 假false

2、控制台输入Scanner
实现控制台输入数据的步骤：
①：在class上导包。import java.util.Scanner;
②：创建Scanner对象。Scanner scan=new Scanner(System.in);
③：调用对象的方法，接收控制台输入的数据。
scan.next();//接收字符串数据
scan.nextint();//接收整数类型数据
scan.nextDouble();//接收浮点数类型数据

3、自增（自减）运算符
①自增（自减）运算符：++ --
就是可以将当前变量自我增加（减少）1的运算符
②i++,后++先将i的值作为整个代表值，然后将i增加1。
③++i,先++，先将i增加1，然后将i的值作为整个代表值。

4、运算符的优先级
最高的优先级：小括号，即（）
最低的优先级：赋值运算符，即#
优先即顺序：算术运算符>关系运算符>逻辑运算符

 

 

if,else if, else 10/25
if的基本结构
if(条件){ //结果必须是布尔值："boolean"
//代码块
} //只有一条语句是可以不用{}，暂不使用

（score1>98 && score2>80）|| (score1==100 && score2>70)

if(条件){
//代码块1
}else{
//代码块2
}

if(赵四Java成绩>98）{
奖励一个MP4
}else{

}
\+1/;//是1-10随机
int random=(int)(Math.random()*10);//0-9随机数

大于等于80好。大于等于60中等。小于60差；

if(成绩>=80){

//条件1,好

}else if(成绩>=60){

//条件2，中等,,,/可多个else if（）/

}else{

//条件3，差

}

if(条件1){//10秒时间
if(条件2){ //性别
代码1
}else{
代码2
}
}else{
代码3
}

switch 以及和 if 的区别 10/26
switch(整型、字符)//使用类型：byte short int char
{

case 常量1:
造句;
break;

case 常量2:
造句;
break;

.....

default:
造句;
break;
}

和 if 比较
相同点：
都是用来处理多分支条件的结构

不同点：
Switch只能处理等值条件判断的情况，而且条件必须是整型变量或字符变量。
if没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况。

while 10/27
while(循环条件）{
循环操作
}

特点：先判断、再执行

 

调试 断点 10/31
设置断点
程序调试 单步运行
观察变量

do-while以及和 while 的区别 11/01
do{

循环操作

}whlile(循环条件);

1.声明初始化循环变量
2.执行一遍循环操作
3.判断循环条件，如果循环条件满足，则循环继续执行，否则退出循环。
特点：先执行、在判断；

 

do-while与while的区别

1.语法不同
while(循环条件）{ do{
循环操作 循环操作
} }whlile(循环条件);

2.执行次序不同
while：先判断、在执行
do-while：先执行、在判断

3.初始情况不满足循环条件时：
while循环一次都不会执行
do-while循环不管任何情况都会/至少运行一次/

 

 

for 11/02
for(表达式1;表达式2;表达式3;){
//循环体
}

步骤:
1.执行初始化部分；比如 int i=1;
2.进行循环条件的判断；比如 i<100
3.根据循环条件判断结果
为true ，则执行
为false,则循环退出 步骤4 5 不执行
4.执行迭代部分，改变循环变量制 i++
5.依次重复2-4，直到退出循环

表达1.2 可以表达多个表达式 用,（逗号/英）号隔开。

break continue 11/03
break:改变程序控制流
用于 do-while while for 中时。可跳出循环而执行循环后面的语句

while(...){
...
break;
...
}

continue:只能在循环里
作用：跳过循环体中剩余 的语句而执行下一次循环
while(...){
...
continue;
....
}

 

数组 11/07

1.数组
数组是一个变量，存储相同数据类型的组数据
变量：声明一个变量就是在内存空间划出一块合适的空间
数组：声明一个数租就是在内存空间划出一串连续的空间

数组基本要素：
标示符： 数组的名称，用于区分不同的数组
数组元素：向数组中存放的数据
元素下标：对数组元素进行编号，从0开始，数组中的每一个
元素都可以通过下标来访问
元素类型：数组元素的数据类型

数组长度固定不变，避免数组越界
数组中的所有元素必须属于相同的数据类型

2.如何使用数组
使用数组： //↓不推荐
1.声明数组 列：int[] a; 数据类型[] 数组名;or 数据类型 数组名[];

一般：数据类型[] 数组名=new 数据类型[数组长度]
2.分配空间 列：a=new int[5]; 数组名=new 数据类型[数组长度];

3.赋值 列：a[0]=8; 数组名[下标值]=8;

4.处理数据 列：a[0]=a[0]*10; 数组名[下标值]=数组名[下标值]*10;//=80

创建数组的方式，声明数组、分配空间、赋值合并完成：
数据类型[] 数组名={值1,值2,...};列：
1.int[] scores = {60,70,80,};
2.int[] scores=new int[]{60,70,80};

scores.length//获取数据的长度，数组的最大下标为：(scores.length-1)

Arrays.sort 11/10
使用Java.util.Arrays类
1.Java.tuil.Arrays包提供了许多工具类
2.Arrays类停工在操作数组的方法、列排序、查询
3.Arrays类的Sort()方法：对数组进行升序排列
列：Arrays.sort(数组名);

复制数组 排序 11/14
数组复制方法
System方法
1、语法
public static void arraycopy {object src
int srcpot
object dest
int destpos
int length}
2、参数
src_原数组
srcpot_原数组中起始的位置
dest_目标数组
destpos_目标数组中起始位置
length_要复制的数组元素的数量

Arrays 方法
1、语法
int[] copyOf (int [] original,int newlength);
2、参数
original_要复制的数组
newlength_要返回的副本长度

 

什么是二维数组
1、二维数组是有一维数组组成的数组
1.二维数组语法
int [][] arrr=new int[2][];
定义了二维数组的长度，但是一维数组长度没有定义，一维数组没有申请内存空间为null

int [][] arr=new[2][3];
定义了一维数组和二维数组的长度，一维数组分配了内存空间，一维数组的长度为3，一维数 组的元素默认为0。
2.二维数组也支持静态初始化：
String [][] arr={{"a","b","c"},{"d","e"}};

选择排序原理
1、将数组中每个元素与第一个元素比较，如果这个元素小于第一个元素则交换着两个元素
2、循环第一条规则，找出最小元素，放于第1个位置
3、经过N-1轮比较完成排序
列：int [] arr={7,4,6,8,1,2,5,3,9,0};
for(int i=0; i<arr.length-1;i++){
for(int j=i+1; j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}

冒泡排序原理
1、逐一比较数组中相邻的两个元素，如果后面的元素小于前面的元素，就交换互相顺序。
2、经过一轮比较，一定有一个最大值的排在最后面的位置。
3、每次比较剩下的元素，经过N-1次表可以实现排序
列：int [] a={7,4,6,8,1,2,5,3,9,0};
for(int i=0; i<a.length-1;i++){
for(int j=0; j<a.length-1-i; j++){
//↑每次循环找到一个最大值，循环次数-1
if(a[j]>a[j+1]){
int s=a[j];
a[j]=a[j+1];
a[j+1]=s;
}
}
}

插入排序原理
1、将数组分为两部分，将后部分的第一张逐一与前部分每一张比较，如果当前元素小，就移动
比较元素
2、找到合理位置插入
列：int[] a = { 7, 4, 6, 8, 1, 2, 5, 3, 9, 0 };
for (int i = 1; i < a.length; i++) {
int temp = a[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (temp < a[j]) {
a[j+1]=a[j];//向后移动元素
}else{
break;
}
}
a[j+1]=temp;//找到合适的位置插入元素
}

列2：int[] a = { 7, 4, 6, 8, 1, 2, 5, 3, 9, 0 };
for (int i = 1; i < a.length; i++) {
int temp = a[i];
int j;
for (j = i - 1; j >= 0 && temp < a[j]; j--) {
a[j + 1] = a[j];// 向后移动元素
}
a[j + 1] = temp;// 找到合适的位置插入元素
}

 

 

类和对象 11/22

一、属性——对象具有的各种特征
1、每个对象的每个属性都拥有特定值
列：张三和李四的年龄、姓名不同

二、方法——对象执行的操作
1、对象：用来描述客观事物的一个实体，有一组属性和方法构成

三、封装
1、对象同事具有属性和方法两项特征
2、对象的属性和方法通常 [被封] 装在一起，共同事物的特性，二者相辅相承，不能分割

四、类
1、
顾客类 |
轿车类 |类是模子，定义对象将会拥有特征（属性）和行为（方法）
......   |

2、类是对象的类型
不同于int类型：具有方法

五、类和对象的关系
1、类是抽象的概念，仅仅是模板
比如说：人
2、对象是一个你能看得到，摸得着的具体实体

六、java是面向对象的语言
1、所有Java程序都以类class为组织单元
2、关键字class定义自定义的数据类型
列：public class HelloWorld //类的基本框架

七、java类模板
1、类将现实世界中的概念模拟到计算器程序中
语法：
public class 类名{
//定义属性部分
属性1的类型 属性1；
属性2的类型 属性2；
...
属性n的类型 属性n；
//定义方法部分
方法1；
方法2；
...
方法m;
}

八、定义类
1、定义一个累的步骤
定义类名—>编写类的属性—>编写类的方法

创建和使用对象 优点 总结 11/23
一、创建和使用对象
1、使用对象的步骤
①创建对象
类名 对象名=new 类名（）；
列：School center=new School();

②引用对象成员：使用“.”进行以下操作
引用类的属性：对象名，属性
列：center.name ="北京中心"：//给name属性赋值

引用类的方法：对象名，方法名（）
列：center.showCenter(); //调用showCenter()方法
二、面向对象（oo）的优点
1、
                      ↙与人类的思维习惯一致↘

                                 面向对象
 
↗信息隐藏，提高了程序→                 ←提高了程序的可重↖
的可维护性和安全性 用性

 

总结
1、对象是用来描述客观事物的一个实体
2、类定义了对象将会拥有的特征（属性）和行为（方法）
3、类是对象的类型，对象是类的实列
4、使用类的步骤：
定义类
使用关键字class
↓
创建类的对象
使用关键字new
↓
使用类的属性和方法
使用"."操作符

 

 

定义类 11/24
一、定义类的方法
1、类的方法定义类的某种行为（或功能）
方法的名称
↑
方法返回值得数据类型←方法的定义→方法的主体

2、定义类的方法
public 返回值类型 方法名（）{
//这里辨析方法的主体
}

二、方法的返回值
1、两种情况
①如果方法具有换回值，方法中必须使用关键之return返回该值，返回值类型
为该返回值的类型
语法：return 表达式； 作用：跳出方法，返回结果
②如果方法没有换回值，返回值类型为void 10:41 2017/1/10

三、方法调用
1、方法是个"黑匣子"，完成某个特定的应用程序功能，并返回结果
2、方法调用：执行方法中包含的语句
语法:对象名.方法名();

三、方法调用小结
1、方法之间允许相互调用，不需要知道方法的具体实现、实现重用、提高效率
情况 举例
Student类的方法a()调用Student public void a(){
类的方法吧b(),直接调用 b(); //调用B（）
}
Student类的方法a()调用Teacher public void a(){
类的方法b（）,先创建类对象，然后 Teachaer t=new Teacher();
使用"."调用 t.b();//调用Teacher类的b()
}

 

成员变量和局部变量 11/28
成员变量和局部变量
1、变量声明的位置决定变量作用域
2、变量作用域确定可在程序中按变量名访问该变量的区域

public class AutoLion{
变量1类型 变量1；
变量2类型 变量2； 成员变量//AutoLion类的方法 其他类的方法
变量3类型 变量3；

public 返回类型 方法1（）{
变量4类型 变量4； 局部变量 // 方法1
}
public 返回类型 方法2（）{
变量5类型 变量5； 局部变量 // 方法2
}
}

区别：
1、作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
2、初始值不同
Java会给成员一个初始值
Java不会给局部变量赋予初始值
注意！
在同一个方法中，不允许有同名局部变量
在不同的方法中，可以有同名局部变量

在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

面向对象的编程（OOP）

 

参数 12/05
定义带参数的方法
<访问修饰符>返回类型<方法名>(<形式参数列表>){
//方法的主体
} //形参

调用带参数的方法
对象名.方法名（参数1，参数2，....，参数N）//实参

 

包命名规范 12/07

包命名规范
1、包名由小写字母组成，不能以圆点开头或结尾
2、包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
3、包名后续部分以不同机构内部的规范不同而不同
列：package com.baidu.game.mypackage
                    ↑域名 ↑部门名 ↑项目名

如何导入包
为了使用不在同一包中的类，需要在java程序中使用import关键字导入这个类
Ctrl+Shift+o导包快捷键

import 包名.类名;列：import java.util.*;//导入所有

 

字符串 12/08
使用String对象存储字符串
String s="Hello world";
String s=new String();
String s=new String("Hello world");

String类包位于java.lang包中，具有丰富的方法
计算字符串的长度、比较字符串、连接字符串、提取字符串。

String类提供了length()方法，确定字符串的长度。
数组的length是属性
String的length()是方法
String类提供了equals()方法，比较存储在两个字符串对象的内容是否一致

==和eqauls()区别
==：判断两个字符串在内存中的首地址，即判断是否是同一个字符的对象

登录时不考虑用户名的大小写问题，实现登录
使用equalslgnoreCase()方法//忽略大小写
使用toLowerCase()方法//全部转换小写
使用toUpperCase()方法//全部转换大写

 

 

12/09
字符串连接
1、‘+’号连接
2、使用concat()方法连接
列：String a="Hello"，b="word";
c=a.concat(b);
System.out.print(c);
输出为：Hello world

字符串常用提取方法
常用提取方法
public int indexOf(int ch) 丨搜索第一个出现的字符ch
public int indexOf(String value) 丨（或字符串value）

public int lastIndexOf(int ch) 丨搜索最后一个出现的字符ch
public int lastIndexOf(String value)丨（或字符串value）

 

12/12
字符串常用提取方法
public String substring(int index)
提取从位置索引开始的字符串部分

public String substring(int beginindex,int endindex)
提取beginindex和endindex之间的字符串部分

public String trim()
返回一个前后不含任何空格调用字符串的副本

beginindex：字符串的位置从0开始算；endindex：字符串的位置从1开始算

字符串拆分
String类提供了split()方法，将一个字符串分割为子字符串，
结果作为字符串数组返回

 

12/13
总结
String类提供了大量的操作字符串的方法
获得字符串的长度：length()
比较字符串：equals()
连接字符串：concat()
提取字符串：substring()
搜索字符串：indexOf() or lastindexOf()
拆分字符串：split()
常用的StringBuffer类提供的方法
转换成String类型：toString()
连接字符串：append()
插入字符串：insert()

String Buffer：String增强版
对字符串平凡修改（如字符串连接）时，使用StringBuffer类
可以大大提高程序执行效率

StringBuffer声明
StringBuffer sb=new StringBuffer();
StringBuffer sb=new StringBuffer{"a","b"};

StringBuffer的使用
sb.toString(); //转化为String类型
sb.append("a"); //追加字符串
sb.insert(1."a");//插入字符串