java基础

初识java

1，java中的注释
// 单行注释
/* / 多行注释
/* */文档注释
注释的作 2编译命令（编译完成之后会生成A.class字节码文件）
2，再运行
对class字节码文件进行执行
java A
2，转义符
\n 换行符
\t 制表符
" 使"失去原来的意义，只作为存字符打印输出

3，java代码的编写规范
1，类名首字母大写，采用驼峰命名法
例如，HelloWorld,UserName
2，代码要缩进
每对大括号里面的代码要缩进
3，单词要写对，区别大小写
4，小括号，大括号，中括号要成对出现
5，一行只写一条语句

02变量，数据类型，运算符

java：一门面向对象的计算机高级语言

程序：为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合

JDK:
配置环境变量：

第一个java程序

public class HelloWorld{
public static void main(String[] args){
//指令集合，代码块
}
}
System.out.println("");
转义符
\n \t

变量：

计算机的硬件：硬盘，cpu，显卡（显存），内存
1TB=1024GB
1GB=1024MB
1MB=1024KB
1KB=1024Byte 字节
1Byte=8bit 位

1个汉子2字节
内存单位：内存中存储数据的大小

内存是如何存放数据？

变量：可以变化的量
在内存中用来存储数据的空间，该空间中的值可以改变。
变量的定义：
int a ;
a = 1;

int a = 1;

int a,b,c;
a=1;
b=2;
c=3;

int a = 1,b=2,c=3;

在银行存1000元钱，银行一年的利息5%，一年之后钱变成了多少？

int money = 1000;
money = money*5%;

int a = 1;
int b = 1;

二进制 0-1 满2进1
八进制 0-7
十进制 0-9 满10进1
十六进制的数 0-9 A-F

十进制	二进制	十六进制
1	1
2	10
3	11
4	100

10		10
11		A

内存地址：一串16进制的数表示的。

数据类型
基本数据类型（8种）

	整数类型	byte short int long
	小数类型	double float
	字符类型	char
	布尔类型	boolean

引用数据类型（对象类型）
	String 

​
​ byte 字节 1byte -128 - 127
​ short 短整型 2byte -32768 - 32767
​ int 整型 4byte -2147483648 - 2147483647
​ long 长整型 8byte
-9223372036854775808
9223372036854775807
​ float 单精度浮点型 4byte 有效的小数点位数8
​ double 双精度浮点型 8byte 有效的小数点位数16
​ char 字符型 2byte 只能存一个字符（汉字还是英文）,单引号，
​ boolean 布尔类型 1byte true/false

数据类型的相互转换 (原则，是相似的数据)
1，整数转小数
double 转 int 要强制转换
double a = 1.2;
int b = (int)a;
2，小数转整数
自动转换
int a = 1;
double b = a; // a = 1.0

3，整数之间
4，小数之间
5，字符和整数
	
	字符转换后的整数（ASCII码值）
	'a'	-	97
	'A'	-	65
	'0'	-	48

03变量，数据类型，运算符（二）

1，变量
概念：在内存中用于存储数据的空间，该空间的值可以改变。
空间大小 数据大小
空间类型 数据类型
空间内容 值
空间名称 变量名

定义变量：
	1,先定义，再赋值  int a ; a = 1;
	2,定义的同时赋值  int a = 1;
	3,可以同时定义多个变量

变量的区分	
	局部变量：写在方法中，必须先赋值才可以使用。
变量的注意事项：
	变量名的命名规则
	首字母必须是 ，字母，_,$开头，而且首字母小写

2，数据类型
基本数据类型
整数：byte short int long
小数：float double
字符：char
布尔：boolean
引用数据类型
对象：String Scanner

数据类型之间的转换：
	自动转换
	强制转换
String str = "12";
int a = Integer.parseInt(str);

3，Scanner 类：扫描仪
作用：接收用户从键盘输入的数据
使用：
1，找到扫描仪的位置
import java.util.Scanner;
2，创建新的扫描仪
Scanner input= new Scanner(System.in);

	3，使用扫描仪（扫描仪具备的功能）
	input.nextInt();
	input.nextFloat();
	input.next();

4，运算符
1，赋值运算符 = += -= *= /= %=
将右边的值赋给左边的变量
右边可以是表达式
左边必须是一个变量

	 int a =1;
	a+=1; // a = a+1;

