java基础

第一章:
System.out.println();//ln下一行换行 \n直接换行 \t

程序运行3步骤：
1，编写源程序
2，编译源程序
3，运行

第二章：<<变量>>（内存中的一块存储空间）

8种基本数据类型：
整数
  整数类型  byte   1字节(8位)
       short   2字节(16位)
       int     4字节(32位)
       long    8字节(64位)
  小数类型 flout   4字节(32位)
       bouble  8字节(64位)
  布尔类型 boolean  ture/false
  字符类型 char     2字节（16位）

使用变量的3步骤：
1，声明变量：数据类型 变量名;
2，赋值： 变量名=值;
3, 使用：变量名;

命名规范：
a.赋值运算符：=
b.算术运算符：+ ，-， * ，/；
前++，--（先赋值再运算）;后++，--（先运算再赋值）
c.比较运算符：> ，<， >=， <=， !=， ==；
d.逻辑运算符：&&，||，!；
e.条件运算符（三元运算符）：条件？结果1：结果2；（当条件为真时，得到结果1，否则结果为2）

f.位运算符：（计算机所有二进制都是用补码进行计算）
0111 1111是二进制最大的数；1111是二进制最小的数。
     源码           反码                         补码
正数（3）0000 0011      0000 0011（与源码相同）[二进制的第一位是符号位] 0000 0011（与反码相同）
负数（-3）1000 0011     1111 1100（除符号位不变，其余位数和源码相同）  1111 1101（在反码基础上加1）
计算：3+（-3）
 0000 0011
+1111 1101
 0000 0000
<<:左移，将2进制左移，低位产生空位用0补齐（如何将2用最高效率变成8？答：将2左移2位。(2<<2)==0000 0010--0000 1000）
>>:带符号右移(16<<2:0001 0000--0000 0010)
>>>:无符号右移

运算符优先级：算术>比较>逻辑>赋值>位运算符

数据类型转换：自转（两种类型相互兼容，目标类型精确度大于源类型）强转（目标类型精确度小于源类型。)例子：
double d=0.1;
int a=(int）d;

分解获得各个数： 
int no=12;
int shiwei=no%10/10;

第三章：<<选择结构2>>

产生0——n随机数的语法：
int random=（int）（Math.random(）*n)+1;

流程图：

if(条件1){
   代码块1
}else {
   代码块2
}

嵌套if:
if(条件1){
       if(条件1){
           代码块1
    }else {
         代码块2
    }
}else {
       代码块2
}
多重if：
if(条件1){
   代码块1
}else if(条件2){
   代码块2
}else {
   代码块n
}

第四章：<<选择结构2>>

switch后常量值可以是：int short byte char String 枚举等类型。
case后接：int short byte char String 枚举等类型。

switch(常量值){
 case 值1:
    代码块1
    break;
case 值2:
    代码块1
    break;
case 值3:
    代码块1
    break;
default:
    代码块
    break;
}
switch与多重if区别：
      switch       if
不同  等值判断      区间判断
相同  都用于多重分支条件结构

第五章：<<循环结构>>

循环四要素：
初始值
循环条件：为boolean类型
循环体
迭代变量

while循环（先判断再执行）
while(循环条件){
    循环体
    迭代变量
}
do-while循环（先执行再判断）
do{
    循环体
    迭代变量
}while(循环条件);

程序调试：1.分析错误，设置断点
      2.启动调试，单步执行
      3.观察变量，发现问题

第六章: <<for循环>>

for(初始值;循环条件;迭代变量){
    循环体
}

break：结束整个循环
continue：跳出本次循环进入下一次

3种循环语句比较：
   while循环：先判断再执行
do-while循环：先执行在判断
     for循环：循环次数确定

第8章:<<数组>>

数组:一组相同类型的数据

使用数组4步骤：
1，声明数组：数据类型[] 数组名;
2,分配空间：数组名 = new 数据类型[大小];
数据类型[] 数组名= new 数据类型[大小];
3，赋值：数组名[下标]=值;
4, 使用: 数组名[下标]（数组下标从0开始)

