Java随笔1
1.变量与运算符
命名规则
由26个英文字母大小写，0—9，或$组成数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
基本数据类型
整型: byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
较大值比较
public class test {
public static void main(String[] args) {
int m1 = 10;
int m2 = 30;
int max1 = (m1>m2)?m1:m2;
System.out.println("m1与m2较大值为"+ max1);
}
}
String类
String：字符串。使用一对""表示，内部包含0个、1个或多个字符。
String与8种基本数据类型变量间的运算：+。
运算的结果还是String类型。
int num1 = 10;
boolean b1 = true;
String str4 = "hello";
String str5 = str4 + b1;
String str6 = str4 + b1 + num1;
System.out.println(str5);
System.out.println(str6);
输出结果：
hellotrue
hellotrue10
进制
二进制（以OB、 ob开头）、十进制、八进制（以0开头）、十六进制（以0x或0x开头）的声明方式。
打印位数
int num = 153;
int ge = num % 10; //个位
int shi = num / 10 % 10; //十位.
int bai = num / 100;
System.out.println("个位是: " + ge);
System.out.println("十位是: " + shi);
System.out.println("百位是: " + bai);
2.流程控制
顺序结构
分支语句if-else
if（条件表达式）{
语句块1；
}else {
语句块2；
}
int heartBeats =101;
if (60<= heartBeats &&heartBeats <=100){
System.out.println("你身体很健康");}
else{
System.out.println("你需要进一步检查");
}}}
注： if (60<= heartBeats<=100) 错误
int num=43;
if (num%2==0){
System.out.println(num+"是偶数");
}
else{
System.out.println(num+"是奇数");
}
int x= 4;
int y = 1;
if (x > 2) {
if (y > 2)
System.out.println(x + y);
System.out.println("atguigu");
} else
System.out.println("x is "+ x);
输出结果：atguigu
选择switch-case
public class test4 {
public static void main(String[] args) {
Scanner scan =new Scanner(System.in);
int num = scan.nextInt();
switch(num){
case 0:
System.out.println("zero");
case 1:
System.out.println("one");
case 2:
System.out.println("two");
}
}}
switch(score / 10){
case 0：
case 1:
case 2：
case 3:
case 4:
case 5:
System.out.println（“不及格”）；
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("及格");
break；
default:
System.out.println（“成绩输入有误”）；
break；
循环结构
public static void main(String[] args) {
for (int i=0;i<=10;i++){
System.out.println("Helloword");
}}
int num = 1;
for(System.out.print("a") ;num < 3; System.out.print("c"),num++)
System.out.print("b");
输出结果：abcbc 执行顺序：124324324
遍历1—100以内的偶数，并获取偶数的个数，获取所有的偶数的和
int count=0;
int sum=0;
for (int i=1;i<=100;i++){
if (i%2==0){
System.out.println(i);
count++;
sum=sum+i;
}
System.out.println(count);
System.out.println(sum);}
水仙花数
for (int i=100;i<=999;i++){
int ge=i%10;
int shi=i/10%10;
int bai=i/100;
if (i==ge*ge*ge+shi*shi*shi+bai*bai*bai){
System.out.println(i);
}} 输出：153 370 371 407
最大公约数 最小公倍数
Scanner scan =new Scanner(System.in);
System.out.print("请输入第一个数：");
int m = scan.nextInt();
System.out.print("请输入第二个数：");
int n = scan.nextInt();
//最大公约数
int min=(m<n)?m:n;
for(int i = min;i >= 1;i--){
if(m%i== 0 && n%i== 0) {
System.out.println("最大公约数为:"+i);
break;//一旦执行，就跳出当
}}
//最小公倍数
int max=(m>n)?m:n;
for (int i=max;i<=m*n;i++){
if (i%m==0&&i%n==0){
System.out.println("最小公倍数为:"+i);
break;//一旦执行，就跳出当
}
}
while语句
int i=1;
while (i<=10){
System.out.println("我的世界");
i++;
}
for循环和while循环的小区别：初始化条件的作用域范围不同。while循环中的初始化条件在while循环结束后，依然有效。
//随机生成一个100以内的数，猜这个随机数是多少？
//从键盘输入数，如果大了，提示大了；如果小了，提示小了；如果对了，就不再猜了，并统计一共猜了多少次。
int random= (int)(Math.random()*100)+1;
Scanner scan =new Scanner(System.in);
System.out.println("请输入一个100内的一个整数：");
int guess=scan.nextInt();
int guessCount =1;
while (random!=guess){
if (guess>random){
System.out.println("你输入的数据偏大了");
}
else if (guess<random){
System.out.println("你输入的数据偏小了");
}
System.out.println("请输入一个100内的一个整数：");
guess=scan.nextInt();
guessCount++;
}//能结束循环 意味着相等了
System.out.println("恭喜你猜对了");
System.out.println("您一共猜了"+guessCount+"次！");
scan.close();
double paper =0.1;
double zf =8848860;
int count = 0;
while (paper<=zf){
paper=paper*2;
count++;
}
System.out.println(paper/1000+"折叠次数为"+count);
do-while
无限循环：最简单“无限”循环格式： while（true），for（；；）
随机数
需求：获取一个[a，b]范围的随机整数
(int)(Math.random()*(b - a + 1)+a)
Scanner
导包 import java.util.Scanner
提供（或创建）一个Scanner类的实例
调用Scanner类中的方法，获取指定类型的变量
关闭资源,调用Scanner类的close()
键盘输入代码的四个步骤：
1.导包：import java.util.Scanner；
2.创建Scanner类型的对象: Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法（next（）/nextXxx（） 来获取指定类型的变量
4.释放资源： scan.close（）
import java.util.Scanner;
public class test3 {
public static void main(String[] args) {
Scanner scan =new Scanner(System.in); //调用一次即可
System.out.println("欢迎光临交友网");
System.out.print("请输入你的网名：");
String name = scan.next();
System.out.print("请输入你的年龄：");
int age = scan.nextInt();
System.out.print("请输入你的体重：");
double weight =scan.nextDouble();
System.out.print("你是否单身（单身：true；不单身：false）：");
boolean isSingle =scan.nextBoolean();
System.out.print("请输入你的性别：（男/女）");
char gender = scan.next().charAt(0);
System.out.println("网名: " + name + ",年龄: " + age + ",体重: " + weight + ",是否单身: " + isSingle +
"，性别:" + gender);
System.out.println("注册完成，欢迎继续进入体验！");
scan.close();
}}
IDEA
3.数组
4.面向对象
①基础
赋值传参
地址传参
引用传参
面向对象
构造函数：初始化函数
析构函数：销毁调用的函数
复合数据：存在对于其他复合数据的引用的
面向过程：过程就是操作数据的步骤。如果某个过程的实现代码重复出现，那么就可以把这个过程抽取为一个函数。这样就可以大大简化冗余代码，便于维护。 C语言
面向对象：在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，用类来表示。 Java python
类的内部成员一、二：
成员之一：属性、成员变量、field （字段、域）
成员之二：（成员）方法、函数、method 参考简历
属性
定义变量 ： 数据类型 变量名 = 变量值
调用格式 ： “对象.属性”或“对象.方法”
public static void main(String[] args) {
Phone p1 =new Phone();
p1.name = "lianjunxian";
p1.price =400;
System.out.println("名字是"+p1.name);
System.out.println("名字是"+p1.price);
p1.call();
p1.sendMessage("dffds");
p1.playGame();
}
面向对象完成具体功能的操作的三步流程
步骤1：创建类，并设计类的内部成员（属性、方法）
步骤2：创建类的对象。比如： Phone p1= new Phone（）；
步骤3：通过对象，调用其内部声明的属性或方法，完成相关的功能
类的实例化
等价描述：类的实例化 <=> 创建类的对象 <=> 创建类的实例
格式：类类型 对象名 = 通过new创建的对象实体
举例：
Phone p1 = new Phone();
Scanner scan = new Scanner(System.in);
String str = new String();
对象内存解析
栈（stack）：方法内定义的变量，存储在栈中。
堆（heap） ：new 出来的结构（比如：对象的实体）。包括对象中的属性
方法区（method area） ：存放类的模板，比如：Person类的模板
注：
Person p1 = new Person();
Person p3 = p1;
说明：此时的p1， p3两个变量指向了堆空间中的同一个对象实体。（或p1，p3保存的地址值相同）如果通过其中某一个对象变量修改对象的属性时，会影响另一个对象变量此属性的值。
成员vs局部
不同点：
①类中声明的位置的不同：
属性：声明在类内，方法外的变量
局部变量：声明方法、构造器内部的变量
②在内存中分配的位置不同（难） ：
属性：随着对象的创建，存储在堆空间中。
局部变量：存储在栈空间中
③是否可以有权限修饰符进行修饰：
权限修饰符： public、 protected、缺省、private.
属性：是可以使用权限修饰符进行修饰的。
局部变量：不能使用任何权限修饰符进行修饰的。
④是否有默认值：〔重点）
属性：都有默认初始化值
意味着，如果没有给属性进行显式初始化赋值，则会有默认初始化值。
局部变量：都没有默认初始化值。
意味着，在使用局部变量之前，必须要显式的赋值，否则报错。
方法
方法 是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为 函数 或 过程。
格式：
权限修饰符[其它修饰符] 返回值类型 方法名（形参列表）{ //方法头
//方法体
}
细节：①权限修饰符 private \ 缺省 \ protected \public
②返回值类型
无返回值类型：void 如输出
有具体的返回值类型：需要指明返回的数据的类型。
在方法内部配合使用“return +返回值类型的变量或常量”
注：
Java里的方法`不能独立存在`，所有的方法必须定义在类里。
Java中的方法不调用，不执行。每调用一次，就执行一次。
方法内可以调用本类中的方法或属性。
方法内不能定义方法。return后面不能声明执行语句
对象数组
数组的元素可以是基本数据类型，也可以是引用数据类型。当元素是引用类型中的类时，称为对象数组。
public class StudentTest {
public static void main(String[] args) {
Student[] students = new Student[20];
for (int i = 0; i < students.length; i++) {
students[i]=new Student();
students[i].number=i+1;
students[i].state=(int)(Math.random()*6+1);
students[i].score=(int)(Math.random()*101);
}
for (int i = 0; i < 20; i++) {
System.out.println("学号："+students[i].number+"，年级："+students[i].state +"，成绩："+students[i].score );
}
}
方法重载
方法的重载（overload）
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可。
满足这样特征的多个方法，彼此之间构成方法的重载。
2.总结为：“两同一不同”
两同：同一个类、相同的方法名一 不同：参数列表不同。
编译器如何确定用的某个具体的方法？
先通过方法名确定了一波重载的方法，
进而通过不同的形参列表，确定具体的某一个方法
可变参数
public class ArgsTest{
public static void main(String[] args){
ArgsTest test = new ArgsTest();
test.print();
}
public void print(int ... nums){
System.out.println("1111"); }
基本数据类型的局部变量
赋值操作过的是数据值
引用数据类型的局部变量
赋值操作过来的是地址值，不是简单的数值 例修改arr2,arr1也会变
规则：实参给形参赋值的过程
>如果形参是基本数据类型的变量，则将实参保存的数据值赋给形参。
>如果形参是引用数据类型的变量，则将实参保存的地址值赋给形参。
面试题：Java中的参数传递机制是什么？值传递。（不是引用传递）
交换数组两个变量时
public void swap(int i, int j){
int temp i;
i=j;
j= temp;
以上错误！！！
public void swap(int[] arr, int i, int j){
int temp arr[i];
arr[i] = arr[j];
arr[j] =temp;
import关键字的使用
import:导入
import语句来显式引入指定包下所需要的类。相当于`import语句告诉编译器到哪里去寻找这个类
import语句，声明在包的声明和类的声明之间。
如果需要导入多个类或接口，那么就并列显式多个import语句即可
如果使用`a.*导入结构，表示可以导入a包下的所有的结构。举例：可以使用java.util.*的方式，如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
如果已经导入java.a包下的类，那么如果需要使用a包的子包下的类的话，仍然需要导入。
如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类。例：Date
封装性
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅暴露少量的方法给外部使用，尽量方便外部调用。
所谓封装，就是把客观事物封装成抽象概念的类，并且类可以把自己的数据和方法只向可信的类或者对象开放，向没必要开放的类或者对象隐藏信息。