2，算术运算符
	+ - * / % ++ -- 

	+号：1,两边都是整数则相加
	         2,有一边是字符串则拼接（拼接完之后还是字符串）
	
	++ : 自增1
	--   ：自减1

	++ 在前： ++a;  先自增1，再运算
	++在后：a++ ；先运算，再自增1

3，比较运算符
	> >= < <= == !=
	比较两边的表达式（也可能是数值，变量），结果是boolean类型

​
​ 4，逻辑运算符(返回的结果是boolean类型)
​ 对布尔类型进行判断
​ 逻辑与 && 有一个为假即为假
​ 逻辑或 || 有一个为真即为真
​ 逻辑非 ! 取反

运算符
一元运算符 a+=1
二元运算符 a = 1+1;
三元运算符 a = 1>2?1:0;

04条件结构

选择结构
数据类型，变量，运算符

变量：
数据类型 变量名 = 值;
数据类型：
八种基本数据类型+引用数据类型
byte short int long
char
double float
boolean
在java中除了八种基本数据类型，其他的都是引用数据类型
String Scanner Random

运算符
赋值运算符
=

算术运算符
	+
	/ 求商 % 求余数 ++  --
逻辑运算符 (对boolean类型进行运算得到也是boolean)
	&& 	|| 	!
	&	|	!

	false&&....
	true|
比较运算符 
	对两边的表达式进行比较，返回的是boolean类型

选择结构：
单if结构
if(条件){
代码块
}
if else

if(条件){
	条件为真执行此代码块
}else{
	条件为假执行此代码块
}

多重if
if(){

}else if(){

}else if(){

}else{

}	

随机数：
int random=(int)(Math.random()*10);

05条件结构（二）

选择结构
1，单if结构
if(条件){
//代码块
}
注：如果代码块只有一行代码，则大括号可以省略
2，if else 结构
if(条件){

}else{
	
}
3，多重if
if(){
}else if(){
}else if(){
}...else{

}
注：最后一个else可以省略
4，switch选择结构

switch(变量){
	case 常量：
		代码块；
		break;
	default:
		
}
注：
1，不要忘记写break;
	如果不写break，则会继续往下执行。
2，case 后的常量值不s能重复。
3，default块顺序可以变动，但要注意其执行顺序。通常，default块放在末尾，也可以省略

06循环结构（一）

循环结构
循环：重复做某一件相同或相似的事情。

跑圈

while循环
语法
while(1==1){
//循环体
//条件为真进入循环体
}

a;
while(b){
	c;
}
d;
           |<------------|
a-->判断b--true-->c
           |false
          d
循环的三个要素：
	1，要定义一个循环变量
	2，要有循环结束条件
	3，循环变量的累加

特点：先判断，再执行。有可能一次都不会运行

07循环结构（二）

变量，数据类型，运算符
编写程序的基础

程序中的流程判断
选择结构
循环
int a =1 ; 循环变量的初始化
while(a<100){ 循环终止条件
循环变量的改变
}

特点：先判断，再执行。有可能一次都不会执行。
int a =1 ; 循环变量的初始化
do{
	循环变量的改变
}while(a<100);循环终止条件
特点：先执行，再判断。至少执行一遍。

a;
do{
b;
}(条件);
c
|<---------|
a–>b–条件–true–b
|false
c

08循环结构（三）

break； 打断，跳出
break：改变程序控制流
用于do-while、while、for中时，可跳出循环而执行循环后面的语句

continue; 继续
break：改变程序控制流
结束本次循环，继续下一次循环

10数组

数组+循环

变量：在内存中存储数据的空间。
该空间在内存的顺序是杂乱无章的。

数组：一组数据，在内存中存储数据的多个空间。
该空间在内存中的顺序是连续的。
数组是一个变量，存储相同数据类型的一组数据

为什么需要数组
可以定义一个变量 存储多个数据。数据类型必须是相同的。

数组的定义
int arr[] = new int[3];
int[] arr = new int[3]

数据类型[]  数组名 = new 数据类型[数组的长度]

数组新建之后是有默认值的
int[] 默认值   	0
double[]		0.0
String[]		null
boolean[]		false


给数组赋值：数组定义的连续空间都会有对应的下标，小标从0开始
int[] arr = new int[3]
arr[0] = 1;//给第一个空间赋值
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;//定义数组是没有第四个空间。报错：数组下标越界
		ArrayIndexOutOfBoundsException 

取值
System.out.print(arr[1]);	//取单个数组空间的值
for(int i=0;i<arr.length;i++){ //循环取出数组中的所有值
	System.out.println(arr[i]);
}

