java web(后端＋前端) 学习路线记录（代码＋总结）---1.JavaSE（完成）-前端-CSS教程

java web(后端＋前端) 学习路线记录（代码＋总结）---1.JavaSE（完成）

java学习

资源：狂神说

一、基础语法

1.注释、标识符、关键字

（1）建立空项目来建立java项目：

（2）单行注释：//注释
（3）多行注释：/*
Djandjan
/
（4）文档注释: /* */
2标识符（类名，变量名，方法名）
（5）关键字

（6）标识符注意点：

2.数据类型

（1）要求变量严格符合规范，所有变量先定义后使用（java, c++）
（2）弱类型语言（js,vb）
（3）分类 ①基本类型
②引用类型

    //小数；浮点数
    float num5=50.1F;
    double num6=3.415926;

    //字符
    char name='马';
    //String不是关键字，是一个类
    //String name="秦疆"；

    //布尔值;是非
    boolean flag = true;

3.类型转换

public class Demo3 {
    public static void main(String[] args) {
        //整数拓展：  进制 二进制ob 十进制 八进制o 十六进制ox
        int i =  10;
        int i2 = 010;  //八进制
        int i3 = 0x10; //十六进制
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=================================");


        //浮点数拓展 银行业务怎么表示 BigDecimal 数学工具类
        //float 有限 离散 舍入误差 大约 接近但不相等
        //double
        //最好避免完全使用浮点数进行比较
        float f = 0.1f;    //0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d);
        System.out.println(f);
        System.out.println(d);

        float d1 = 32423423423f;
        float d2 = d1+1;
        System.out.println(d1==d2);


        //字符类拓展
        System.out.println("==============================");
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换
        System.out.println(c2);
        System.out.println((int)c2);//强制换行
        //所有字符本质还是数字
        //编码 Unicode 表：97=a 65=A 2字节 0-65536 Excel
        //U00000-UFFFFF
        char c3 ='\u0061';
        System.out.println(c3);//a

        //转义字符
        // \t 制表符
        // \n 换行
        //.....
        System.out.println("l\tl\nd");

        System.out.println("=========================");
        String sa = new String("dcfs");
        String sb = new String("dcfs");
        System.out.println("sa==sb");

        String sc = "qqqq";
        String sd = "qqqq";
        System.out.println(sc==sd);
        //对象 从内存分析

        //布尔值拓展
        boolean flag = true;
        if(flag==true){}
        if(flag){}//建议精简代码
    }
}

public class Demo4 {
    public static void main(String[] args) {
        int i = 128;
        double b = i;
        byte c = (byte)i;//内存溢出 -128
        //强制类型转换 （类型）变量名 高----低
        //自动转换 低-----高
        System.out.println(i);
        System.out.println(b);
        System.out.println(c);

        /*
        * 注意点：
        *1.不能对布尔值进行转换
        *2.不能吧对象转换成不相干的数据
        *3.把高容量转换成低容量的要强制转换
        *4.转换时会出现内存溢出问题，或者精度问题
        * */
        System.out.println("===============");
        System.out.println((int)23.7);//23
        System.out.println((int)-45.3);//-45

        System.out.println("===============");
        char c1 = 'a';
        int  d1 = c1+1;
        System.out.println((char) d1);


        //操作比较大的数，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int year = 20;
        int total1 = money*year;// -147484163,计算时已经溢出了
        long total2 = money*year; //默认是int,转换之前已经存在问题了

        long total3 = money*((long)year);//先把一个数据转换成Long
        System.out.println(total3);
    }
}

4.变量常量作用域

public class Demo5 {
    //属性：变量

    //常量 修饰符 不存在先后顺序
    static final double PI = 3.14;



    //类变量static
    static double salary = 2500;

    //实例变量：从属于对象;如果不初始化，这个类型的默认值0，0.0
    //布尔值：默认值是false
    //除了基本类型，其余默认值都是null;
    String name;
    int age;


    //main 方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化,局部变量只在方法快里起作用
        int i = 10;
        System.out.println(i);

        //变量类型 变量名字=new Demo5();
        Demo5 demo5 = new Demo5();
        System.out.println(demo5.age);
        System.out.println(salary);

        System.out.println(PI);
    }

    //其他方法
    public void add(){

    }

