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

封装性

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅暴露少量的方法给外部使用，尽量方便外部调用。

所谓封装，就是把客观事物封装成抽象概念的类，并且类可以把自己的数据和方法只向可信的类或者对象开放，向没必要开放的类或者对象隐藏信息。