int[] arr = new int[10];

数组的长度
arr.lengh	长度的值是数组的最大下标加1

数组的其他定义方式
1，int[] arr = new int[10];
int[] arr；
arr = new int[10];

2，int[] arr = {1,2,3};
	int[] arr ;
	arr = {1,2,3};	错误的

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

数组基本要素
1，int[] 数据类型（元素类型）
2，arr 数组名称（变量名，标识符）
3，{1,2,3}; 值（数组元素）
4，元素下标：下标从0开始。最大下标是长度（arr.length）减1

数组的特点：
1，类型必须一致
int[] arr = new int[2];
arr[0] = “a”; 错误
2，数组一旦定义，长度不可变
int[] arr = new int[2];
arr[2] =1; 错误

数组的排序：
冒泡排序：
选择排序：

11循环结构的进阶

数组：
一个变量存储一组数据（在内存中连续的相同数据类型的空间）

定义：
int[] arr = new int[3];
int[] arr = {1,2,3};
int[] arr = new int[]{1,2,3};

数组的要素

13类和对象

类和对象
计算机语言的编程思想
面向对象
面向过程：

吃饭：食堂–给钱–吃饭

做饭：买菜...做菜...吃饭....洗碗。  过程

接受输入的数
Scanner input = new Scanner(System.in);// 帮我们接受值的对象
input.nextInt();
Random rand = new Random(); //帮我们生成随机数的对象

生活中的类和对象
对象：万物皆对象，具体的存在（看得见摸得着）
对象具有特征和行为的（对象具有属性和方法）
对象：用来描述客观事物的一个实体，由一组属性和方法构成

类：对存在的对象进行分类，泛指某一类。
	类是模子，定义对象将会拥有的特征（属性）和行为（方法）	

现实生活中是先有对象再有类（将具有相同或相似属性和共同方法的对象抽象成一个类）

对象进行分类的依据：对象的静态特征和动态方法（能力）

猪：我家养的小花猪（花花）
人：807班的未成年男人（周雨）

属性（特征）：（五官，四肢，毛发）
能力：猪不能说话，人能说话

程序中的类和对象
类：class
对象：object

程序中是先有类再有对象
类的定义：
public class A{
	//public 类的访问修饰符
	//class 定义一个类的关键字
	// A 类的名字（首字母大写，驼峰命名法） ChinaPepole
}
类中具有属性和方法
public class Person{

}

类：是虚拟的，不具体的。是一个模板

	模板的作用：规定产品的外观，根据这个模板可以创超出具体的对象。


对象：由类创建出来的，具有该类定义的所有属性和方法，并且要给该属性赋值
语法：
	Person zhangsan = new Person();

14类的无参方法

类和对象

编程思想：面向对象、面向过程
高级计算机语言都是面向对象。

生活中：生活中的分类是为了更好的理解现实社会。
程序中：	
	先有类，再通过类实例化（创建）对象。

	类：将具有相同或相似的一些属性和行为的抽象出来，形成一个类，相当于一个模板。

	人类：姓名，性别，年龄，身高.....
	          说话，直立行走，写程序.....
 
	语法：
	public class Person{
		//特征--属性
		//行为--方法
	}
	类中定义了属性和方法，但是类是一个虚拟的概念，


	对象：通过类实例化出来的对象。它是具体的，它拥有该类定义的所有属性和方法。并且要给该属性赋值。
	
	创建对象的语法：
	类名 对象名 = new 类名();
	Person p1 = new Person();
	给对象的属性赋值
	p1.name = "张三";
	调用对象的方法
	p1.showInfo();


引用数据类型
String str = "1"; 
String str = new String("aaa");

在内存中开辟一块空间用来存放 人类对象

Person p1 = new Person();
类它是一种特殊的数据类型（引用数据类型）

变量：
定义在方法中的变量：局部变量，作用在该方法中。
局部变量没有初始值：需要先赋值再使用。

定义在类中的变量：成员变量，作用在整个类中，相当于全局变量。
		在java中没有全局变量这一说法
	成员变量是有初始值的。

方法：
类的无参方法
	public void methodName(){
		//方法体
	}
	
有返回值的方法
	public String robBall() {
		String ball = "球";
		return ball;
	} 
	该方法返回值的类型为String 
	并且有返回值的方法必须配合 return 一起使用。
	return 返回的值的类型 必须与定义方法的返回值类型一致 2调用有返回值的方法，必须定义一个相应类型的变量来接受