5.运算符

 int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);
        System.out.println(a*b);
        System.out.println(a-b);
        System.out.println(a/(double)b);//注意运算结果范围

  long a = 12312312312313L;
        int b = 123;
        short c = 8;
        byte d = 8;

        System.out.println(a+b+c+d);//Long
        System.out.println(b+c+d);//Int
        System.out.println(c+(double)d);//Tnt

    int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);

        System.out.println(c%a);//取余 模运算

  int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);

        System.out.println(c%a);//取余 模运算

   //++ --  自增 自减 一元运算符
        int a = 3;

        int b = a++; //"后加加"，先给b赋值，再自增
        // a=a+1;

        System.out.println(a);

        //a=a+1；
        int c = ++a;//“前加加”，先自增，再给b赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算2^3   2*2*2 = 8 使用工具类操作（Math）
        double pow = Math.pow(2, 3);//Math.pow(2,3) Alt+Enter
        System.out.println(pow);

  //与（and） 或(or)  非(and)
        boolean a = true;
        boolean b = false;

        System.out.println("a&&b"+(b&&a));//逻辑与运算：两个变量为真，结果才为true
        System.out.println("a||b"+(a||b));//逻辑或运算：两个变量有一个为真，结果才为true
        System.out.println("!(a&&b)"+(a&&b));//真->假 假->真

        //短路运算 c<4为false ,后面c++不执行
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);//false
        System.out.println(c);//5

    /*
        * A = 0011 1100
        * B = 0000 1101
        * ------------------
        * A&B = 0000 1100
        * A|B = 0011 1101
        * A^B = 0011 0001 相同为0，不同为1
        * ~B = 1111 0010
        *
        * 2*8 = 16 2*2*2*2
        * 增加效率！！！
        * <<   *2
        * <<   /2
        * */

        System.out.println(2<<3);

    int a = 10;
        int b = 20;

        a+=b;//a=a+b
        a-=b;//a=a-b

        System.out.println(a);

        //字符串连接符 + ，String  ""+()=字符串
        System.out.println(""+a+b);
        System.out.println(a+b+"");

  //x ? y : z
        //如果x==true, 则结果为y,否则为z

        int score = 50;
        String type = score < 60 ? "不及格":"及格";
        System.out.println(type);

二、Java流程控制

1.Javadoc

public class Doc {
    String name;
    /**
     * @author kuangshen
     * @version 1.0
     * @since 1.11
     */