数组排序：Arrays.sort(数组名）；

A.向数组插入元素：

package and;

import java.util.Scanner;

public class test {
    
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int no[]=new int [3];
        no[0]=9;
        no[1]=6;
        int index=no.length;
        System.out.println("请输入要增加的元素：");
        int num=input.nextInt();
        //找到数组插入的位置
        for (int i = 0; i < no.length; i++) {
            if (num>no[i]) {
                index=i;
                break;
            }
        }
        //输出原数组
        System.out.println("原数组元素为：");
        for (int j = 0; j < no.length; j++) {
            System.out.println(no[j]+"\t");
        }
        //元素后移
        for (int i =no.length-1 ; i < index; i--) {
            no[i]=no[i-1];//index下标开始的元素后移
            
        }
        no[index]=num;//插入数据
        System.out.println("插入成绩的下标为："+index);
        System.out.println("插入后的成绩为：");
        for (int i = 0; i < no.length; i++) {
            System.out.println(no[i]+"\t");
        }
   }
}
B.删除数组中的元素：
package and;

import java.util.Scanner;

public class test {
    
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int no[]=new int [3];
        no[0]=9;
        no[1]=6;
        no[2]=3;
        int index=0;
        System.out.println("原数组元素为：");
        for (int j = 0; j < no.length; j++) {
            System.out.println(no[j]+"\t");
        }
        System.out.println("请输入要删除的元素：");
        int del=input.nextInt();
        //找到数组删除的位置
        for (int i = 0; i < no.length; i++) {
            if (del==no[i]) {
                index=i;
                break;
            }
        }
        System.out.println("删除成绩的下标为："+index);
        //输出原数组
        
        
        //元素后移
        for (int i = index; i <no.length-1 ; i++) {
            no[i]=no[i+1];//index下标开始的元素后移
            
        }
        System.out.println("删除后的成绩为：");
        for (int i = 0; i < no.length-1; i++) {
            System.out.println(no[i]+"\t");
        }
   }
}

第九章：<<双重循环>>

for(初始值;循环条件;迭代变量){
    for(初始值;循环条件;迭代变量){
        循环体
    }
}
外层变量变动一次，内存循环执行一遍

打印九九乘法表：
package and;
public class test4 {
    public static void main(String[] args) {
        int rows=9;
        //外层循环控制乘法表行数
        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(j+"*"+i+"="+j*i+" ");
            }
            System.out.println();
        }
            
    }
}

打印菱形
package and;

import java.util.Scanner;

public class test3 {
    public static void main(String[] args) {
                package and;

import java.util.Scanner;

public class test3 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入菱形的行数：");
        int rows=input.nextInt();
        if (rows%2==0) {
            System.out.println("请输入奇数：");
            rows=input.nextInt();
                
        }else{
            //外层循环控制菱形上半部分的行数
            for (int i = 0; i <= rows; i++) {
            //内层循环控制菱形上半部分每行空格个数
                for (int j = 1; j <= rows-i; j++) {
                    System.out.print(" ");
                }
                //内层循环控制菱形上半部分每行*个数
                for (int j = 1; j <= 2*i-1; j++) {
                    System.out.print("*");
                }
            System.out.println();
            }
            //外层循环控制菱形上半部分的行数
            for (int i = 0; i <= rows; i++) {
                //内层循环控制菱形上半部分每行空格个数
                for (int j = 1; j <=i-1; j++) {
                    System.out.print(" ");
                }
                //内层循环控制菱形上半部分每行*个数
                for (int j = 1; j <= 2*(rows-1)-2*(i-1); j++) {
                    System.out.print("*");
                }
            System.out.println();
            }
                    
            
       }
    }
}
       }
    }
}

第十一章：<<类和对象>>

类和对象？
电脑怎么认识这个世界呢？
类：告诉电脑这个世界是什么构成的(分类)
对象：(类别中的具体实体)
面向对象的优点：
1.人类思维一致
2.信息隐藏
3.提高程序可用性

类和对象的关系：
类是对象的抽象，对象是类实例
访问修饰符（public protected private）
    
访问修饰符 class 类名{

    //属性:特征
    //方法:行为或功能
}
方法的调用：
同一类中直接用：方法名（）
不同类中需要创建对象，对象名.方法名（）；

第十二章  <<类的无参方法>>

无参方法：不带条件的行为