Random rand = new Random();
int a = rand.nextInt();

15类的有参方法

类和对象

类：属性+方法，类相当于模板，这个模板上定义了它的外观和它的能力。

对象：由类实例化出来的具体对象，对象具有类所定义的属性和方法。

类的定义：
public class ClassName{
//定义属性 — 成员变量（相当于全局变量，有初始值）
public String name;

	//定义方法

	//无参无返方法
	public void method1(){

	}

	//无参有返方法
	public String method2(){
		return null;
	}

	//有参有返的方法
	//定义方法时，小括号中的参数（参数列表），叫做形参，可以定义多个，多个之间用逗号隔开
	public String zhazi(String name,int count){

		return count+"\t"+name;
	}
	//调用有参方法时:必须和定义时的参数列表，数量一致，类型一致，顺序一致。
	//调用方式传入的参数叫做实参

​
​ }
​ 任意数据类型：8种基本数据类型+引用数据类型（自定义的类）
​
​ int a= 1;
​ Person p = new Person();
​ p.name = “陈诗涵”;
​ p.height=158;
​ p.weight=“80kg”;

16类的有参方法

方法：

编程思想：OOP–面向对象

做两件事：
1，学会自己写类
2，学习别人写的类

任何对象，都会有属性和方法

类和对象
Person p = new Person();//

public int method(int a){

}

int[] arr = {1,2,3}
arr.length
类是一种特殊的引用数据类型

String[] names = new String[10];

Person[] persons = new Person[];  //对象数组
存person对象



添加姓名（字符串）
保存多个姓名：String[] names = new String[10];
添加客户信息（姓名，年龄，性别....）

客户业务类
	功能：添加姓名
	String[] names = new String[10];
	public void addName(String name){
		for(int i=0;i<names.length;i++){
			if(names[i]==null){
				names[i] = name;
				berak;
			}
		}
	}
	
测试类
	客户业务类  对象 = new 客户业务类();
	对象.addName("张三");
	对象.addName("李四");

17字符串

字符串 （String）
引用数据类型,也是一个类

自定义的类，也是引用数据类型

所有的类都是引用数据类型

数据类型：在内存中存对应的数据

为什么叫引用数据类型

String对象的创建
String str = “Hello World”; //直接赋值
String str = new String(“Hello World”);

String类位于java.lang包中，具有丰富的方法
java.lang包中的类，在使用时不需要导包
属性：

方法：
	length()； 返回字符串的长度
	str = str.trim();//祛除两边的空格
	equals(""); //比较两个字符串的值是否相等
		== 比较的内存地址
	equalsIgnoreCase()；比较字符串时忽略大小
	str.toUpperCase(); //转大写
	str.toLowerCase(); //转小写

	str.indexOf("a");//查找a字符在str字符串中的下标位置
		//从字符串前面开始查找，找到即返回下标，找不到则返回-1
	str.lastIndexOf("a"); 
		//从后面开始查找，找到即返回下标，找不到则返回-1
	indexOf("a", 1); //从下标为1的字符开始查找
	str.charAt(8);  //查找下标所对应的字符

	str.substring(4);//字符串截取，从下标4开始（包括4），截取到最后
	str.substring(4,8);//字符串截取，从下标4开始--到8下标 （包前不包后）
	
	str.split("d"); //根据指定的字符串对字符串进行拆分，返回字符串数组


	String str = "ABC.java1";
	boolean b = str.endsWith(".java");	//true
	boolean b1 = str.startsWith("AB1");	//false

1，转换字符数组
String str = “abcdefg”;
char[] carr = str.toCharArray();
for (int i = 0; i < carr.length; i++) {
System.out.println(carr[i]);
}

18阶段项目

S1: Logic java ,Html5+css3,SqlServer,C# winforms窗体应用程序

Logic java
java:是一门面向对象的计算机编程语言
原来 sun 公司，现在是oracle公司

java版本
	javaSE
	javaEE
	javaME
jdk:
	jvm:java虚拟机
	jre:java运行环境
1，编写就java程序    *.java
2，编译java文件	javac *.java
3，运行		java 

变量：

数据类型
final String a = “a”;//常量 值不可变

int a = 1;
String b = a+"";	

java是面向对象的，万物皆对象
除了基本数据类型，
包装类
int Integer
short Short
byte Byte
char Character

int a 

条件运算符（三元运算符，三目运算符）
int a = 1>2?1:2;

数组的定义：