    /**
     * @author Kuangshen
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }

2.用户交互Scanner

public class Demo1 {
    public static void main(String[] args) {

        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);// new Scanner(System.in)+alt+Enter

        System.out.println("使用next方式接受：");

        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用Next方式接受
            String str = scanner.next();
            System.out.println("输入的内容为"+str);
        }

        //凡属于Io流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();
    }
}

  public static void main(String[] args) {
        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方式接受：");

        if(scanner.hasNextLine()){
            //使用Next方式接受
            String str = scanner.nextLine();
            System.out.println("输入的内容为"+str);
        }
        scanner.close();

public static void main(String[] args) {
        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("输入数据：");


            String str = scanner.nextLine();
            System.out.println("输入的内容为： "+str);

        scanner.close();
    }

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //从键盘接受数据
        int i = 0;
        float f = 0.0f;

        System.out.println("请输入整数:");

        //如果 .... 那么
        if(scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据为："+i);
        }else{
            System.out.println("输入的不是整数数据！");
        }

        //如果 .... 那么
        if(scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据为："+i);
        }else{
            System.out.println("输入的不是小数数据！");
        }
    }

public static void main(String[] args) {
        //我们可以输入多个数字，并求和与平均数，每输入一个数字用回车表示
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;

        //通过循环判断是否还存在输入，并在里面对每一次进行求和和统计
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();//scanner.nextDouble();输入一个数
            m=m+1;//m++
            sum = sum +x;
            System.out.println("你输入了第"+m+"个数据，当前的结果sum+"+sum);
        }

        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均值为："+(sum/m));


        scanner.close();
    }

3.选择结构

1.if单选择结构

  public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        //equal:判断字符是否相等
        if(s.equals("hellow")){
            System.out.println(s);
        }

        System.out.println("end");
        scanner.close();

2.if双选择结构

 //双选择结构
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60分就是不及格
        Scanner scanner = new Scanner(System.in);

        System.out.println("输入成绩：");
        int score = scanner.nextInt();

        if(score>60){
            System.out.println("及格");
        }else{
            System.out.println("挂了");
        }

        scanner.close();

    }

3.if多选择结构

 public static void main(String[] args) {
        //多选择结构
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩： ");
        int score = scanner.nextInt();

        if(score==100){
            System.out.println("满分");
        }else if (score<100&& score>90){
            System.out.println("A");
        }else if (score<90&& score>80){
            System.out.println("B");
        }else if (score<80&& score>70){
            System.out.println("C");
        }else if (score<70&& score>60){
            System.out.println("D");
        }else if (score<60){
            System.out.println("挂了");
        }else{
            System.out.println("成绩不合法");
        }

        scanner.close();
    }

4.switch选择结构

  public static void main(String[] args) {
        //case具有穿透性，需要break进行停止
        //seitch匹配一个具体的值

        char grade = 'A';

        switch(grade){
            case'A':
                System.out.println("优秀");
                break;//可选
            case'B':
                System.out.println("良好");
                break;//可选
            case'C':
                System.out.println("及格");
                break;//可选
            case'D':
                System.out.println("挂科");
                break;//可选
            default:
                System.out.println("未知");

        }

    }

5.循环结构

1.while循环

  public static void main(String[] args) {
        //输出1~100

        int i = 0;

//        System.out.println(i++);
//        System.out.println(i++);
//        System.out.println(i++);
//        System.out.println(i++);
//        System.out.println(i++);
//        System.out.println(i++);
//        System.out.println(i++);

        while (i<=100){
            i++;
            System.out.println(i);
        }
    }

  public static void main(String[] args) {

        //死循环
        while(true){
            //等待客户检查
            //定时检查

        }
    }

 public static void main(String[] args) {
        //计算1+2+3....100=？
        int i = 0;
        int sum = 0;

        while(i<=100){
            sum = sum +i;
            i++;
        }
        System.out.println(sum);
    }

2.do…while

 public static void main(String[] args) {
        int i = 0;
        int sum = 0;

        do{
            sum = sum +1;
            i++;
        }while(i<=100);
        System.out.println(sum);
    }

 public static void main(String[] args) {

        //do....while至少执行一次
        int a = 0;
        while(a<0){
            System.out.println(a);
            a++;
        }

        System.out.println("===============");
        do{
            System.out.println(a);
        }while (a<0);
    }

3.for

 public static void main(String[] args) {
        int a = 1;//初始化条件

        while(a<=100){//条件判断
            System.out.println(a);//循环体
            a+=2;//迭代
        }

        System.out.println("while循环结束");

        //初始化//条件判断 //迭代
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
        System.out.println("for循环结束！");

        //死循环
        for (; ;) {

        }
    }

 public static void main(String[] args) {
        //计算1~100之间奇数和偶数的和

        int oddSum = 0;
        int evenSum = 0;

        for (int i = 0; i < 100; i++) {
            if(i%2!=0){
               oddSum+= i;
            }else {
                evenSum+=i;
            }
        }
        System.out.println("奇数和的"+oddSum);
        System.out.println("偶数和的"+evenSum);
    }

 public static void main(String[] args) {
        //用while或for循环输出1-1000之间能被5整除的数，并且每行输出三个

        for (int i = 0; i < 1000; i++) {
           if(i%5==0){
               System.out.println(i+"/t");
           }
           if(i%(5*3)==0){//每行
               System.out.println();
               //System.out.print("/n");
           }
        }
        //pritntln  输出完全会换行
        //print     输出完不会换行
    }

  public static void main(String[] args) {
        //打印九九乘法表
        /*
        * 1.我们先打印第一列
        * 2.固定的1再用一个循环包起来
        * 3.去掉重复项
        * 4.调整样式
        * */

        for (int j = 1; j <= 9; j++) {

            for (int i = 1; i <= j; i++) {
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }

    }

  public static void main(String[] args) {
        int[] number = {10,20,30,40,50};

        //遍历数组
        for (int x:number){
            System.out.println(x);
        }
        System.out.println("==============");
        for (int i = 0; i < 5; i++) {
            System.out.println(number[i]);
        }
    }

4.break、continue

 public static void main(String[] args) {
        int i = 0;
        while(i<100){
            i++;
            System.out.println(i);
            if(i==30){
                break;
            }
        }
        System.out.println("1,2,3");
    }

  public static void main(String[] args) {
        int i = 0;
        while(i<100){
            i++;
            if(i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i);
            System.out.print("\t");
        }
      
    }

    1.break在任何循环语句的主题部分，均可用break控制循环流程。
    2.break用于强行退出循环，不执行剩余语句。（break语句也在switch语句中使用）
    3.continue语句在循环语句体中，用于终止某次循环过程，即跳出循环体中尚未执行的语句，接着执行下一次是执行循环的判定。

训练：打印三角形

 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();
        }
    }

