我的java笔记
■java的数据类型
▶基本数据类型 8个
整型(4个)
byte 字节型 1byte=8bit
用第一个bit位置来记录符号 0：正数；1：负数
数值的范围 -2的7次方2的7次方-1（-128127）
short 16bit
int 32bit
long 64bit
浮点型（2个）
float 32bit
double 64bit
字符型（1个）
char 16bit 2字节 Unicode编码 0-65535
布尔型（1个）
boolean 1bit true false
▶引用数据类型
数组 []
类 class（抽象类 abstract class）
接口 interface
枚举 enum
注解 @interface
▶常量
代表程序运行过程种不能再次改变的值
常量的作用
1.固定的值，代表计算过程种经常用到的值
便于程序计算
圆周率 3.1415....
2.用来代表一个含义
1 2 3 4 分别代表上下左右四个方向
什么样的值算是常量
1.固定不变的值算作常量
1 3.14 ‘a' true
2.特殊的常量
“abc” --> String
String是一个引用数据类型，它的值很特殊，可以简单视作常量
3.自己创建的空间 存储一个值 让他固定起来 不能改变
final int UP=1;
常量池中默认空间大小 32bit--int 64bit--double
▶变量
指的是在程序执行过程中可以改变
变量是一个内存空间（小容器）
变量空间在创建（声明）的时候，必须指定数据类型，变量空间名称
变量空间 里面只能存储一个内容（值 引用）
变量空间内的内容可以改变
创建变量时需要注意命名的问题
命名的规则
字母（大小写敏感） 数字（0-9 不允许开头） 符号（英文符号 _ $） 中文（不推荐）
命名的规约
类名称 首字母大写，如果两个以上的单词，所有首字母都大写
SuperPerson
变量名 首字母小写，如果两个以上的单词，之后的首字母大写
superPerson
遵循驼峰式命名规约
所有名字都需要见名知义（为了增加可读性）
注意：
变量时一个空间，可以只创建空间，里面不存放内容
变量空间创建后时没有默认内容的，是空的
空的变量空间不能拿来使用 产生编译错误
byte x;//声明变量空间
x=1;//变量赋值
float x=4.14F;
long y=2147483648L;//如果超过int的取值范围2147483647
注释
1.单行注释
//
2.多行注释
/*
*/
3.文档注释
/**
*/
变量如何创建/声明
数据类型、变量名称；
int a;
String b;
▶内存结构与执行
类的定义 编译 加载 空间各个区 变量 赋值
栈内存 堆内存 存储区
数据类型之间的转换问题
类型之间的转换问题
1.同种数据类型之间是可以直接赋值操作
2.数据类型不同的而类型之间的赋值 -->转换问题
同种大数据类型之间才能发生转换
基本类型-----基本类型之间可以直接转换（自动、强制）
引用类型-----引用类型之间 可以直接转换（自动、强制--上转 下转）
基本类型-----引用类型之间 不可以直接转换（间接 -- 包装类/封装类）
3.保证大数据类型一直的前提下
基本数据类型--基本数据类型
小数据类型相同
都是整型 都是浮点
byte a=1;int b=a;//自动直接转换就可以
int a=1;byte b=(byte)a;//需要强制类型转换
float x=3.14F;double y=x;//自动直接转化
double x=4.14;float y=(float)x;//强制转换
如果发现强制转换之前的数值比较大，强制转换这件事情是可以做的
但是强制转换后数值会发生变化
小数类型不同
整型--浮点型 比较的是精确程度
任何一个浮点型都可以存放一整型
int a=1;float b=a;//直接转换
float a=1;int b=(int)a；//强制转换
整型--字符型
每一个字符都对应一个Unicode码 a--97
char x='a';int y=x;//自动转换
int x=97;char y=(char)x;//强制的转化
布尔类型
不能和其他基本类型之间发生转化
Java运算符
运算符 用来指明对于操作数的运算方式
按照操作数的数目进行分类
单目 a++
双目 a+b
三目 (a>b)>x:y;
按照运算符的功能来进行分类
算术运算
加 +
减 —
乘 *
除 /
取余 取模 %
自增 ++
自减 --
int x=1;
int y=x++; // x++: x=x+1
x=? y=?
int a=1;
for(int i=1;i<100,i++){
a=a++
}
a=? 1
int m=1;
int n=2;
int sum=m++ + ++n - n-- - --m + n-- - --m;
m=? 0 n=? 1 sum=? 2
赋值运算
= 赋值符号 将=右边的内容存入=左边的变量空间
+=
-=
*=
/=
%=
int x=1;
x++;//x自增了一个 需求让x增加10个
x+=10;//同x=x+10
byte a=1;
a+=2;//3
a=a+2;//编译出错，类型从int转byte会损失
a=(byte)(a+2);//OK
关系运算
>
>=
<
<=
!=
==
(对象instanceof类)
1.区分=和==区别
2.比较运算符的最终结果是什么？
boolean true false
3>2 3>4 3==5
逻辑运算
1.条件1，条件2，条件3
& 逻辑与
| 逻辑或
^ 逻辑异或 前后两个结果不一致
! 逻辑非
&& 短路与
|| 短路或
逻辑运算符前后链接的应该是连个boolean结果
(3>4) & (3>2)
位运算bit
& 按位与
| 按位或
^ 按位异或
~ 按位取反
<< 按位左移 相当于乘2的位移次幂，
>> 按位右移 相当于除2的位移次幂，保留符号位置
>>> 按位右位移（无符号）
进制转换
原码、反码、补码
6 -6
原码：00000110 100000110
反码：00000110 111111001 符号不动，其余取反
补码：00000110 111111010 反码+1
计算机中不管是正数还是负数，存储形式都是以补码来存储的
注意：反码是一种表示形式，取反是一个计算过程（每一个位置取反）
java语法结构(流程控制)
顺序结构
分支结构
单分支 if
-------------------------
import java.util.Scanner;
public class Month{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
System.out.println("请你输入一个月份，我来输出季节");
int mon=input.nextInt();//获取数字
int mon=input.nextLine();//获取字符串
if(mon>=3 & mon<=5){
System.out.println("春天");
}else if(mon>5 & mon<9){
System.out.println("夏天");
}else if(mon>8 & mon<12){
System.out.println("秋天");
}else if(mon==12 | mon==1 | mon==2){
System.out.println("冬天");
}else{
System.out.println("你来自月球8");
}
}
}
-------------------------
import java.util.Scanner;
public class DiceGame{
public static void main(String[] args){
//1.随机摇骰子的过程 随机产生一个骰子点数 1-6整数
//Math--->Scanner(1.import 2.new 3.input.next();)
double value = Math.random();//有范围[0.0-1.0) 0.0----0.99999999
int number = (int)(value*6+1);
//2.让玩家猜测大小 大 小
Scanner input = new Scanner(System.in);
System.out.println("买大买小 买定离手");
String choose = input.nextLine();//帮我们读取输入的文字
//3.比较点数与猜测结果
System.out.println("本次摇出的点数为:"+number);
// (点数1 2 3 同时 小) 或者 (点数4 5 6 同时 大)
// (number<=3 && choose.equals("小")) || (number>3 && choose.equals("大"))
// == equals();区别
// "a"=="b" "a".equals("b");
if((number<=3 && choose.equals("小")) || (number>3 && choose.equals("大"))){
System.out.println("恭喜您 猜对啦");
}else{
System.out.println("对不起 猜错啦 给2块钱");
}
}
}
-----------------------------------
多分支 switch
switch(值){// byte short int char 1.5enum 1.7String
case 值1:
代码1;
[break;] 可有可无
case 值2:
代码2;
default:
代码
}
循环结构
for
while
do...while
--------------------------------------------
for 循环
用于头和尾都知道的循环
模式1：
for(1初始值;2终点判定条件;4变化量){//允许3个条件都放在()内，但是不是必须
3好多好多执行;
}
模式2：
初始值;
for(;终点判定条件;){
好多好多执行;
变化量;
}
while 循环（for循环的变体）
先判断，再执行，条件满足后再执行
用于知道尾的循环
模式：
初始值;
while(终点判定条件){//()内只允许写一个
好多好多执行;
变化量;
}
do...while循环
先执行，后判断，条件不满足至少执行一次
模式：
初始值;
do{
好多好多执行;
}while();
----------------------------------------------
public class TestFor{
public static void main(String[] args){
}
}
----------------------------------------------
public class TestWhile{
public static void main(String[] args){
int i=1;
while(i<=5){
System.out.println(i);
}
}
}
----------------------------------------------
两个重要的关键字
break 中断循环
continue 中断本次循环
循环标记，通过关键字对循环产生影响
----------------------------------
public class Test{
public static void main(String[] args){
OK: for(int i=1;i<=5;i++){ //给循环加标记OK
KO: for(int j=1;j<=5;j++){
if(j==3){
break;//中断循环（推出j的循环）
//continue;//中断j==3时的循环，其他循环继续
//break OK;//停住外面的循环
//continue OK;//
}
System.out.println("this is a test");
}
}
//输出几次 i和j分别时多少
}
}
----------------------------------
1.可读性
起名字规范
代码缩进
多添加注释
2.健壮性
程序严谨
数组(容器)
数组是一组数据类型相同的数据的组合，将这些数据统一的管理起来
数组本身是一个引用数据类型，数组内存储的类型可以是基本类型，也可以是引用类型
特点： a.数组是一个引用数据类型
b.数组是在堆内存中的遗传连续的地址存在
c.堆内存的数组空间长度一旦确定，不能再次发生改变
d.栈内存的变量中存储的是数组的地址引用
e.数组内部存储的类型可以是基本类型也可以是引用类型
f.数组在初始化时必须指定长度
1.数组的定义（声明）
数据类型[] 数组名字;
int[] x;
char[] y;
boolean[] z;
String[] m;
2.数组的赋值（初始化）
静态初始化 -> 有数组的长度、元素内容
int[] array = new int[]{10,20,30,40};
int[] array = {10,20,30,40};
int[] array;
一百行代码
array = new int[]{10,20,30};
动态初始化 -> 有长度、没有元素（不是真的没有，是默认值）
int[] array = new int[5]//5是数组长度 大于0的整数
整数默认值 --- 0
浮点型默认值 --- 0.0
字符型默认值 ---- 0的ascii对应的char
布尔值默认值 ---false
引用数据默认值 ---null
3.数组元素的访问
通过元素在数组中的位置index（索引）来访问
索引时由取值范围【从0开始 -----数组长度-1】
如果数组的索引超出了上述范围
会出现一个运行时异常 ArrayIndexOutOfBoundsException 数组索引越界
4.数组元素的遍历（轮询）
通过循环的方式访问数组的每一个元素
JDK1.5版本 J2SE-->JavaSE
JDK1.5版本后，出现了新特性，增强for循环
正常的for循环
可以通过index直接访问数组的某一个位置，可以存取
for(;;){
}
加强的for循环
没有索引，写法简单，只能取值，没有index索引，找不到元素是哪一个
for(用来接收数组的index变量:要遍历的数组){
}
数组的长度 array.length
----------------------------------
public class TestArray{
public static void main(String[] args){
int[] array = new int[]{10,20,30,40};
//通过元素在数组中的位置index（索引）来访问
//array[index];//index从0开始
//----从数组内取得某一个位置的元素
int value=array[0];
System.out.println(value);
//-----向数组内的某一个位置存入数据
array[3]=400;
//-----数组的异常
int value=array[5];
System.out.println(value);
//异常----编译OK,运行时异常
//ArrayIndexOutOfBoundsException 数组索引越界
//----数组的遍历
//将数组中的每一个元素都拿出来
for(int index=0;index<5;index++){
System.out.println(array[index]);
}
//加强版的for循环
for(int value;array){
System.out.println(value);
}
//----数组动态初始化
int[] array = new int[0];//---可以编译，不能运行
//NegativeArraySizeException
int[] array=new int[5];
array[0]=199;
}
}
------------------------------------
*5.基本类型和引用类型在内存结构上的区别
所有的变量空间都存储在栈内存
变量空间可以存储基本数据累心给，也可以存储引用数据类型
如果变量空间存储的是基本数据类型，存储的是值，一个变量值改变，另一个变量不会跟着改变
如果变量空间存储的是引用数据类型，存储的是引用（地址），一个变量地址对应的值改变，两一个跟着改变
-----------------------------------
public class Date{
public static void main(String[] args){
int a = 10;
int b = a;
b = 100;
System.out.println(a);//?? -->10
int[] x = new int[]{10,20,30};//见到new关键字，相当于在堆内存中申请开辟一块新的空间，空间的地址是连续的，x是空间首地址
int[] y = x;//y里面存了x的值，即地址
y[0] = 100;//引用空间存储的是引用，传递的也是引用，一个改变，另一个也是改变
System.out.println(x[0]);//？？ -> 100
}
}
-------------------------------------------------
练习
0.创建一个数组，用来存储1-100之间的偶数
------------------------------------------------------------------------
public class SaveNum{
public static void main(String[] args){
//1.需要创建一个数组
int[] array=new int[50];
//2.需要将1-100之间的偶数存入数组内
for(int i=0;i<array.length;i++){
array[i]=2*i+2;
}
//查看
for(int value:array){
System.out.println(value);
}
}
}
-------------------------------------------
1.给定两个数组a{1,2,3,4} b{5,6,7,8} 将两个数组内的元素对应位置互换
2.给定一个数组a{1,2,3,4,5,6} 将这个数组中的元素头尾对应互换位置
3.给定一个数组a{1,2,3,4,5,6} 计算数组所有元素的平均值
4.给定一个数组a{1,3,5,7,9,0,2,4,6,8} 找寻数组中的最大值和最小值(极值问题)
5.给定两个数组a{1,2,3} b{4,5} 合并两个数组 (创建一个新的数组5长度)
6.给定一个数组a{1,2,3,9,4,5} 按照数组中的最大值位置 将数组拆分成两个{1,2,3} {4,5}
7.给定一个数组a{1,2,3,0,0,4,5,0,6,0,7} 去掉数组中的0元素 (创建一个新数组 短的 非零元素挑出来)
8.创建一个数组 存储2-100之间的素数(质数)
9.数组元素的排序(冒泡 快速 选择 希尔.....)
10.用户的登录认证(用数组当作小数据库 存值 用户验证)
----------------------------------------------------------------
public class TestArray{
public static void main(String[] args){
//1.给定两个数组a{1,2,3,4} b{5,6,7,8} 将两个数组内的元素对应位置互换
int[] a={1,2,3,4};
int[] b={5,6,7,8};
//方式2:直接交换变量a和b中的数组引用（地址），没有循环，不受长度限制
int[] temp=a;
a=b;
b=temp;
//方式1：交换数组中对应的元素
for(int value:a){
System.out.print(value + ",");
}
System.out.println();
for(int value:b){
System.out.print(value + ",");
}
System.out.println();
for(int i=0;i<a.length;i++){
a[i]=a[i] ^ b[i] ;
b[i]=a[i] ^ b[i] ;
a[i]=a[i] ^ b[i] ;
}
for(int value:a){
System.out.print(value + ",");
}
System.out.println();
for(int value:b){
System.out.print(value + ",");
}
System.out.println();
}
}
---------------------------------------------------------
public class TestArray{
public static void main(String[] args){
//2.给定一个数组a{1,2,3,4,5,6} 将这个数组中的元素头尾对应互换位置
int[] a={1,2,3,4,5,6};
for(int value:a){
System.out.print(value + ",");
}
System.out.println();
for(int i=0;i<a.length/2;i++){
a[i] =a[i] ^ a[a.length-1-i] ;
a[a.length-1-i]=a[i] ^ a[a.length-1-i] ;
a[i] =a[i] ^ a[a.length-1-i] ;
}
for(int value:a){
System.out.print(value + ",");
}
System.out.println();
}
}
---------------------------------------------
public class TestArray{
public static void main(String[] args){
//3.给定一个数组a{1,2,3,4,5,6} 计算数组所有元素的平均值
int[] a={1,2,3,4,5,6};
float sum=0;
for(int value:a){
System.out.print(value + ",");
sum+=value;
}
System.out.println();
System.out.println(sum/a.length);
}
}
----------------------------------------------
public class TestArray{
public static void main(String[] args){
//给定一个数组a{1,3,5,7,9,0,2,4,6,8} 找寻数组中的最大值和最小值(极值问题)
int[] a={1,3,5,7,9,0,2,4,6,8};
int max=a[0];
int min=a[0];
for(int value:a){
System.out.print(value + ",");
if(value>max){
max=value;
}
if(value<min){
min=value;
}
}
System.out.println();
System.out.println(max + " " + min);
}
}
------------------------------------------------------------
public class TestArray{
public static void main(String[] args){
//给定两个数组a{1,2,3} b{4,5} 合并两个数组 (创建一个新的数组5长度)
int[] a={1,2,3};
int[] b={4,5};
int[] c=new int[a.length+b.length];
int i=0;
for(int value:a){
c[i]=value;
i++;
}
for(int value:b){
c[i]=value;
i++;
}
for(int value:c){
System.out.print(value + ",");
}
}
}
-----------------------------------------------
public class TestArray{
public static void main(String[] args){
//给定一个数组a{1,2,3,9,4,5} 按照数组中的最大值位置 将数组拆分成两个{1,2,3} {4,5}
int[] a={1,2,3,9,4,5};
int[] b=new int[3];
int[] c=new int[2];
int max=0;
int maxIndex=0;
for(int i=0;i<a.length;i++){
if(max<a[i]){
maxIndex=i;
max=a[i];
}
}
for(int i=0;i<maxIndex;i++){
b[i]=a[i];
}
for(int i=maxIndex+1;i<a.length;i++){
c[i-maxIndex-1]=a[i];
}
for(int value:b){
System.out.print(value + ",");
}
System.out.println();
for(int value:c){
System.out.print(value + ",");
}
}
}
--------------------------------------------------
多维数组
二维数组
0.数组的概念 特点
1.数组的定义/声明
2.数组的初始化
静态初始化---有长度 有元素
动态初始化---有长度 没有元素(默认值)
3.数组元素的访问
通过元素在数组中的位置----index索引
4.数组元素的遍历/轮询
0.数组特点
数组本身是一个引用类型
声明时必须指定长度 长度一旦确定不能再次发生改变
1.定义/声明
里面存储的类型[] 数组名字;
int[][] array;
2.初始化
静态---有长度 有元素
int[][] array = {{1,2},{3,4,5,6},{7,8,9}};
动态---只有长度 没有元素(默认)
int[][] array =new int[3][2];//3个小数组、每个小数组里面有2个元素
array--->{{x,x},{x,x},{x,x}}---> x默认值0
可能会产生一个运行时异常
NullPointerException
3.元素访问
通过元素在数组中的位置---index
array[i][j]
i控制大数组中 小数组的位置
j控制小数组中 元素的位置
4.遍历轮询
正常 增强for循环 嵌套完成
5.引用类型在内存中的存储结构
二维数组在内存中的存储
int[][] array = new int[3][];
//3表示有3个小数组 int[]
//2表示每一个小数组内有2个元素---->表示小数组的长度
//array[0][0] = 10;
//array[0][1] = 20;
//NullPointerException 空指针异常
----------------------
public class TestArray {
public static void main(String[] args){
/*
int[][] array = new int[3][2];
array[0][0] = 10;
array[0][1] = 20;
array[1] = array[0];
array[0] = new int[4];
array[0][0] = 100;
System.out.println(array[1][0]);//? 10
*/
//二维数组的动态初始化
int[][] array=new int[3][2];
array[0][0]=10;
array[0][1]=20;
array[0][2]=30;//运行时异常ArrayIndexOutOfBoundsException
//子数组初始时不指定
// int[][] array=new int[3][];
// array[0]=new int[2];
// array[0][0]=10;
// array[0][1]=20;
// array[0][2]=30;//空指针异常， 可以
//声明--初始化（静态）
int[][] array=new int[][]{{1,2},{2,3},{4,5,8}};
for(int i=0;i<array.length;i++) {
System.out.println("子数组的id是:" + i);
for(int j=0;j<array[i].length;j++) {
System.out.print(array[i][j] + ",");
}
System.out.println();
}
//增强型for循环
for(int[] arr:array){
for(int v:arr){
System.out.print(v + ",");
}
}
}
}
--------------------------
三维数组
创建一个数组 数组内存储好多个 int[][]
int[][][] array = {{{1,2},{3,4}},{{},{}},{{},{}}};
int[][][] array = new int[3][][];
三个二维数组 每一个里面有两个一维数组 再里面有两个int元素
常见的运行时异常
1.InputMisMatchException 输入类型不匹配
input.nextInt(); 输入一个整数 a
2.ArrayIndexOutOfBoundsException 数组索引越界
静态初始化 int[] array = {10,20};
array[2] 索引超出边界
3.NegativeArraySizeException 数组长度不合法(长度出现负数)
动态初始化 int[] array = new int[-2];
4.NullPointerException 空指针异常
引用为null 还拿来使用就不行啦
int[] array = null;
array[0] = 10;//空元素再拿来用
最容易找到异常 同时也是最难找的
1.模拟班级同学每周换位置
{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
留给大家2. 利用二维数组 实现用户登录认证
String[] 账号 索引对应 int[] 密码
String[][] {{"郑中拓","123"},{"渡一教育","666"},{"Java","888"}}
main方法
public static void main(String[] args){
}
public 访问权限修饰符 公有的
static 特征修饰符 静态的 有且只有一份
void 方法执行完没有返回值 关键字
main 方法名字 主要的
主方法中的args参数 可否传递?
1.主方法不是我们调用的 JVM虚拟机启动的时候 虚拟机调用的
2.主方法里面有args参数 是一个String[]类型 我们是可以传递参数进去 给JVM
面向过程 面向对象---编程思想的区别
类和对象
类-----抽象笼统的概念(人类)
是用来描述很多对象 具有相同的特征(属性)和行为(方法)
对象---类中衍生出来的一个具体的个体(人)
应该与自己的类具有相同的特征和行为
1.需要自己(其他人String Scanner Math)描述一个类Person
2.利用属性或方法 描述类的具体形态
3.创建一个当前类的对象 对象.调用属性 赋值/取值 调用方法 执行一次
=============================================================
类中的方法---->做一件事情
权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常] [{
方法体
}]
权限修饰符 返回值类型 方法名字 (参数列表) {
}
1.无参数无返回值
2.无参数有返回值
3.有参数无返回值
4.有参数有返回值
人类有名字 有年龄 有性别----属性
人类能吃饭 能说话 能学习----方法
可以理解为方法是做了一件事情
可以理解为返回值是这件事情做完了 留下的一个结果
可以理解为参数是做事情之前 必须提供的条件
需求
设计一个方法 用来画星星(控制台输出) 只输出4行 每一行4颗星星
分析 做事情之前是否需要提供条件 不需要
做事情之后是否需要留下结果 不需要
设计一个方法 用来画星星 只输出4行 直角三角形 第一行一颗 第二行两颗 第三行三颗
分析 做事情需要提供条件 不需要
做事情之后是否需要结果 不需要
设计一个方法 用来画星星 直角三角形 不一定画几行?
分析 做事情之前是否需要提供条件? int line
结果 不需要
设计一个方法 用来画星星 直角三角形 (反向) 几行不确定?
分析 是否提供条件？ int line
结果 不需要
设计一个方法 用来画星星 几行不确定 直角三角形(方向也不确定)
分析 是否需要条件? int line boolean f
返回值 不需要
小任务---参数及返回值的设计
0.设计一个方法 用来画星星 倒三角
行数不确定 方向也不确定
1.设计一个方法 用来交换两个数组元素 a{1,2,3,4} b{5,6,7,8}
2.设计一个方法 用来交换一个数组(头尾互换)
3.设计一个方法 用来寻找数组中的极值(最大值 或 最小值)
4.设计一个方法 用来找寻给定的元素是否在数组内存在(Scanner输入一个)
5.设计一个方法 用来合并两个数组
6.设计一个方法 用来将一个数组按照最大值位置拆分
7.设计一个方法 用来去掉数组中的0元素
8.设计一个方法 用来存储给定范围内的素数(2-100)
9.设计一个方法 用来给数组元素排序(冒泡排序算法)
既能升序又能降序
10.设计一个方法 用来实现用户登录认证(二维数组当作小数据库)
形参和实参
形参可以理解为是方法执行时的临时变量空间 x
实参可以理解为是方法调用时传递进去的参数 a
方法调用时会将实参的内容传递给形参
如果内容是基本类型 传递的 是值 形参改变 实参不变
如果内容是引用类型 传递的 是引用 形参改变 实参跟着改变
小任务---参数及返回值的设计
0.设计一个方法 用来画星星 倒三角
行数不确定 方向也不确定
*1.设计一个方法 用来交换两个数组元素 a{1,2,3,4} b{5,6,7,8}
2.设计一个方法 用来交换一个数组(头尾互换)
3.设计一个方法 用来寻找数组中的极值(最大值 或 最小值)
4.设计一个方法 用来找寻给定的元素是否在数组内存在(Scanner输入一个)
5.设计一个方法 用来合并两个数组
6.设计一个方法 用来将一个数组按照最大值位置拆分
7.设计一个方法 用来去掉数组中的0元素
8.设计一个方法 用来存储给定范围内的素数(2-100)
*9.设计一个方法 用来给数组元素排序(冒泡排序算法)
既能升序又能降序
*10.设计一个方法 用来实现用户登录认证(二维数组当作小数据库)
-----------------------------------------------------------------
import java.util.Scanner;
public class Test {
public static void main(String[] args){
//隐藏的过程 加载类
//0.创建一个对象
TestFunctions tf = new TestFunctions();
//实现一个用户的登录认证
//2.用户输入自己登录的账号和密码
Scanner input = new Scanner(System.in);
//3.提示用户输入账号和密码
System.out.println("请输入账号:");
String user = input.nextLine();
System.out.println("请输入密码:");
String password = input.nextLine();
//4.tf对象调用方法 方法执行登录判断
String result = tf.login(user,password);
System.out.println(result);
//冒泡排序算法 (从数组的底端每一次冒出一个值)
// int[] x = new int[]{5,3,4,2,1,8,7,6,9,0,2,3,4,5};
// //调用刚才定义好的排序方法 执行一遍
// tf.orderArray(x,false);
// for(int v:x){
// System.out.println(v);
// }
//找素数
// int[] x = tf.findPrimeNum(100,10);
// for(int v:x){
// System.out.println(v);
// }
//找寻给定元素是否在数组中存在
// int[] x = new int[]{1,2,3,4,5,6};
// String result = tf.isExist(x,14);
// System.out.println(result);
//找寻最大值或最小值
// //1.有一个数组
// int[] array = new int[]{1,3,5,7,9,0,8,6,4,2};
// //2.调用tf中的方法 做事
// int result = tf.findMaxOrMinNum(array,false);//array数组中找寻最大值
// //4.验证一下
// System.out.println("数组中的最大值为:"+result);
//交换数组内部元素
// //1.有一个数组
// int[] x = new int[]{1,2,3,4,5,6,7,8,9};
// //2.利用tf对象调用方法执行操作
// tf.changeArrayElements(x);//x--->array
// //3.验证看一看结果
// for(int v:x){
// System.out.println(v);
// }
}
}
//=========================================
public class TestFunctions {
//*10.设计一个方法 用来实现用户登录认证(二维数组当作小数据库)
// 是否需要条件? 需要提供账号名和密码 需要返回值 登录成功与否的结果
//1.需要有小数据库---存储用户真实的账号和密码
private String[][] userBox = {{"郑中拓","123456"},{"渡一教育","666666"},{"Java","888"}};
public String login(String user,String password){
//4.进行校验
String result = "用户名或密码错误";
for(int i=0;i<userBox.length;i++){
if(userBox[i][0].equals(user)){
if(userBox[i][1].equals(password)){
result = "登录成功";
}
break;
}
}
return result;
}
//9.设计一个方法 给数组进行排序(既能升序又能降序)
// 是否需要提供条件---数组 提供一个排序的规则boolean 返回值---不用
// flag==true升序排列 flag==false降序排列
public void orderArray(int[] array,boolean flag){
for(int i=1;i<array.length;i++){//控制执行的轮次---数组的长度
for(int j=array.length-1;j>=i;j--){//控制比较4次
//什么情况下可以进行元素的互换
// (flag==true && array[j]<array[j-1]) || (flag==false && array[j]>array[j-1])
if((flag==true && array[j]<array[j-1]) || (flag==false && array[j]>array[j-1])){
int temp = array[j];
array[j] = array[j-1];
array[j-1] = temp;
}
}
}
}
//8.设计一个方法 用来存储给定范围内的素数(2-100) 素数在自然数之内
// 是否需要提供条件 begin end 返回值一个装满了素数的数组
public int[] findPrimeNum(int begin,int end){
if(begin<0 || end<0){
System.out.println("素数没有负数 不给你找啦");
return null;//自定义一个异常 认为规定的一种不正常的现象
}
if(begin>=end){
System.out.println("您提供的范围有误 begin应该比end要小");
return null;//自定义一个异常 认为规定的一种不正常的现象
}
//创建一个足够长的数组
int[] array = new int[(end-begin)/2];
int index = 0;//记录新数组的索引变化 同时记录个数
for(int num=begin;num<=end;num++){
boolean b = false;//标记
for(int i=2;i<=num/2;i++){
if(num%i==0){
b = true;
break;
}
}
if(!b){
array[index++] = num;
}
}
//将数组后面的多余的0去掉
int[] primeArray = new int[index];
for(int i=0;i<primeArray.length;i++){
primeArray[i] = array[i];
}
array = null;
return primeArray;
}
//扩展 设计一个方法 将给定的元素插入数组的某一个位置
//7.设计一个方法 用来去掉数组中的0元素
// 需要提供参数一个数组 需要提供删除的元素是什么 返回值 一个新的数组
public int[] removeElementFromArray(int[] array,int element){
//找寻原数组中去掉被删除元素后的长度
int count = 0;//记录非删除元素的个数
for(int i=0;i<array.length;i++){
if(array[i]!=element){
count++;
}
}
//通过找到的count创建一个新数组
int[] newArray = new int[count];
int index = 0;//控制新数组的索引变化
//将原来数组中非删除的元素存入新数组中
for(int i=0;i<array.length;i++){
if(array[i]!=0){
newArray[index++] = array[i];
}
}
//将新数组返回
return newArray;
}
//5.设计一个方法 用来合并两个数组
// 是否需要参数 需要提供两个数组 需要返回一个大的数组
public int[] mergeArray(int[] a,int[] b){
//创建一个新的数组
int[] newArray = new int[a.length+b.length];
//分别将a和b数组的元素存入新数组内
for(int i=0;i<a.length;i++){
newArray[i] = a[i];
}
for(int i=0;i<b.length;i++){
newArray[a.length+i] = b[i];
}
//将新数组返回
return newArray;
}
//6.设计一个方法 用来将一个数组按照最大值位置拆分
// 需要提供一个大的数组 需要返回值二维数组
public int[][] splitArray(int[] array){// 1 2 3 9 4 5
//找寻最大值索引位置
int max = array[0];//记录最大值
int index = 0;//记录最大值的索引位置
for(int i=1;i<array.length;i++){
if(array[i]>max){
max = array[i];
index = i;
}
}
//通过找寻到的index判定数组拆分后的前后长度
int[] newa = new int[index];
int[] newb = new int[array.length-index-1];
//分别将两个小数组填满
for(int i=0;i<newa.length;i++){
newa[i] = array[i];
}
for(int i=0;i<newb.length;i++){
newb[i] = array[(index+1)+i];
}
//将两个新的小数组一起返回
return new int[][]{newa,newb};
}
//4.设计一个方法 用来找寻给定的元素是否在数组内存在(Scanner输入一个)
// 是否需要参数及返回值 需要提供一个数组 需要一个目标元素 返回值告诉你是否找到啦
// 方法设计了返回值类型 就必须给返回值 编译检测的悲观性原则
public String isExist(int[] array,int element){
//循环方式找寻是否存在
String result = "对不起 您要的值在数组中没有";
for(int i=0;i<array.length;i++){
if(array[i]==element){
result = "恭喜您 您要的值在数组中存在";
break;
}
}
return result;
}
//3.设计一个方法 用来寻找数组中的极值(最大值 或 最小值)
// 是否需要参数及返回值 需要提供一个数组 需要提供一个值(最大 最小) 返回值肯定需要一个值
public int findMaxOrMinNum(int[] array,boolean flag){//flag==true最大值 flag==false最小值
//2.找一个变量
int temp = array[0];
//3.利用遍历数组的方式挨个与max比较
for(int i=1;i<array.length;i++){
if(flag && array[i]>temp){//找寻最大值
temp = array[i];
}else if(!flag && array[i]<temp){//找寻最小值
temp = array[i];
}
}
//3.将找到的值返回
return temp;
}
//*2.设计一个方法 用来交换一个数组(头尾互换)
// 是否需要参数及返回值 需要提供一个数组 不需要返回值
public void changeArrayElements(int[] array){
//2.数组内部的元素头尾对应互换
for(int i=0;i<array.length/2;i++){
int temp = array[i];
array[i] = array[array.length-1-i];
array[array.length-1-i] = temp;
}
}
}
命名规则和规约
规则
字母 数字 符号 中文
字母 区分大小写
数字 不能开头
符号 _ $
中文 不推荐使用
规约
类名字 首字母大写 两个单词以上 每一个首字母都大写
Test TestOne TestOneTwo
属性/方法/变量 驼峰式命名规约 首字母小写 两个单词以上 第二个以后的每一个首字母大写
test testOne testOneTwo
构造方法 与类名一致 类中唯一的大写字母开头的方法
静态常量 全部字母大写 通过_做具体说明 BOOKSTORE_ADMIN
包名 全部字母小写 Java关键字都是小写 注意与关键字不要冲突
所有的名字最好--->见名知意(增强可读性 层次关系缩进 见名知意 注释)
overload---方法重载
方法重载
1.概念：一个类中的一组方法 相同的方法名字 不同的参数列表 这样的一组方法构成了方法重载
参数列表的不同体现在哪里?
参数的个数 参数的类型 参数的顺序
2.作用：为了让使用者便于记忆与调用 只需要记录一个名字 执行不同的操作
3.自己也可以设计方法重载
调用方法的时候 首先通过方法名字定位方法
如果方法名字有一致 可以通过参数的数据类型定位方法
如果没有与传递参数类型一致的方法 可以找一个参数类型可以进行转化(自动)
4.JDK1.5版本之后 出现了一个新的写法
int... x 动态参数列表 类型固定 个数可以动态 0--n都可以
x本质上就是一个数组 有length属性 有[index]
int[]... x int[][] x
动态参数列表的方法 不能 与相同意义的数组类型的方法构成方法重载 本质是一样的
动态参数列表的方法 可以不传参数 相当于0个 数组的方法 必须传递参数
动态参数列表在方法的参数中只能存在一份儿 且必须放置在方法参数的末尾
利用类来描述现实生活中的事情
利用对象去具体的执行操作
类的内部成员Person
2.属性---静态描述类的特征(变量 存值) name
1.方法---动态描述类的行为(做事情) eat
3.构造方法---用来创建当前类的对象(方法 很特殊)
4.程序块(代码块)---理解为就是一个方法(非常特殊的 无修饰符无参数无返回值无名字)
类中的第三个成员
构造方法---做事情
1.作用: 只有一个 构建(构造)当前类的对象
2.写法: 权限修饰符 与类名一致的方法名 (参数列表) [抛出异常]{
一件事情 创建一个对象(当前类Person)
返回对象;
}
3.用法: 通过new关键字调用
4.特点:
1.每一个类都有构造方法，若自己在类中没有定义，系统会默认提供一个无参数的构造方法
若在类中自己定义了构造方法，则默认无参数的构造方法即被覆盖
2.构造方法是否存在方法重载?----存在构造方法重载
5.每一个类都有构造方法
若不定义 系统会默认提供构造方法
为什么要定义构造方法? 什么时候需要设计构造方法?
在创建对象的同时 想要一并做一些事情 默认提供的构造方法是不会做的
这个时候我们可以自己定义构造方法(无参数的构造方法内做事 也可以定义带参数的)
类的第四个成员---程序块(代码块)
1.作用: 跟普通方法一样 做事情的
2.写法: 可以认为程序块是一个 没有修饰符 没有参数 没有返回值 没有名字的特殊方法
{
}
3.用法: 块也需要调用才能执行 我们自己调用不到(没有名字)
每一次我们调用构造方法之前 系统会帮我们自动的调用一次程序块 让他执行一遍
4.特点: 没有什么重载的概念(压根连名字都没有 连参数都没有)
但是可以在类中定义 多个程序块
5.块可以在里面写一些程序 我想要在创建对象之前执行
====================================================================
构造方法中 属性与变量重名 必须需要一个代替词 代替对象
this关键字的使用
1.是一个关键字(指代词) 代替的是某一个对象 (当前调用属性或方法时的那个对象)
2.this既然代替的是一个对象
this可以调用什么? 属性 方法 可以
this可以调用构造方法么? 可以 在一个构造方法内可以调用另一个构造方法
通过this(); 省略了构造方法的名字(必须与类名一致)
必须在另一个构造方法内调用 必须在程序的第一行
构造方法 一般方法 有顺序 认为构造方法早于一般方法
在一般方法内调用构造方法呢？ 不行
构造方法可以重载 构造方法 调用另一个构造方法呢?
3.this调用的过程可以放置在哪个位置写?
调用属性或方法 这一行代码 可以放置在类中的任何成员位置 上下顺序随意
=======================================================================
一个类的描述都学完啦
类中的四个成员
1.属性 -- 静态描述特征(存值)
权限修饰符 [特征修饰符] 属性类型 属性名字 [= 值];
2.方法 -- 动态描述行为(做事情)
权限修饰符 [特征修饰符] 返回值类型 方法名字 ([参数列表]) [抛出异常] [{方法体}]
最主要的是方法设计的参数及返回值问题 传递 调用 执行 内存
3.构造方法 -- 创建当前类对象(做事情 唯一的事情)
权限修饰符 与类名相同的方法名 ([参数列表]) [抛出异常] {方法体}
4.程序块 -- 一个特殊的方法(没名 做事情 不用我们调用 构建对象之前调用)
{方法体}
5.this关键字的使用
用来代替某一个对象
可以调用一般属性或一般方法 放置在任何类成员中
可以调用构造方法 只能放在另一个构造方法内 只能放在程序的第一行
6.类的加载及对象的创建(内存原理 机制)
小任务:
1.设计一个类模拟一个计算器 做什么 加减乘除 方法 计算方法
控制台输出
请输入第一个数
1
请输入符号
+
请输入第二个数
2
3
请输入符号
-
请输入第二个数
2
1
2.设计一个类 替代数组可以做的事情
数组 长度是固定 存储一组元素
长度一旦固定 使用起来不太方便 添加元素 删除元素
设计一个类---充当一个小容器 ArrayBox
能添加元素 获取元素 删除元素 看一看到底有几个
