JDK1.8安装与卸载
1.卸载
-
删除java的安装目录
-
删除JAVA_HOME
-
删除path下关于java的信息
2.安装
-
百度搜索JDK8,找到下载地址
-
同意协议
-
下载电脑对应的版本
-
双击安装JDK
-
记住安装的路径
-
配置环境变量
-
我的电脑-->右击--->属性
-
环境变量-->JAVA_HOME
-
配置path变量
-
-
测试JDK是否安装成功
-
打开cmd(win+R)
-
java -version
-
JavaSE
1.八大基本数据类型
import sun.applet.Main; public class DOY1 { public static void main(String[] args) { //整数类型 int num1=100000000; byte num2=100; short num3=111; long num4=30L;//LANG类型要在数字后面加L表示 //小数:浮点型 float num5=50.1f;//float类型需要在数字后面加F double num6=3.1; //字符 char name = '张'; //布尔值:是非 boolean fu =true; System.out.println(num1); System.out.println(num2); System.out.println(num3); System.out.println(num4); System.out.println(num5); System.out.println(num6); System.out.println(name); System.out.println(fu); } }
-
扩展1:java中的进制表示
//整数扩展 :进制 二进制ob 十进制 八进制0 十六进制0x int i1=10; //十进制 int i2=010;//八进制 int i3=0x10;//十六进制 System.out.println(i1); System.out.println(i2); System.out.println(i3);
-
扩展2:浮点数拓展:银行业务如何表示钱
float:缺点:有限,舍入误差,大约接近却不等于
//最好不要用浮点型
//可以使用数学工具类:BigDecimal
-
强制转换:在变量前面加要转换的类型
public class dou2 { public static void main(String[] args) { char i='a'; char i2='郭'; System.out.println(i); System.out.println((int)i);//强制转换 System.out.println(i2); System.out.println((float)i2);//强制转换 } } 注意点: 1.不能对布尔值进行转换 2.不能把对象类型转换为不相干的类型 3.在把高容量转换为低容量的时候强制转换的时候可能存在内存溢出,或者精度问题 4.低容量转高容量可以自动转换
-
制表符
public class dou2 { public static void main(String[] args) { // char i='a'; char i2='\u0061'; char i3='\u0062'; char i4='\u0063'; System.out.println(i2); System.out.println(i3); System.out.println(i4); System.out.println("张晓静\n小公主");//\n:换行 System.out.println("张晓静\t小笨蛋");//\t制表符 } }
2.变量
1.局部变量 :只可以在代码块中使用,必须声明初始值.
public class Doy2 { public static void main(String[] args) { String name="张晓静"; //局部变量,只可以在当前代码块中使用 System.out.println(name); } static { System.out.println(name); //在其他代码块会预警 } }
2.类变量:同类的出现而出现,同类的消失而消失,定义在方法体外。
public class Doy2 { /* 实例变量:定义在方法体外,从属于对象 方法1:可以在变量前加static修饰符,即可表示当前所属类 */ static String name2="郭晋科@张晓静"; int age=20; public static void main(String[] args) { // Doy2 doy2 = new Doy2(); //方法1:可以通过把对象new出来,获取对象的变量值 System.out.println(name2); } }
public class Doy2 { /* 实例变量:定义在方法体外,从属于对象 方法2:可以不加static修饰符,这个修饰符表示静态的,用过new一个对象来获取其中的类成员 */ String name2="郭晋科@张晓静"; int age=20; public static void main(String[] args) { Doy2 doy2 = new Doy2(); //方法1:可以通过把对象new出来,获取对象的变量值 System.out.println(doy2.name2); } }
3.常量:用final修饰,常量是不允许修改的。
public class Doy2 { static final String name="张晓静"; public static void main(String[] args) { System.out.println(name); } }
3.基本运算符
1.逻辑运算符
package DOY2; public class Demo02 { //二元运算符 public static void main(String[] args) { int a=10; int b=20; int c=30; System.out.println(a+b); System.out.println(a-b); System.out.println(a*b); System.out.println((double)a/b); //这边因为a和b都是int类型的所以除出来的数都会取整,所以需要将其强转为double类型后再做计算 } }
package DOY2; public class Demo03 { public static void main(String[] args) { long a =124123456789L; int b=100; short c=123; byte d=124; System.out.println(a+b+c+d); //如果说这几个不同的数据类型中有long类型的话,那么最后的结果也是long类型 System.out.println(b+c+d);//如果说这几个不同的数据类型中不存在long类型的话最后默认返回都是int类型 System.out.println(c+d); } }
package DOY2; public class Demo04 { public static void main(String[] args) { //关系运算符返回布尔值,用于判断是否为真:true:真false :假 int a=10; int b=20; int c=21; System.out.println(c%a); //这边的%为取c/a得到的余数,java中称为取模 System.out.println(a>b); System.out.println(a<b); System.out.println(a==b); System.out.println(a>=b); System.out.println(a !=b); } }
package DOY2; public class Demo01 { //自增or自减:一元运算符 public static void main(String[] args) { int a=10; int b=a++; //先赋值给b,a再自增 int c=++a; //a先自鞥,再赋值给c System.out.println(a); System.out.println(b); System.out.println(c); //幂运算2^3,像数学中的这种运算我们通常使用java中的工具类来实现:MATH double pow = Math.pow(2, 3); System.out.println(pow); } }
package DOY2; public class Demo05 { public static void main(String[] args) { //逻辑运算符:与(and)或(or),非(取反) boolean a=true; boolean b=false; System.out.println("a&&b:"+(a&&b)); //两个变量都为真,结果为真 System.out.println("a&&b:"+(a||b)); //有一个为真,结果为真 System.out.println("!(a&&b):"+(! a&&b));//取反,如果返回为真结果为假,如果返回为假,结果为真 //短路运算:验证当第一个判断返回为false的时候是否还会之后另外一个判断 int c=5; boolean d=(c<4) &&(c++<4); System.out.println(d); System.out.println(c); } }
2.位运算
package Doy3; public class Demo01 { public static void main(String[] args) { /* 位运算:了解就行,与二进制打交道 A=0011 1100 B=0000 1101 A&B=0000 1100 对两个值的每一位做计算同时满足某个位的值为1,那么这一位就是1,否则就是0 (与) A|B=0011 1101 满足有一个是1,那么的到的值就是1 (或) A^B=0011 0001 两个值中对应的位数相同返回0,不相同返回1 亦或。 ~B=1111 0010 去对应位数相反的值 (取反) */ /* 案例:面试常问,优点,效率高 计算2*8=16位运算是如何就散的 << *2 >> /2 0 的二进制表示是 0000 1 的二进制表示是 0001 2 的二进制表示是 0010 3 的二进制表示是 0011 4 的二进制表示是 0100 5 的二进制表示是 0101 6 的二进制表示是 0110 7 的二进制表示是 0111 8 的二进制表示是 1000 根据位运算<<来实现 */ System.out.println(2<<3);//意思就是先将2转化为二进制,然后再向做异动三位的到的数再转为十进制,意思就等同于2的三次方 } }
3.偷懒符
package Doy3; public class Demo02 { public static void main(String[] args) { int a=100; int b=200; a+=b;//a=a+b; //偷懒方法慎用 b-=a;//b=b-a System.out.println(a); System.out.println(b); } }
4.字符串拼接符
package Doy3; public class Demo03 { //字符串连接符 public static void main(String[] args) { int a=100; int b=200; //得出结论:字符串加前面会把变量进行拼接,如果加在后面,则前面的变量将正常计算 System.out.println( ""+a+b ); System.out.println( a+b+":" ); } }
5.三元运算符
package Doy3; public class Demo04 { //三元运算符 public static void main(String[] args) { //语法:x ? y : z //如果x==true则返回y,否则返回z int a=10000; String zxj =a<100 ? "及格" :"滚蛋"; System.out.println(zxj); } }
4.包机制
包就等同于文件夹,不同的包可以包含不同的文件名称,每个java文件的最上方会显示包名称,包以关键字packages表示
package Doy3; //表示当前的包名 import Doy3.*; //导入这个包中所有的类 public class Demo04 { //三元运算符 public static void main(String[] args) { //语法:x ? y : z //如果x==true则返回y,否则返回z int a=10000; String zxj =a<100 ? "及格" :"滚蛋"; System.out.println(zxj); } }
5.使用Scanner类实现用户交互
1.使用next接收数据
package Doy4; import java.util.Scanner; public class Demo01 { //使用SCanner接收用户数据 public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入数据"); String str=scanner.next();//使用next接收数据的话,只会获取空格之前的字符 System.out.println("当前输入内容为:"+str); scanner.close(); } }
2.使用nextLine接收数据
package Doy4; import java.util.Scanner; public class Demo01 { //使用SCanner接收用户数据 public static void main(String[] args) { Scanner scanner2 = new Scanner(System.in); System.out.println("请输入数据"); String str=scanner2.nextLine(); //使用nextLine接收用户数据的话,则可以获取到回车之前的所有字符 System.out.println("当前输入内容为:"+str); scanner2.close(); } }
3.Scanner进阶
例题1
package Doy4; import java.util.Scanner; public class Demo02 { //Scanner进阶 public static void main(String[] args) { //进阶内容:根据从键盘输入的值来判断输入的类型 int a=0; float b=0.0f; Scanner scanner = new Scanner(System.in); System.out.println("请输入一个整数"); if (scanner.hasNextInt()) { //hasNextInt用于判断输入的数是不是整数 a=scanner.nextInt();//接收传进来的数据 System.out.println("整数数据:"+a); }else { System.out.println("当前输入不为整数"); }; System.out.println("请输入一个小数值"); if (scanner.hasNextFloat()){//hasNextFloat用于判断输入的值是不是小数float类型 b=scanner.nextFloat();//接收传进来的数据 System.out.println("小数值为:"+b); }else { System.out.println("不为小数值"); } scanner.close(); } }
例题2
package Doy4; import java.util.Scanner; public class Demo03 { public static void main(String[] args) { //我们可以输入多个数字,并且每次输入都可以显示当前总共输入的数和以及自动计算平均值 Scanner scanner = new Scanner(System.in); double sun=0; int count=0; System.out.println("请输入你的数字"); //循环判断是否还有输入合法的数字 while (scanner.hasNextDouble()){ double num=scanner.nextDouble(); sun=sun+num; count++; System.out.println("当前输入的数字为:"+num+"当前总数为"+sun+"当前总共输入的数字个数为"+count+"当前平均数为"+(sun/count)); } } }
6.选择结构
1.if单选结构
package Doy05; import java.util.Scanner; public class Demo01 { public static void main(String[] args) { /** * if单选:语法:if (判断条件){执行的代码} */ Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); if (s.equals("张小静")){ //这边的equals方法的作用表示比较字符串是否相等,满足条件才会走代码块,否则跳过当前判断,直接走下面的代码 System.out.println(s); } scanner.close(); } }
2.多选结构
package Doy05; import java.util.Scanner; public class Demo01 { public static void main(String[] args) { /** * if else 双选结构 , * 语法 if (判断条件) { 执行的的代码} * else {这边是不满足if的条件,就会执行这边的内容} */ Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); if (s.equals("张小静")){ //这边的equals方法的作用表示比较字符串是否相等,满足条件才会走代码块,否则跳过当前判断,直接走下面的代码 System.out.println(s); }else { System.out.println("郭晋科"); } scanner.close(); } }
3.多重选择结构
package Doy05; import java.util.Scanner; public class Demo01 { public static void main(String[] args) { /** * if elseif else 多重选择结构 , * 语法 if (判断条件) { 执行的的代码} * else if {这边是不满足if的条件,就会执行这边的内容} * else if {不满足上一个if,继续走到当前判断,不满足的话走下一个if} * else if {} * else {上面的判断都不满足的话,最终执行else中的代码块} */ Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); //这边的equals方法的作用表示比较字符串是否相等,满足条件才会走代码块,否则跳过当前判断,直接走下面的代码 if (s.equals(1)||s.equals(2)||s.equals(3)){ System.out.println("春天来来"); }else if (s.equals(4)||s.equals(5)||s.equals(6)) { System.out.println("夏天来了"); } else if (s.equals(7)||s.equals(8)||s.equals(9)) { System.out.println("秋天来了"); } else if (s.equals(10)||s.equals(11)||s.equals(12)) { System.out.println("冬天来了"); }else { System.out.println("你离开了,再也回不来了"); } scanner.close(); } }
4.if嵌套结构
package Doy05; import java.util.Scanner; public class Demo01 { public static void main(String[] args) { /** * if嵌套结构 * 语法: if (条件){if (条件) {} } * 案例:做一个登录的逻辑,先输入一个账号,判断是否合法,合法的话继续输入密码,否则提示账号不存在,然后判断密码是否合法,合法的话显示登录成功,否则登录失败 * */ Scanner scanner = new Scanner(System.in); System.out.println("请输入账号信息"); String s = scanner.nextLine(); //这边的equals方法的作用表示比较字符串是否相等,满足条件才会走代码块,否则跳过当前判断,直接走下面的代码 if (s.equals("张小静")){ System.out.println("请输入密码"); String p = scanner.nextLine(); if (p.equals("zxj")){ System.out.println("登录成功"); }else { System.out.println("密码错误,请纠正后重新输入"); } }else { System.out.println("账号信息不存在,请先注册"); } scanner.close(); } }
5.switch选择结构
package Doy05; public class Demo02 { public static void main(String[] args) { String zxj ="张小静"; switch (zxj){//括号中接收一个值用做判断下面的层级 case "张小静": System.out.println("老婆你好"); break; //break可选的,当不写的时候也会执行下面的逻辑,如果写的话将终止下面的逻辑 case "1": System.out.println("你是谁"); case "2": System.out.println("你是谁"); case "3": System.out.println("你是谁"); case "4": System.out.println("你是谁"); default: //default相当于else,当上面每一层的case都不满足的话执行:后面的语句 System.out.println("报上名来"); } } }
7.循环结构
1.while循环
package Doy05; public class Demo03 { //while循环,作用:在一定范围内循环,直到不满足为止 public static void main(String[] args) { int a=0; while (a<1000){ System.out.println(a); a++; } } }
2.do while循环
package Doy05; public class Demo03 { // do while循环,作用:先循环do的代码块,再判断while中的范围是否满足, //和wjele的区别就是 do while先执行一次再去看范围是否满足,而while则是先判断,再执行 public static void main(String[] args) { int a=0; int b=0; do { a=a+500; b++; System.out.println(a); System.out.println(b); }while (a<1000); } }
3.for 循环
package Doy06; public class Demo01 { public static void main(String[] args) { /** 初始化/条件/更新 * FOR循环:语法 for (1=0;i<100;i++) */ for (int i = 0; i < 1000; i++) { System.out.println(i); } } }
1.案例1
计算0到1000之间奇数和偶数的和
package Doy06; public class Demo01 { public static void main(String[] args) { /** 初始化/条件/更新 * FOR循环:语法 for (1=0;i<100;i++) */ int js_qty=0; int os_qty=0; for (int i = 0; i < 1000; i++) { if (i%2 !=0){ //判断i能否被2除尽,如果除不尽的话就是奇数 js_qty+=i; //奇数 }else { os_qty+=i; //偶数 } } System.out.println("奇数和未"+js_qty); System.out.println("偶数和未"+os_qty); } }
2.案例2
循环打印出1到1000中能被3整除的数,且,每行显示5个数字
package Doy06; public class Demo02 { public static void main(String[] args) { for (int i = 0; i < 1000; i++) { if (i%3 ==0){ System.out.print(i+"\t"); //这边print(i+"\t")表示不自动换行每个i后面拼一个制表符\t } if (i%(3*5)==0){//判断是否为第5个可以被三整除的数,如果是的话就换行 System.out.println();//println就表示自动换行 } } } }
3.案例3
打印九九乘法表
package Doy06; public class Demo03 { public static void main(String[] args) { //打印99乘法表 for (int j = 1; j <=9 ; j++) {//最外层的循环是循环行数:j=1,那么i<=j,所以第一行只有一条,如果j=2.那么i<=2,就会第二行输出两条,依次类推 for (int i = 1; i <=j ; i++) {//里面的循环是循环列数 System.out.print(i+"*"+j+"="+(i*j)+"\t"); } System.out.println(); } } }
4.案例四
打印等腰三角形
package Doy07; public class Demo01 { public static void main(String[] args) { for (int i = 1; i <=5 ; i++) { for ( int j=5; j>=i; j--){//打印空的倒三角形 System.out.print(" "); } for (int j = 1; j <=i ; j++) {//循环左边正的三角形 System.out.print("*"); } for (int j = 1; j <i ; j++) {//循环右边的正三角形 System.out.print("*"); } System.out.println(); } } }
5.循环终止
1.break详解
package Doy06; public class Demo04 { public static void main(String[] args) { for (int i = 0; i <1000 ; i++) { System.out.println(i); if (i>=500){ break; //这边判断成立的话将终止当前循环,直接跳出循环体外执行下面的逻辑 } } System.out.println("nnn"); } }
2.continue详解
package Doy06; public class Demo04 { public static void main(String[] args) { for (int i = 0; i <10 ; i++) { if (i==5){ continue; //这边判断成立的话跳出当前循环,直接返回循环体最开始的位置进行下一次循环 } System.out.println(i); } System.out.println("nnn"); } }
8.方法
1.方法定义
顾名思义:方法是为了可以更快的做一件事情,比如:max,sum这种在elsx中经常用到的方法就是为了方便计算和统计 注意:方法的唯一特定就是要保持原子性,一个方法不能同时干两件事。 方法分为有参方法和无参方法:清洗请看代码:
package Doy07; public class Demo02 { public static void main(String[] args) { //这里括号中的两个100表示实际参数 int a= add(100,100); //调用add方法 System.out.println(a); SJX(); //调用SJX方法 } //这边定义了一个带有两个参数add的方法,在main方法中进行调用 //这里的a,b表示形式参数 public static int add (int a,int b){//有参方法 return a+b; } public static void SJX(){//这边没有返回值的类型,而是又关键字void代替,说明该方法无需返回值 for (int i = 1; i <=5 ; i++) { for ( int j=5; j>=i; j--){//打印空的倒三角形 System.out.print(" "); } for (int j = 1; j <=i ; j++) {//循环左边正的三角形 System.out.print("*"); } for (int j = 1; j <i ; j++) {//循环右边的正三角形 System.out.print("*"); } System.out.println(); } } }
2.return的用法
return的用法除了返回值以外,还可以终止程序,例如:
package Doy07; public class Demo03 { public static void main(String[] args) { int max=max(10000,1000); System.out.println(max); } public static int max (int num1,int num2){ int retur=0; if (num1==num2){ System.out.println("num1==num2"); return 0; //如果说这边加了return的话,那么系统会在这边终止,返回当前的值 } if (num1>num2){ retur =num1; }else { retur=num2; } return retur; } }
3.方法重载
特点:
方法名一样,
参数类型不同,或者参数个数不同,顺序不同等,
编译器会根据代码定义的参数去匹配具体用哪个方法。
例如:
package Doy07; import java.util.Scanner; public class Demo03 { public static void main(String[] args) { /* int max=max(10000,1000); System.out.println(max); */ Scanner scanner = new Scanner(System.in); System.out.println("请输入您的名字,我们将为您自动查找到您的夫人信息"); String num=scanner.nextLine(); String name= max(num); System.out.println(name); } public static int max (int num1,int num2){//这边方法名为max,两个int参数 int retur=0; if (num1==num2){ System.out.println("num1==num2"); return 0; //如果说这边加了return的话,那么系统会在这边终止,返回当前的值 } if (num1>num2){ retur =num1; }else { retur=num2; } return retur; } public static String max (String lp){//这边方法名为max,参数为String String name=""; if (lp.equals("郭晋科")){ name="您的夫人名为:"+"张小静"; } return name; } }
4.使用命令行传递参数
1.定义main方法:
package Doy07; public class Demo04 { public static void main(String[] args) { for (int i = 0; i <args.length ; i++) { System.out.println("args"+"["+i+"]"+args[i]); } } }
2.在当前文件所在位置打开cmd窗口
1.执行javac命令编译java文件 D:\java\项目管理\基础语法\JAVASE\Doy07>javac Demo04.java 2.使用命令../退回路径至存放包的原始目录 D:\java\项目管理\基础语法\JAVASE\Doy07>cd ../ 3.使用 ‘java 包名.文件名不加后缀 参数 ’格式进行传递参数进行输出结果 D:\java\项目管理\基础语法\JAVASE>java Doy07.Demo04 I LOVE YOU ZHANG XIAO JING args[0]I args[1]LOVE args[2]YOU args[3]ZHANG args[4]XIAO args[5]JING
5.可变参数
特征:一个参数可以传多个值,前提必须是最后一个参数为可变参数格式如下:
package Doy07; public class Demo05 { //可变参数 public static void main(String[] args) { kb(1,2,3,4,5,6); } public static void kb(int ... num){ for (int i = 0; i < num.length ; i++) { System.out.println(num[i]); } }
6.递归
通过不停的调用本身来处理数据,尽量不用,了解就行
package Doy07; public class Demo06 { //递归:通过不停的调用本身的方法来处理数据,慎用 public static void main(String[] args) { System.out.println(ff(4)); } public static int ff (int num){ if (num==1){//首先第一次传进来的时候为4,直接走下面的判断,直到传进来的数为1 return 1; }else { //走到这边的话不停的调用本身方法,如果传进来的是4, // 4 * (4-1) * (4-1-1) * (4-1-1-1),直到传进来的数等于1,就会停止调用,这就是递归 return num*ff(num-1); } } }
9.数组
1.数组的定义
特点:
数据类型的唯一性,长度唯一性,下标由0开始。
代码如下:
package Doy08; public class DeMo01 { public static void main(String[] args) { //数组的定义 int[] num;//1.声明类型为int,数组名为num的数组 num=new int[10];//2.创建一个数组,下标最大为10 //3.为数组内容赋值 num[0]=1; num[1]=2; num[2]=3; num[3]=4; num[4]=5; num[5]=6; num[6]=7; num[7]=8; num[8]=9; num[9]=10; int sum=0; for (int i = 0; i < num.length; i++) {//num.length:获取数组num的长度 sum=sum+num[i];//循环累加计算数组的总长度 } System.out.println(sum); } }
2.栈和堆的讲解
栈(Stack): 栈是一种线性数据结构,它的特点是先进后出(Last In, First Out,LIFO)。 用于存储方法调用的局部变量、方法调用和返回地址等。 在函数调用时,函数的参数和局部变量会被压入栈中,当函数执行完毕后,这些数据会被弹出。 栈的大小是有限的,通常较小。 堆(Heap): 堆是一个用于动态分配内存的区域,它的分配和释放不是由编译器自动管理的,而是由程序员手动管理。 用于存储动态分配的对象,例如通过 new 或 malloc 分配的对象。 堆的大小通常比栈大,并且可以动态地增长。 关于你提到的数组和空间开辟: 在栈上分配的数组是由编译器自动管理的,它的大小在编译时确定,函数的局部变量和数组通常存储在栈上。
3.创建数组的几个方式
package Doy08; public class DeMo02 { public static void main(String[] args) { //数组的几个创建方式 //1.静态初始化:创建+赋值 int[] a={1,2,3,4,5}; System.out.println(a[0]); //2.动态初始化-包含默认初始化:声明的时候定义数组长度,如果没有为数组的某个元素赋值的话默认就是类型的默认值 int[] b =new int[10]; b[1]=5; System.out.println(b[0]); } }
4.数组总结
1.其长度是确定的,数组一旦创建,其大小无法变更 2.其类型必须相同,不允许出现混合类型 3.数组中的类型可以是任何类型 4.数组变量属于引用类型,数组可以看做对象,数组的每个元素可以看做是对象的成员变量,数组本身就是对象,java中的对象是在堆中的,因此无论是原始数据类型还是其他类型,数组本身就是在堆中的。
5.增强for循环
快捷方式:数组名.for
package Doy08; public class DeMo03 { public static void main(String[] args) { int[] arrays={1,2,3,4,5,6}; //增强for循环:没有下标,直接遍历数组所有元素 for (int array : arrays) { System.out.println(array); } } }
6.数组反转
package Doy08; public class DeMo03 { public static void main(String[] args) { int[] arrays={1,2,3,4,5,6}; //先调用arays(反转数组),得到反转后的数组再用array方法依次打印 array(arays(arrays)); } /** * 遍历数组方法 * @param array */ public static void array (int[] array){ for (int i = 0; i <array.length ; i++) { System.out.print(array[i]+"\t"); } } /** * 数组反转 */ public static int[] arays (int[] arays ){ //1.获取传进来数组的长度将其赋给这个变量 int[] ruseult =new int[arays.length]; //反转操作 //循环还是从i开始,j=ruseult.length-1的意思就是将数组反过来循环,先取最后一个下标,依次往前循环 //i <arays.length的意思就是取最大下标的时候结束,比如长度为6,你们她的最大下标就是6-1,每次循环就会更新i递增,j递减 for (int i = 0,j=ruseult.length-1; i <arays.length ; i++,j--) { //原数据1 2 3 4 5 6 //第一次循环i=0,那么j=arays[6-1],取最大下标对应的值就是6 //这边返回的就是 //下标为5的值就是传进来数组最小的下标 ruseult[j]=arays[i]; } //返回所有循环后的数组 return ruseult; } }
7.多维数组
多维数组又称嵌套数组,将许多个数组组合嵌套起来形成的数组,又为下标中的下标
package Doy08; public class DeMo04 { public static void main(String[] args) { //多维数组 //解析:多维数组又称嵌套数组,就是一个数组中的几个元素中的某个元素又是一个数组,案例如下 //多维数组用[][]定义,语法{{},{},{}} int[][] arrays={{1,2},{3,4},{5,6},{7,8},{9,10}}; for (int i = 0; i <arrays.length ; i++) {//首先判断这个最外层的数组包含几个字数组,取下标开始循环, for (int j = 0; j <arrays[i].length ; j++) {//通过取到最外层的下标来获取里面字数组的长度,也是从0开始循环下标 System.out.println(arrays[i][j]); } } } public static void pl (int[] arrays){ for (int i = 0; i <arrays.length ; i++) { System.out.println(arrays[i]); } } }
10.Arrays工具类
Arrays是java中的工具类,里面的一些方法可以拿来直接使用
package Doy08; import java.util.Arrays;//工具类 public class DeMo05 { public static void main(String[] args) { int[] arrays ={1,29,5,34,0,}; // System.out.println(Arrays.toString(arrays)); Arrays.sort(arrays);//sort先对arrays进行升序排序 System.out.print(Arrays.toString(arrays));//然后调用toString方法打印 Arrays.fill(arrays,0);//fill方法是字符串填充,数组名后面加参数 System.out.println(Arrays.toString(arrays)); } }
11.冒泡排序
package Doy08; import java.util.Arrays; public class DeMo06 { //冒泡排序 public static void main(String[] args) { int[] a={12,23,11,0,9,67,2}; int[] sort = sort(a); System.out.println(Arrays.toString(sort)); } public static int [] sort (int[] arrays ){ //最外层循环总共需要循环的轮数 for (int i = 0; i <arrays.length-1 ; i++) { int num; //,每一轮需要循环几次 //举例,如果循环12345,那么比较规则如:1比较2;2比较3.3比较4,4比较5,所以要比较四次 //然后每一轮结束,那么比较的次数就会少1,如:第一次比较出了2最大,那么直接比较2比较3.3比较4,4比较 5,所以要比较四次 //所以每次都需要减去循环的轮数。 // 第一轮 1和2,2和3,3和4,4和5,5个数比较四次 // 第二轮 2和3,3和4,4和5,5个数比较三次,所以这边的范围就需要减去一个轮数 for (int j = 0; j <arrays.length-1-i ; j++) { if (arrays[j+1]>arrays[j]){ //每次循环判断后一个数是否大于前一个数 num=arrays[j]; //利用变量先存储一下前一个数 arrays[j]=arrays[j+1]; //将后一个数赋值给前一个数 arrays[j+1]=num;//将前一个数赋值给后一个数; } } } return arrays; } }
面向对象
1.类与对象的创建及调用
1.创建两个类,一个类定义属性和方法,另一个类用来调用这个类的属性和方法
package Doy09; //属性 public class Demo01 { String name; int age; double sg; public void stout (){ System.out.println("姓名:"+this.name+"\t"+"年龄:"+this.age+"\t"+"身高:"+sg); } }
package Doy09; //调用上面的属性方法 public class Demo02 { public static void main(String[] args) { Demo01 demo01 = new Demo01(); demo01.name="钱多多"; demo01.age=100; demo01.sg=0.1; demo01.stout(); Demo01 demo011 = new Demo01(); demo011.name="张晓静"; demo011.age=100; demo011.sg=1.0; demo011.stout(); } }
2.构造器详解
//一个类即使什么也不写,这个类也会默认存在一个构造器 //构造器的本质就是用来NEW这个类 //构造器的定义:没有返回值,名称与类名一致 //如果存在了有参构造,如果需要调用无参构造的话,类本身需要显示定义,否则会报错 //可以存在多个构造器,这边用到方法重写的特性
package Doy09; //构造器 public class Demo01 { String name; int age; //一个类即使什么也不写,这个类也会默认存在一个构造器 //构造器的本质就是用来NEW这个类 //构造器的定义:没有返回值,名称与类名一致 //如果存在了有参构造,如果需要调用无参构造的话,类本身需要显示定义,否则会报错 //可以存在多个构造器,这边用到方法重写的特性 public Demo01() {//无参构造 } public Demo01(String namne,int age){//有参构造 this.name=namne; this.age=age; } }
package Doy09; //方法 public class Demo02 { public static void main(String[] args) { Demo01 demo01 = new Demo01("张晓静",20); System.out.println(demo01.name+"\t"+demo01.age+"\t"); } }
3.封装
特点:属性变为私有,使用getset调用
好处:提高程序的安全性,包含数据
隐藏代码实现细节
处理非法数据
package Doy09; //封装 public class Demo01 { private String name;//private修饰符表示变量是私有的,只能通过getset来调用 private int age; public Demo01() { } public Demo01(String namne,int age){ this.name=namne; this.age=age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
调用
package Doy09; //方法 public class Demo02 { public static void main(String[] args) { Demo01 demo01 = new Demo01(); demo01.setName("张晓静吃屁屁"); System.out.println(demo01.getName()); } }
4.继承
继承就是拥有被继承类的属性和方法 需要主要只支持一个字类继承一个父类,但是一个父类可以被继承多个子类
父类:
package Doy09; //父类 public class Demo01 { private String name;//private修饰符表示变量是私有的,只能通过getset来调用 private int age; public Demo01() { } public Demo01(String namne,int age){ this.name=namne; this.age=age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
子类
package Doy09; //子类 public class jsc extends Demo01 {//关键字表示extends继承Demo01的所有属性和方法 }
调用子类
package Doy09; //方法 public class Demo02 { public static void main(String[] args) { jsc jsc = new jsc(); jsc.setName("张晓静");//因为jsc这个类继承了Demo01,所以这边可以取到Demo01的所有属性和方法 System.out.println(jsc.getName()); } }
5.SUPER详解
super注意点: 1.super调用父类的构造方法,必须在构造方法的第一个 2.super必须只能出现在子类发方法或者构造方法中 3.super和this不能同时使用构造方法 4.父类如果没有无参构造,子类也不能有无参方法 与this、的区别: 代表对象不同、 this、:本身调用者这个对象 super:代表父类对象的应用 前提: this:没有继承也可以用 super:只能在继承条件下才可以使用 构造方法: this();本类的构造 super()父类的构造
父类:
package Doy09; //父类 public class Demo01 { public String name="我是钱多多的爸爸"; public int age=100; public Demo01() { System.out.println("爸爸的构造器执行了"); } public void add() { System.out.println("钱多多叫了一声"); } }
子类:
package Doy09; //子类 public class jsc extends Demo01 {//关键字表示extends继承Demo01的所有属性和方法 public String name="钱多多生了哇"; public int age=3; public void text (String name){ System.out.println(name); System.out.println(this.name); System.out.println(super.name); } public void add (){ text("钱多多叫了两声"); } public void text (){ add(); this.add();//调用当前类的add方法 super.add();//调用父类的add方法 } public jsc(String name) { this.name = name; } public jsc() { this("小汉堡");//这里的supper是隐藏代码,当程序new子类的无参构造的时候,默认先会执行父类的无参构造方法 System.out.println(this.name); System.out.println("儿子的构造器执行了"); } }
测试类:
package Doy09; // public class Demo02 { public static void main(String[] args) { jsc jsc = new jsc(); // jsc.text("张晓静大汉堡"); // jsc.text(); } }
6.重写
概念: 需要有继承关系,子类重写父类的方法,方法名和参数列表必须相同,方法体不同 为啥需要重新: 因为父类的功能不一定能满足子类,所以需要重新定义
父类
package Doy09; public class B { public void add (){ System.out.println("我是你父亲,你在调用我的方法"); } }
子类
package Doy09; public class A extends B{ @Override public void add() { System.out.println("我是A,我重写了父亲的方法"); } }
测试
package Doy09; public class TEST { public static void main(String[] args) { B a = new A(); a.add(); A a2 = new A(); a2.add(); } } /* 输出结果: 我是A,我重写了父亲的方法 我是A,我重写了父亲的方法 */
7.多态
多态注意事项: 1.多态是针对方法的,属性没有多态 2.父类和子类有联系 3.存在条件:继承关系,父类引用指向子类对象 拓展: 1.static 方法属于类,不属于实例 2.final 常量 3.private方法
package Doy09; public class TEST { public static void main(String[] args) { //A:子类;B:父类 B b = new B(); //像这个对象就是引用父类的方法,所以他只能获取到父类的方法 //这边就用到了多态的性质:父类的引用指向子类的对象 B b1 = new A();//这边是通过new子类,然后返回父类的引用,所以获取到的也是父类的方法 b1.add(); A a2 = new A();//这边的话就是new了子类,因为子类继承父类的所有方法,所以这边既可以取到子类的方法,也可以取到父类的方法 a2.add(); } }
8.instanceof的用法
概念:用于比较两个引用类型是否存在父子继承关系
package Doy10; import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ; import java.sql.SQLOutput; public class text { //案例:使用instanceof区分不同类之间是否存在父子关系 //A父类;B:子类;C:子类 public static void main(String[] args) { Object b = new B(); //利用多态的原理:父类的引用指向子类的实例 if (b instanceof A){ // true Object是所有类的父类,他们之间用instanceof作比较,如果是父子关系,就会返回true System.out.println("我们是父子关系"); }else { System.out.println("我们不是父子关系"); } if (b instanceof B){ //true System.out.println("我们是父子关系"); }else { System.out.println("我们不是父子关系"); } if (b instanceof C){//false System.out.println("我们是父子关系"); }else { System.out.println("我们不是父子关系"); } if (b instanceof String){//false System.out.println("我们是父子关系"); }else { System.out.println("我们不是父子关系"); } } }
9.类型转换
有点:减少重复代码,提供效率,随用随取(向上或向下转型)
1.高转低
父类的引用指向子类的实例,如果需要用子类的方法,需要强制转换为子类类型
package Doy10; public class Text02 { public static void main(String[] args) { //A类型的引用指向B的实例,所有这边只可以取到A的方法 A a = new B(); a.sun();//这是A的方法,如果需要取到B的方法,需要将其转换为B类型 B a1 = (B) a;//转换为类型 a1.add(); /* 你在调用父类中的sun方法 你调用了B的方法 */ } }
2.低转高
如果需要调用父类的方法,需要向上转型,但是会丢失一些子类原有的方法
package Doy10; public class Text03 { public static void main(String[] args) { B b = new B(); b.add(); //调用B本身的方法 A a=b; //低转高无需强转,但是很有可能会丢失本身的方法 a.add(); //这边是报错的 } }
10.抽象类
概念:以abstract修饰
1.抽象类无法被实例NEW,只能通过子类继承的方式重写方法来实现 2.抽象类中可以写普通的方法,普通的类不可以写抽象的方法 3.抽象方法必须在抽象类中
package Doy10; //抽象类 //以abstract修饰 public abstract class C { //抽象方法:只有方法名字,没有方法实现,需要有子类继承这个类,重写抽象类的方法 public abstract void add(); /* 1.抽象类无法被实例NEW,只能通过子类继承的方式重写方法来实现 2.抽象类中可以写普通的方法,普通的类不可以写抽象的方法 3.抽象方法必须在抽象类中 */ }
通过继承抽象类来实现其中的方法
package Doy10; //子类 public class B extends C { @Override public void add() { } }
11.接口的定义与实现
1.约束 2.定义一些方法,让不同的人实现 3.接口不和类一样,类以class修饰,接口以interface修饰。 4.接口不能被实例化,没有构造方法 5.接口中的方法通过实现类中以implements来继承 6.实现类中的方法必须重写接口中的方法,一个实现类可以继承多个接口,以逗号隔开。 代码如下:
1,定义两个接口
package Doy11; public interface UserSersr { void add(); void update(); void delete(); }
package Doy11; public interface UserSeresr { void run(); void orderby(); }
2。通过implements关键字来实现接口中的方法
package Doy11; public class UserSers implements UserSersr, UserSeresr { @Override public void add() { } @Override public void update() { } @Override public void delete() { } @Override public void run() { } @Override public void orderby() { } }
12,异常处理与捕获
待学习;
MySql数据库
1.安装