三、Java方法详解

1.方法定义

（1）.方法命名规则:首字母小写，后面驼峰规则
（2）.形式：
修饰符返回值类型方法名（参数类型参数名）{
方法体；
return 返回值；
}

2.方法调用

值传递

public static void main(String[] args) {

        //实际参数：实际调用传递的参数
        int sum = add(1, 2);
        System.out.println(sum);
    }

    //形式参数，用来定义作用
    public static int add(int a,int b){

        return a+b;
    }

    //方法重载
    public static int add(int a,int b,int c){

        return a+b+c;
    }

3.方法重载

相同函数名称，形参不同

public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);
    }

    //比大小   方法重载“名字可以相同，参数类型（个数、类型、排列顺序）不同”
    public static double max(double a,double b){
        double result = 0;

        if(a == b){
            System.out.println("a = b");
            return 0;//终止方法
        }

        if(a>b){
            result = a;
        }else {
            result = b;
        }
        return result;
    }

    //比大小
    public static int max(int a,int b){
        int result = 0;

        if(a == b){
            System.out.println("a = b");
            return 0;//终止方法
        }

        if(a>b){
            result = a;
        }else {
            result = b;
        }
        return result;
    }

4.命名行传参

5.可变参数

  public static void main(String[] args) {

        //调用可变参数方法
        printMax(12.11,21,121,1212,121);
        printMax(new double[]{1,2,3});

    }

    public static void printMax(double...number){
        if(number.length==0){
            System.out.println("No argument passed");
            return;
        }

        double result = number[0];

        //排序！
        for (int i = 1; i <number.length ; i++) {
            if(number[i]>result){
                result = number[i];
            }
        }
        System.out.println("The max value is"+result);

    }

6.递归

  //阶乘
    public static void main(String[] args) {
        System.out.println(f(3));
    }

    public static int f(int n){
        if(n==1){
            return n;
        }else {
            return n*f(n-1);
        }
    }

四、数组

1.定义与初始化

public class ArrayDemo01 {
    //变量的类型 变量的名字 = 变量的值；
    //数组类型

    public static void main(String[] args) {
        int[] nums; // 1.定义一个人数组
        nums = new int[10]; // 2.创建一个数组

        //赋值
        for (int i = 0; i < 10; i++) {
            nums[i] = i;
            System.out.println("num["+i+"]="+nums[i]);
        }

        //求和
        //nums.length 数组长度
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println();
        System.out.println("数组和为"+sum);
    }

}

 public static void main(String[] args) {
        //静态初始化：创建＋赋值
        int[] a = {1,2,3,4,5,6,7,8};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        b[1] = 11;

        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
        System.out.println(b[4]);
        System.out.println(b[5]);
    }

3.数组使用

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8};

        //打印全部数组元素
        for (int i = 0; i <array.length ; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=============");

        //计算机所有元素的和
        int sum = 0;
        for (int i = 0; i <array.length ; i++) {
            sum += array[i];
        }
        System.out.println("sum="+sum);
        System.out.println("==============");

        //查找最大的元素
        int max = array[0];
        for (int i = 0; i <array.length ; i++) {
          if(array[i]>max){
              max = array[i];
          }
        }
        System.out.println("max="+max);
    }
}

  public static void main(String[] args) {
         int[] arrays = {1, 2, 3, 4, 5, 6};

//         //JDK1.5  没有下标 arrays.for
//         for (int array : arrays) {
//             System.out.println(array);

//         }
         int[] revese = revese(arrays);
         printArray(revese);
     }

    //打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i]+"");

        }
    }

    //反转数组
    public static int[] revese(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j = arrays.length-1; i <arrays.length; i++,j--) {
            result[j] = arrays[i];
        }

        return result;
    }

   public static void main(String[] args) {

        //[4][2] 面向对象
        /*
        * 1,2 array[0]
        * 2,3 array[1]
        * 3,4 array[2]
        * 4,5 array[3]
        * */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.println(+array[i][j]);
            }
        }
    }

public static void main(String[] args) {

        int[] a = {15,1,1,5,61,561,561,651,561};

       //System.out.println(a);

        //打印数组
       // System.out.println(Arrays.toString(a));
       printArrray(a);
        System.out.println();

       //数组排序 升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        System.out.println();

        //填充
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));

    }
    public static void printArrray(int[] a){
        for (int i = 0; i <=a.length ; i++) {
            if(i==0){
                System.out.print("[");
            }
            if (i==a.length){
                System.out.print("]");
            }else{
                System.out.print(a[i]+",");
            }
        }
    }

