Jdk
– 是Java开发的核心.包含了各种开发工具.
– 需要下载,安装和配置…如果有问题,通常是配置的过程出错了.
– JAVA_HOME : 指定jdk的安装位置
– Path : 找打jdk里的bin文件夹,让系统自主调用bin里的各种.exe程序
– 检验: (win+r)执行dos命令.
C:\Users\pc>java -version
java version “1.8.0_241”
Java™ SE Runtime Environment (build 1.8.0_241-b07)
Java HotSpot™ 64-Bit Server VM (build 25.241-b07, mixed mode)
eclipse
– 用来进行java开发的平台.是一个java开发工具.
– eclipse : 免费的
– IDEA : 免费版(commity) 收费版
– Myeclipse : 收费的
– 设置自己的workspace,用来存储java代码
– 有严格的目录结构 : 项目/工程project – 包 – 类
– 创建项目/工程project
–右键-new-other-java project-输入工程名day01-Finish
– 创建包
–选中src-右键-new-package-输入包名cn.tedu.hello-Finish
– 创建类
–选中包-右键-new-Class-输入类名HelloWorld-Finish
,数据类型
–1,标识符
– 由字母,数字,_,$组成
– 不能以数字开头
– 见名知意,严格区分大小写
–2,变量
– 程序中想要记录,一些一直在变的值,就需要定义变量.
– 三要素:变量类型 变量名 = 变量值
–3,数据类型的种类
– 基本类型8种:
byte short int long float double char boolean
– 引用类型: 只要不是8种的基本类型,其他的都是引用类型.
.MAX_VALUE ;//通过.调用功能 最大值
.MIN_VALUE ; //通过.调用功能 最小值
char类型–字符型–面试题:char类型可以存一个中文汉字吗? 可以
//char类型,可以直接存储一个数字本身.但是,本质上还是一个char类型.
//这时,底层会拿着你的数字100 ,去ascii码表里查询对应的字符 ,然后使用字符本身.
//ascii码表里收录了数字0127对应着的字符.12865535对应的默认字符都是?
double r = new Scanner(System.in).nextDouble() ;
动态接收键盘出入的r的值
进制前缀
二进制的数据0b开始 – 0b0011
八进制的数据0开始 – 0567
十六进制的数据0x开始 – 0x0987C
– char类型是\u开始 – \u0000
基本类型的类型转换
–1,小转大 – 隐式转换
–2,大转小-- 显式转换
运算符
–1,算术运算符
+ - * / %(取余数) ++ –
–2,比较运算符:结果是boolean值
== !=
–3,逻辑运算符:结果是boolean值
+ !(取反,非真即假,非假即真)
– &(逻辑与) – 表示并且关系
– 1 & 2 ,想得到最终的结果是true,要求是:1是true并且2是true
– &&(双与/短路与)-- 表示并且关系 --高效
– 1 && 2 ,当1为false时,结果早都注定了是false,2的代码就会被短路不用执行了,提高效率
– |(逻辑或) – 表示或者关系
– 1 | 2 ,想得到最终的结果是true,要求是:1是true或者2是true
– ||(双或/短路或) – 表示或者关系 --高效
– 1 || 2 ,当1为true时,结果早都注定了是true,2的代码就会被短路不用执行了,提高效率
–4,三元运算符
1 ? 2 : 3 —运算结果可能是2,也可能是3.到底是谁?由1决定.
–当1的位置判断成立时,结果就是2
–当1的位置判断不成立时,结果就是3
–5,赋值运算符
=
+= -= *= /= 复合赋值运算符
自增自减++ –
符号在后,先使用再变化
符号在前,先变化再使用
分支结构1：if
–1,用来完成先判断再执行的需求,和顺序结构不同,顺序只是向下执行.
–2,语法
–单分支
if(判断条件){
满足了条件的代码
}
–多分支
if(判断条件){
满足了条件的代码
}else{
不满足了条件的代码
}
–嵌套分支
if(判断条件1){
代码1
}else if(判断条件2){
代码2
}else if(判断条件3){
代码3
}else if(判断条件4){
代码4
}else{
以上4个判断条件都没有满足的代码5
}
分支结构2：switch-----------[了解]
–1,语法
switch(判断条件){
case 0 : sout(0);
case 1 : sout(1);
case 2 : sout(2);
case 3 : sout(3);
default: sout(99);
}
–2,特点
经过判断,从满足的case开始,向后穿透所有case包括default.只有遇到break才会停
循环结构1：for
–1,循环结构用来完成程序中,需要反复执行的一些功能.
–2,for循环语法
for( 开始位置 ; 判断条件 ; 更改条件 ){
循环体;
}
嵌套for循环
–1,语法
for(开始条件;判断条件;更改条件){//外循环
for(开始条件;判断条件;更改条件){//内循环
循环体;
}
}
break和continue
–1,都是用来结束循环的.
–2,break用来简单粗暴的立刻结束.continue结束这次循环还能继续下次.
循环结构2：while – 先判断再执行
–1,语法
while(判断条件){
循环体;
}
循环结构3：do-while – 先执行再判断 – 循环体最少干一次.
–1,语法
do{
循环体;
}while(判断条件) ;
总结
–for --for(开始位置;循环条件;更改条件){循环体}
–while – while(循环条件){循环体}
–do…while – do{循环体}while(循环条件);
–相同点
– 都是用来解决程序中重复干活的需求
–不同点
– for:需要知道开始位置,并且知道要循环多少次,还要知道数据的变化规律
– while/do…while:不需要知道从哪儿开始循环多少次,只需要指定条件就行.
– while – 是要先满足了判断条件才执行
– do…while – 是要最少执行1次循环体
变量
–1,随着变量出现的位置不同,作用和名字都不同.
–2,出现在成员位置(在类里方法外)的变量叫做成员变量–整个类中都有效–不用赋值也有默认值
–3,出现在局部位置(方法里)的变量叫做局部变量–方法里有效–必须手动赋值
–4,变量使用时有一个原则:就近原则
flag的默认值是false,取反,就是true
方法
–1,被命名的代码块，方法可以含参数可以不含参数
–2,语法:
方法的修饰符 方法的返回值 方法名([参数列表…]){ 方法体 }
–3,方法的调用 – 是指调用了指定的方法
方法的调用 – 是指调用了指定的方法
package cn.tedu.method;
//测试方法
public class Test4_Method {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
//1,调用指定方法
method() ;
System.out.println(3);
// function() ;//3,调用指定方法
}
// 方法的修饰符 方法的返回值 方法名([参数列表...]){ 方法体 }
//4,创建function()
public static void function() {
System.out.println("function()...");
}
//2,创建method()
public static void method() {
System.out.println(4);
System.out.println(5);
System.out.println(6);
}
}
方法的参数
package cn.tedu.method;
//测试 方法 传参
public class Test5_Method2 {
public static void main(String[] args) {
//1,调用指定方法求平方
method(10);
//4,求10的5倍的结果
function(10);
//TODO 5, 求 1,2和
add(1,2);
add2("jack",5,10);
add3(5,10,"jack");
}
public static void add3(int a,int b,String c) {
//a+b中 +用来完成加法运算. +c用来拼接字符串.
System.out.println(a+b+c);//15jack
}
public static void add2(String a,int b,int c) {
//+ 在字符串间,用来做拼接
System.out.println(a+b+c);//jack510
}
//TODO 6,创建求和方法
public static void add(int a,int b) {
System.out.println(a+b);
}
//3, 创建 求5倍的方法
public static void function(int x) {
System.out.println(5*x);
}
//2, 创建method(参数类型 参数名) --其中,参数类型必须 匹配!!
public static void method(int a) {
System.out.println(a*a);
}
}
方法的返回值
package cn.tedu.method;
import java.util.Random;
//测试 方法返回值
public class Test6_Method3 {
public static void main(String[] args) {
//1, 调用add方法求和 并把结果返回 交给sum保存
int sum = add(5,10) ;
System.out.println(sum);
int sum2 = add2(1,2,3);
System.out.println(sum2);
String sum3 = add3("jack",1,2);
System.out.println(sum3);//jack12
//TODO random()产生随机整数并返回
int num = random(100);
System.out.println(num);
}
// 修饰符 返回值类型 方法名(参数列表) {}
//创建 random(100);
public static int random(int n){
return new Random().nextInt(n);//产生n以内的随机数并返回
}
//创建add3("jack",1,2);
public static String add3(String a,int b,int c) {
return a+b+c;
}
//创建add2(1,2,3);
public static int add2(int a,int b,int c){
//通过return关键字把结果返回给sum2保存
return a+b+c ;
}
//创建add(5,10) ;
public static int add(int a,int b){
//3,通过return关键字,把结果返回给外界的调用位置
return a+b ;
}
}
方法调用流程
方法的重载Overload
–1,是指在一个类里的现象,存在多个同名的方法,但是,参数列表不同(可以个数相同但是类型不同 ,也可以个数不同)
方法重载Overload – 在一个类里,存在多个同名的方法,但是参数列表不同
//目的:为了体现程序的灵活性,对外提供多个同名方法,方便外界使用
数组
–1,概念
作用就是用来存储多个数据的容器.类似于水杯.英文名称叫Array.标志是[].专门用来存多个 相同类型的 数据
–2,特点
– 数据都有下标
– 下标是从0开始的,下标的最大值是数组的长度-1
– 想要获取数组里的数据,存的是啥? – a[0] a[1] a[2] …
– 数组一旦创建,长度不能改变!!
–3,创建数组 – 数组类型[] 数组名 = new 数组类型[数组的长度] ;
–动态初始化
– int[] a = new int[5];
–静态初始化
– int[] b = new int[]{1,2,3,4,5};
– int[] c = {1,2,3,4,5};
数组的遍历/循环 --下标
for(开始位置;判断条件;更改条件){循环体}
for(从下标为0开始 ; 下标的最大值是<=数组的长度-1;下标++ ){循环体}
数组内存结构图
,数组工具类Arrays
–1,Arrays.toString(数组)–把数组里的数据,拼接成字符串展示
–2,Arrays.sort(数组)–把数组里的数据进行排序,默认是从小到大
–3,Arrays.copyOf(数组，新的长度)–把原数组进行复制
测试
package cn.tedu.array;
import java.util.Arrays;
//测试 数组工具类Arrays
public class Test5_Arrays {
public static void main(String[] args) {
int[] a = new int[] {1,2,3,4,5} ;
method(a);//toString()---用来把数组里的数据变成字符串展示
sortArr();//sort()--可以对无序数组进行排序
copyOfArr();//copyOf()---复制数组
}
//copyOf()---复制数组
public static void copyOfArr() {
//准备原数组
double[] a = {1.1,2.2,3.3,4.4,5.5,6.6};
//开始复制--copyOf(m,n)--m是原数组名称--n是新数组的长度
//当 新数组的长度 > 原数组长度时,会扩充新的位置--相当于扩容
double[] b = Arrays.copyOf(a, 10);
//[1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 0.0, 0.0, 0.0, 0.0]
System.out.println( Arrays.toString(b) );
//当 新数组的长度 < 原数组长度时,会截取前面的一部分数据--相当于缩容
double[] c = Arrays.copyOf(a, 4);
//[1.1, 2.2, 3.3, 4.4]
System.out.println( Arrays.toString(c) );
}
//sort()--可以对无序数组进行排序
public static void sortArr() {
//创建乱序数组
int[] a = {9,12,3,7,10};
//排序
Arrays.sort(a);
//打印数组
System.out.println(a);//数组在内存中的地址值--[I@15db9742
System.out.println( Arrays.toString(a) );//[3, 7, 9, 10, 12]
}
//toString()---用来把数组里的数据变成字符串展示
public static void method(int[] arr) {
//打印数组里的数据
// for (int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]);
// }
// String arrs = Arrays.toString(arr);
// System.out.println(arrs);//[1, 2, 3, 4, 5]
//1,toString()---用来把数组里的数据变成字符串展示
System.out.println( Arrays.toString(arr) );//[1, 2, 3, 4, 5]
}
}
320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