访问修饰符 返回值类型 方法名(){
    方法体;
}
返回值类型：void(无返回)  所学过的数据类型(有返回，return "返回值")
类型值必须一致；调用有返回值的方法，必须定义一个变量接收这个返回值
方法的调用：对象名.方法名（）；
成员变量和局部变量的区别？
        成员变量        局部变量
作用域不同    类        方法
初始值不同     有初始值        无初始值

第十三章：<<带参数的方法>>

有参方法：带条件的行为
访问修饰符 返回值类型 方法名(参数列表){ 形参：形容这个方法的条件是什么
    方法体;
}
实参：调用方法时传过去的值
形参和实参：类型一致，个数一致，顺序一致
数组作为参数的方法：（在数组中计算平均值，寻找最大值）
通过创建学生类

package book;

public class Student {
    
    public  double Avg(int []scores){
    int sum=0;
    
    double avg=0.0;
    for(int i=1;i<scores.length;i++){
        sum+=scores[i];
        
    }
    avg=(double)sum/scores.length;
    return avg;
}
    public int Max(int[]scores){
        int max=scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (max<scores[i]) {
                max=scores[i];
            }
        }
        return max;
    }
}
测试类
package book;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        Student s=new Student();
        int []scores=new int[5];
        System.out.println("请输入5位参赛者的成绩：");
        for (int i = 0; i < 5; i++) {
            scores[i]=input.nextInt();
            
        }
        double avg=s.Avg(scores);
        System.out.println("平均成绩为："+avg);
        int max=s.Max(scores);
        System.out.println("平均成绩为："+max);
        
    }
}

对象作为参数的方法：
package book1;

public class Student {
    //形式类
        int id;
        String name;
        int age;
        int score;
        public void show(){
            System.out.println("学号\t姓名\t年龄\t分数");
            System.out.println(id+"\t"+name+"\t"+age+"\t"+score);
}
        
}

//学生管理类
public class StudentBiz {
    Student[] s=new Student[30];
    public void add (Student st){//增加学生
        for (int i = 0; i < s.length; i++) {
            if (s[i]==null) {
                s[i]=st;
                break;
            }
        }
    }
    public void show(){//展示学生信息
        System.out.println("本班学生列表：");
        for (int i = 0; i <s.length; i++) {
            if (s[i]!=null) {
                s[i].show();
        }
        }
        System.out.println();
    }
}

//测试类
     public class Test {
         public static void main(String[] args) {
             Student s1=new Student();
             s1.id=1;
             s1.name="zry";
             s1.age=11;
             s1.score=95;
             Student s2=new Student();
             s2.id=2;
             s2.name="ry";
             s2.age=11;
             s2.score=80;
             StudentBiz stu=new StudentBiz();
             stu.add(s1);
             stu.add(s2);
             stu.show();;
        }
}

包：1.将类分成较小点单元，易于寻找
    2.防止命名冲突
    3.允许更广范围内保护类，数据和方法
声明：package 包名

第十五章：<<字符串>>

A.创建字符串对象：
1.String s=new String ();
2.String s="hello";
3,String s=new String("hello");
B.字符串的长度:
s.length();
C,字符串的比较：
1.s.equals(s1);
==:判断两个字符串对象在内存中的首地址是否相等，判断11是否是同一个字符串
equals():判断两个字符串内容是否相等；
2.s.equalsIgnoreCase(s1):忽略字符串大小写进行比较；
3.s.toLowerCase().equals(s1).toLowerCase():转换为小写字母并且返回小写字母
4.s.toUpperCase().equals(s1).toUpperCase():转换为大写字母并且返回大写字母
D.复杂字符串的处理：
1.字符串的连接：s.concat,(s1);
2.字符串的提取和查询：
public int indexOf(int s):查询第一个出现的字符s
public int lastIndexOf(int s):查询最后一个出现的字符s
public String substring(int index):提取从index字符开始及之后的字符
public String substring(int beginindex,int endindex):提取从index字符开始到endindex之间的字符
public String trim（）；返回不含空格的字符
E.字符串的拆分：s.split(String separator,int limit);
separator:要拆分的字符
 limit:限制返回字符中的元素
F:StringBuffer：String的增强版（不仅可以是字符，还可以是int等类型）
  s.toString();将s转换成String类型并输出
  s.append(s2):在s的后面追加s1的内容；
  s.insert(位置，参数）；将参数插入到s的指定位置并返回；