冒泡排序

import java.util.Arrays;

public class ArrayDemo07 {

    public static void main(String[] args) {

        int[] a = {1,222,45,564,64,4654,564,16,54,6,5,14};

        int[] poposort = poposort(a);
        System.out.println(Arrays.toString(poposort));
    }

    /*冒泡排序
    *1.比较相邻元素，如果第1个数比第二个数大，交换他们的位置
    *2.每一次比较，都会产生一个最大的，或者最小的数字
    *3.下一次排序可以少一次排序!
    *4.以此循环，直到结束
    * */

    public static int[] poposort(int[] array){

        //临时变量
        int temp=0;

        //外层循环，判断走了多少次
        for (int i = 0; i <array.length ; i++) {

            boolean flag = false;//通过Flag标志位减少无意义的比较。

            //内层循环，比较判断两个数，第一个数比第二的数大，则交换位置
            for (int j = 0; j <array.length-1-i; j++) {
                if(array[j+1]<array[j]){
                    temp=array[j];
                   array[j]=array[j+1];
                   array[j+1]=temp;
                   flag = true;
                }
            }

            if (flag==false){

                break;
            }

        }

        return array;
    }

}

4.二维数组与稀疏数组使用

  public static void main(String[] args) {
        //1.创建一个二维数组11*11  0：没有棋子   1：黑棋    2:白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数据
        System.out.println("输出原始数据");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存
        //获得有效值的个数
        int sum = 0;
        for (int i = 0; i <11 ; i++) {
            for (int j = 0; j <11 ; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i <array2.length ; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }

        System.out.println("===============");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中元素还原他的值
        for (int i = 1; i <array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //3.打印
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }

二维数组底层逻辑图：

五、面向对象编程（OPP）

1.理解及定义

2.方法定义及调用

/
* 修饰符返回值类型方法名（）{
* //方法体
* return 返回值；
* }
* /

import java.io.IOException;

//Demo类
public class Demo01 {

    //main方法
    public static void main(String[] args) {

    }

    /*
    * 修饰符 返回值类型 方法名（）{
    *   //方法体
    *   return 返回值；
    *  }
    * */

    //return 结束方法，返回一个结果
    public String sayhellow(){
        return"Hellow";

    }
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a > b?a:b;//三元运算符
    }

    //数组下标越界：Arrayindexoutofbounds
    public void readFile(String file)throws IOException {

    }
}

调用方法

  public static void main(String[] args) {

        //调用静态方法直接用 类.方法（）；
        Student.say();

        //调用非静态方法
        // 1.实例化 对象类型 对象名 = 对象值；
        // 2.对象.方法
        Student student = new Student();
        student.play();
        //或者 new Student().play()

    }
    //和类一起加载的
    public  void a( ){
        b();
    }

    //实例化之后才存在
    public void b( ){
        a();
    }
    //带static不可以调用不带的
}

实际参数要对应形式参数的类型

public class Demo03 {
    public static void main(String[] args) {
        //实际参数要对应形式参数的类型
        int add = Demo03.add(3, 2);//实际参数
        System.out.println(add);
    }

    public static int add(int a,int b){//形式参数
        return a+b;
    }
}

值传递

public class Demo04 {
    //值传递
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//a:1
        Demo04.chage(a);
        System.out.println(a);//a:1

    }
    //返回值为空
    public static void chage(int a){
        a = 10;
    }
}

3.类与对象的关系

引用传递

//对象、内存
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();

        System.out.println(person.name);//null

        Demo05.change(person);

        System.out.println(person.name);//qinyan
    }

    public static void change(Person person){
        //person是一个对象：指向的--->Person person = new Person();这是一个具体的人，可以改变属性！
        person.name= "qinyan";
    }
}

//定义一个Person,有一个属性：name
class Person{
    String name;//NULL
}

package ***.oop.demo01;

public class Student {

    //静态方法
    public static void say(){
        System.out.println("学生说话了");
    }

    //非静态方法
    public  void play(){
        System.out.println("学生wan了");
    }
}

4.创建和初始化对象

构造器

* 构造器：
* 1.与类名相同
* 2.没有返回值
*作用：
* 1.new 的本质在调用构造方法
* 2.初始化对象的值
*
* 注意：一旦定义了有参构造，若想用无参构造，无参构造必须显示！！！，否则无意义
*this.当前类 = 定义参数

