javaSpringboot基础一

2022-11-21 14:38:48

一、递归讲解

 public class diGuiStudy {
     public static void main(String[] args) {
         System.out.println(f(5));
     }
     public static int f(int n ){
         if(n==1) {
             return 1;
         }else {
             return n*f(n-1);
         }
     }
 }

设置边界条件：边界n==1

前阶段：前面一个阶段

返回阶段：返回值n*（n-1）

能不用递归就不用递归。

二、数组

（一）数组的声明和创建

首先必须声明数组变量，才能在程序中使用数组

 public class arryStudy {
     //变量的类型 变量的名字=变量的值：
     //数据类型
     public static void main(String[] args) {
 //        int[] nums;
 //        int nums2[];
        int[] nums=new int[10];
        nums[0]=1;
        for (int i =0;i<nums.length;i++){
            System.out.println(nums[i]);
        }
 
     }
 }
 // 输出 1000000000

三、方法

（一）静态方法

含有static

static 是跟类一起加载，而动态类是实例化后才加载

1.创建static方法

 package oop;
 
 public class funcStduny03 {
     public static void sayhello(){
         System.out.println("我是静态方法");
     }
 }

2 调用方法

 package oop;
 
 public class funcStudy02 {
     public static void main(String[] args) {
         funcStduny03.sayhello();
 
     }
 }

（二）动态方法

1.创建方法

 package oop;
 
 public class funcStduny03 {
     public void Sayhello(){
         System.out.println("我是动态方法");
     }
 }

2.调用方法

 package oop;
 
 public class funcStudy02 {
     public static void main(String[] args) {
         funcStduny03 sayhello=new funcStduny03();
         sayhello.Sayhello();
 
     }
 }

（三）值传递

（四）引用传递

四、面向对象的概念

(一) 类的方法与引用

 package oop;
 //每个类，只能包含有属性和方法
 public class oppStudy {
     String name;
     int age;
     public void study(){
         System.out.println(this.name+"在学习");
     }
 }
 
 package oop;
 
 public class oopStudy02 {
     //类：抽象的，实例化
     //实例化后返回一个自己的对象
     //对象就是一个类的具体实例！
     public static void main(String[] args) {
         oppStudy oppstudy=new oppStudy();
         oppstudy.name="小明";
         System.out.println(oppstudy.name);//小明
     }
 }

（二）构造方法

 package oop;
 //一个类什么都不写，都会有一个方法
 //显示的定义构造器
 public class oopStudy03 {
     String name;
     //实列化初始值
     //1.new 本值就是使用构造器
     public oopStudy03(){
         this.name="你好";
 
     }
     //有参构：一旦定义了有参，必须要无参定义
     public oopStudy03(String name){
         this.name=name;
     }
 
 }
 
 
 package oop;
 
 public class oppstudy04 {
     public static void main(String[] args) {
         oopStudy03 opp= new oopStudy03("涂飞");
         System.out.println(opp.name);
     }
 }

(三）、封装

package oop;
/**
 * 1.提高程序的安全性，保护数据
 * 2.隐藏代码的实现细节
 * 3.统一接口
 * 4.系统可维护增加
 *alt inerst 自动增加get/set
 */

public class oopsStudy05 {
    public static void main(String[] args) {
        oopStudy06 oop=new oopStudy06();
        oop.setAge(5);
        oop.setName("DZH");
        System.out.println(oop.getName());
        System.out.println(oop.getAge());

    }
}

package oop;

public class oopStudy06 {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<10){
            System.out.println("*邓");
        }
        this.age = age;

    }
}

(四)、继承

1.super 调用父类的构造方法，必须在构造方法的第一个

2.super 必须只能出现子类的方法或者构造方法中！

3.super和this 不能同时调用构造防范

VS this：

代表的对象不同：

this：本身的调用者

super：父类的代表应用

前提： this：没继承也可以使用

重写：

需要有集成关系，子类重写父类的方法：

1.方法名必须相同

2.参数离别必须相同

3.修饰符：范围可以可以扩大但不能缩小：

public>Protected>Default>private

4.抛出的异常：范围，可以被缩小，但不能扩大：

ClassNote>erro

5.子类的方法和父类必要一致，方法不通！

为什么要重写：

1.父类的功能，子类不一定需要，或者不一定满足！

alt+insert：ovverid

五、多态

instanceof 判断类别关系

六、接口

七、内部类

八、异常

 package oop;
 
 public class ErrorStudy {
     public static void main(String[] args) {
         int a=1;
         int b=0;
         try{
             int c =a/b;
             System.out.println(c);
         }catch (Throwable e){
             System.out.println(e);
         }finally {
             System.out.println("结束");
         }
     }
 }

九、快捷键

alt+inerst 类中使用的各类方法，比如get/set方法

psvm 类中的主方法

sout 控制台打印方法

alt+ctr+t if do while try catch 包括代码

码农公寓