//java---->class
public class Person {
    //Person类中存在一个空的Person方法
    //一个类即使什么也不写，也会存在一个方法

    //显示构造器
    String name;
    int age;

    //实例化初始值
    //1.使用new关键字必须有构造器
    //2.用来初始化值
    public Person(){//无参构造
        this.name = "QINyan";
    }

    //有参构造：一旦定义了有参构造，无参构造必须显示，否则无意义
    public Person(String name){//无参构造
        this.name = "QINyan";
    }

    //alt+insert 生成构造器!!!!


    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

/*
*   public static void main(String[] args) {

        //Person类中存在一个默认的空的Person方法
        Person person = new Person();

        System.out.println(person.name);
    }

//学生类
public class Student {

    //属性：字段
    String name;//默认null
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"学习");
    }

    测试：
      public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！
        //不同的对象有相同的属性，可以给对象的属性赋不同的值
        Student student = new Student();
        Student student1 = new Student();

        student.name =  "james";
        student.age = 2;

        System.out.println(student.name);
        System.out.println(student.age);

        student1.name = "curruy";
        student1.age = 1;

        System.out.println(student1.name);
        System.out.println(student1.age);
    }
    
}

构造器底层原理

public class Pet {
    public String name;
    public int age;

    //无参构造

    public void shout(){
        System.out.println("哇哇哇哇");
    }
}

/*
*     Pet dog = new Pet();
        dog.name = "qqq";
        dog.age = 1;

        dog.shout();

        System.out.println(dog.age);
        System.out.println(dog.name);

        Pet cat = new Pet();

* */

5.opp三大特性-封装

1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了

//类 private:私有
public class Student {

    private String name;
    private int id;
    private int age;
    private char sex;


    //提供一些可以操作这个属性的方法！
    //提供一些publicd的get,set方法

    //alt +insert  Fn
    //get 获得这个数据
    public String getName() {
        return name;
    }


    //set 给这个数据设值
    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){//不合法
            this.age = 3;
        }else {
            this.age = age;
        }
        this.age = age;
    }

}
测试：
 	    Student s1 = new Student();

        System.out.println("\t\t学生信息情况表");

        s1.setName("秦严");
        System.out.println(s1.getName());

        s1.setAge(18);
        System.out.println(s1.getAge());

        s1.setSex('w');
        System.out.println(s1.getSex());

        s1.setId(2020304621);
        System.out.println(s1.getId());

6.opp三大特性-继承

1.person、student、teacher

//person 人  基类：父类
//java中所有的类默认直接或者间接继承Object
public class Person {//extend Object
        protected String name = "Kg";

    public Person() {
        System.out.println("无参构造Person");
    }

    //只能用public,不能用private，私有的不能被继承
        public void print(){
            System.out.println("person");
        }

}

/*
* //继承用public 或者不加修饰符
     int money = 1000_000;



    public void say(){

        System.out.println("哈哈哈哈哈哈哈哈哈");
    }

    //如果用private 可以构建一个get,set方法由子类来调用
    private int money1 = 1444;
    public int getMoney1() {
        return money1;
    }

    public void setMoney1(int money1) {
        this.money1 = money1;
    }
* */

//学生 is person 派生类：子类
//子类继承父类，就会拥有父类的全部方法
public class Student extends Person {
    //ctrl + H 展开继承树
    private String name = "Qy";



    public Student() {
        //隐藏代码，调用了父类的无参构造
        super();//调用父类的构造器必须在子类构造器的第一行
        System.out.println("无参构造Student");
    }

    public void print(){
        System.out.println("student");

    }

    public void test1(){
       print();
       this.print();
       super.print();
    }


    public void test(String name){
        System.out.println(name);//方法参数中的
        System.out.println(this.name);//子类中的
        System.out.println(super.name);//父类 Person中的
    }
}

/*1.
*  Student student = new Student();
        student.say();

  2.
*   Student student = new Student();
        System.out.println("===============1");
        student.test("秦严");
        System.out.println("===============2");
        student.test1();

* */

//老师 is person  派生类：子类
public class Teacher extends Person {
}

2.A-B

public class A extends B{

    //重写  @Override
    @Override //注解：由功能的注释
    public void test() {
        super.test();
        System.out.println("A=>test");
    }
}
/*
import ***.oop.demo05.A;
import ***.oop.demo05.B;
import ***.oop.demo05.Student;

//静态方法：方法的调用只和左边，调用的数据有关
//非静态方法：重写

* public static void main(String[] args) {
        A a = new A();
        a.test();//A

        //父类的引用指向子类
         B b = new A();//子类继承父类，并重写了父类的方法
        b.test();//B

    }

* */

public class B {

    //重写都是方法的重写与属性无关
    public  void test(){
        System.out.println("B=>test");
    }

}

注意：

 1. java中所有的类默认直接或者间接继承Object

 2.JAVA中类只有单继承，没有多继承! 一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子！

```
 3.Super-this（P，T，S）：
```

super注意点:

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中!
super和 this不能同时调用构造方法!

this注意点:
superVSthis:
1.代表的对象不同:
*** this: 本身调用者这个对象
*** super: 代表父类对象的应用

2.前提
*** this:没有继承也可以使用
*** super:只能在继承条件才可以使用

3.构造方法
*** this();本类的构造
*** super（）:父类的构造

方法重写（A，B）
子类继承父类，并重写了父类的方法
重写：需要有继承关系，子类重写父类
*** 1.方法名必须相同
*** 2.参数列表必须相同
*** 3.修饰符：范围可以扩大但不能缩小：public>protected>Default>private
*** 4.抛出的异常：范围可以缩小但不能扩大：classNotFoundException–>Exception(大)
重写，子类的方法和父类必须一致：方法体不同

为什么要重写：
***1. 父类的功能，子类不一定需要，或者不一定能满足！
***2.ALT+Insert(Fn):override

7.三大特性-多态

1.定义

2.instanceof（类型转换）引用类型
多态注意事项

1.多态是方法的多态，属性没有多态
2.子类父类，有联系，类型转换异常! ClassCastException!
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son
4.以下不能重写：

          1.static 方法 属于类 它不属于实例

```
          2.final 常量
```
```
          3.private 方法：
```

public class Person {
    public void run(){
        System.out.println("run");
    }

}

/*
* 1. public void run(){
        System.out.println("run!!!!!");
    }
*
* */

public class Student extends Person {

    public void go(){
        System.out.println("go");
    }

    }
/*多态注意事项
* 1.多态是方法的多态，属性没有多态
* 2.子类父类，有联系，类型转换异常! ClassCastException!
* 3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son
* 4.以下不能重写：
*               1.static 方法 属于类 它不属于实例
*               2.final 常量
*               3.private 方法：
*
*1.  @Override
    public void run() {
        System.out.println("son");

    }

    public void eat(){
        System.out.println("吃");
    }
    *
    *
    *    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向引用类型就不确定了:父类的引用指向子类

        // Student 能调用的方法都是自己的或者调用父类的
        Student s1 = new Student();
        // Person 父类型 指向子类，不可以调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();
        s1.run();//子类重写了父类的方法，执行子类的方法

        //s2.eat（）;不能执行 对象能执行那些方法主要看左边类型，和右边关系不大
        ((Student)s2).eat();//可以强转后执行
    }
    *
    *2.
    *   public static void main(String[] args) {


        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student

        //System.out.println(X instanceof Y);//是否能编译通过取决于具有父子关系
        //System.out.println(X instanceof Y);//true或者false取决于引用对象X指向的类型是不是Y的子类型

        Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//flase
        System.out.println(object instanceof String);//flase
        System.out.println("=======================");
        Person person = new Student();
        System.out.println( person instanceof Student);//true
        System.out.println( person instanceof Person);//true
        System.out.println( person instanceof Teacher);//false
        System.out.println( person instanceof Object);//true
        //System.out.println( person instanceof String);//编译报错
        System.out.println("=======================");
        Student student = new Student();
        System.out.println( student instanceof Student);//true
        System.out.println( student instanceof Person);//true
        System.out.println( student instanceof Object);//true
       // System.out.println( student instanceof Teacher);//编译报错
        //System.out.println( person instanceof String);//编译报错


* */

public class Teacher extends Person {


}
/*
*   public static void main(String[] args) {
        //类型之间的转换 父 子（高转低 强制转换   低转高 自动转换）

        //父类引用指向子类对象
        //student将这个对象类型强制转换成Student类型，就可以使用Student类型的方法了
        Person person  = new Student();

        ((Student)person).go();

        //子类转换为父类可能丢失一些自己本来的方法
        Student student = new Student();
        Person person1 = student;


    }

*
* */

8.Static关键字、抽象类，接口

1.Static关键字

public class Person {

    {
        System.out.println("匿名代码块");
    }

    static {
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("=============");
        Person person1 = new Person();
        //静态代码块只执行一次

    }
}

public class Student {

    //静态属性
    private static int age;//静态变量 多线程
    private int score;//非静态变量

    //静态方法
    public void run(){

    }
    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        //System.out.println(Student.score);类只能调用静态变量
        System.out.println(s1.score);
        System.out.println(s1.age);

        Student.go();
        go();
        //Student.run(); 不可以编译
        s1.run();
    }
}

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);

        //类被final定义，无法继承
    }
}

2.抽象类

抽象类的所有方法继承他的子类都必须实现的方法除非也是抽象类public abstract class A extends

 Action
public class A extends Action {
    @Override
    public void something() {

    }
}

// abstract 抽象类: extends 单继承  (接口可以多继承)插排
public abstract class  Action {

    //约束 不实现
    //abstract 抽象方法 只有方法名字，没有方法实现

    public abstract void something();

    //1.不能new这个抽象类，只能靠子类实现它:约束
    //2.抽象类可以写普通方法，普通方法不能有抽象类
}

3.接口
声明：interface

作用：
1.约束
2.定义一些方法，让不同的人实现
3.public static final
4.public abstract
5.接口不能实例化，接口不能构造方法
6.inplements可以实现多个接口
7.必须重写接口中的方法

public interface TimeService {
    void time();


}

// interface 是关键字，接口都需要有实现类
public interface UserService {

    //常量 public abstract final
    int age = 99;

    //接口中的所有定义都是抽象的 public abstract
    public abstract void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}


//抽象类extends
//类 实现接口 implements 接口
//实现接口中的类 就要重写接口中的方法
//接口可以实现多继承
public class UserServiceImp implements UserService,TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}

9.内部类

public class Outer {

    private int id = 11;

    public void out(){
        System.out.println("外部类");
    }

    public class inner{
        public void out(){
            System.out.println("内部类");
        }

        //获得外部类的私有属性
        public void GetId(){
            System.out.println(id);
        }

    }
}

//一个java中只有一个public类，可以有多个class类
class a{
    public static void main(String[] args) {

    }
}

/*
*  public static void main(String[] args) {
        Outer outer = new Outer();

        //通过外部类实例化内部类
        Outer.inner inner = outer.new inner();
        inner.GetId();
    }
* */

public class Outer {

    private int id = 11;

    public void out(){
        System.out.println("外部类");
    }

    public class inner{
        public void out(){
            System.out.println("内部类");
        }

        //获得外部类的私有属性
        public void GetId(){
            System.out.println(id);
        }

    }
}

//一个java中只有一个public类，可以有多个class类
class a{
    public static void main(String[] args) {

    }
}

/*
*  public static void main(String[] args) {
        Outer outer = new Outer();

        //通过外部类实例化内部类
        Outer.inner inner = outer.new inner();
        inner.GetId();
    }
* */

六、异常机制

1.异常定义

2.异常结构体

1.Error与Exception

Ctrl Alt T:自动生成抛出异常

3.异常处理机制与自定义异常

public class Test {

    public static void main(String[] args) {
        int a = 0;
        int b = 1;
        try {//try监控区域
            if(a==0){//throw throws
                throw new ArithmeticException();//主动抛出异常
            }
            System.out.println(b/a);
        } catch (ArithmeticException e) {//catch 异常捕获
            e.printStackTrace();
            System.out.println("程序出现异常，被除数不为0");
        }finally {//处理善后工作
            System.out.println("final");
        }
        //可以不要finall,在 假设 IO 资源 关闭



        //捕获多个异常 从小到大
        try {
            new Test().a1();
        } catch (RuntimeException e) {
            System.out.println("出现异常1");
        }
        catch (Exception e) {
            System.out.println("出现异常2");
        }
        catch (Throwable e) {
            System.out.println("出现异常3");
        }

    }


    public void a1(){
        b1();
    }

    public void b1(){
        a1();
    }


}

public class Test1 {

    public static void main(String[] args) {
        new Test1().tset(10,0);
    }


    public void tset(int a,int b){
        if(b==0){
            throw new ArithmeticException();//主动抛出异常，一般用在方法中
        }
        System.out.println(a/b);
    }
}

实际应用中的经验总结：

前端学习

转载请说明出处内容投诉
CSS教程_站长资源网 » java web(后端＋前端) 学习路线记录（代码＋总结）---1.JavaSE（完成）

626458752

分享到：