Java学习

参照视频[狂神说java]([狂神说Java]Java零基础学习视频通俗易懂_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili)

标识符注意点

  1. 不能使用关键字作为变量名
  2. 标识符对大小写敏感
public class Demo02 {
    public static void main(String[] args) {
        String a = "hello";
        int num = 10;
        long num4 = 30L;//Long类型要在数字后面加个L

        //小数:浮点数
        float num5 = 50.1F;
        double num6 = 3.1415926;

        //字符
        char name = 'Q';
        //字符串,String不是关键字,类
        String namea ="秦将";

        //布尔值
        boolean num7 = false;
        System.out.println(a);

    }
}

数据类型

  1. Java是强类型语言

    Java的数据类型

    • 基本类型(primitive type) 整数类型、浮点类型、字符类型char(占2个字节)、boolen类型。short 2字节
    • 引用类型(reference type):类、接口、数组
    public class Demo3 {
        public static void main(String[] args) {
            //整数拓展:     进制         二进制0b    八进制0        十六进制0x
            int i = 10;
            int i2 = 010;//八进制
            int i3 = 0x10;//十六进制0x  0~9 A~F
    
            System.out.println(i);
            System.out.println(i2);
            System.out.println(i3);
            System.out.println("==========");
    
            //=================================================
            //浮点数拓展?  银行业务怎么表示? 钱
            //BigDecimal    数学工具类
            //float 有限 离散  舍入误差     大约      接近但不等于
            //double
            //最好完全不用浮点数进行比较
    
            float f =0.1f;
            double d = 1.0/10;
            System.out.println(f==d);
    
            float d1 = 231231231231231231232131f;
            float d2 = d1 + 1;
            System.out.println(d1==d2);
            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 - 65535  Excel 2 16 = 65536
            //U0000 UFFFF
            char c3 = '\u0061';
            System.out.println(c3); //a
    
            //转义字符
            //\t    制表符
            //\n    换行
            System.out.println("Hello\tWorld");
            System.out.println("Hello\nWorld");
    
            System.out.println("======================================");
            String sa = new String("hello world");
            String sb = new String( "hello world");
            System.out.println(sa==sb);
    
            String sc = "hello world";
            String sd = "hello world";
            System.out.println(sc==sd);
    
            //对象    从内存分析
            //布尔值扩展
            boolean flag = true;
            if(flag==true) { }
        }
    }
    
    

    类型转换

    • 低--------------------------------------->高
    • byte,short,char-> int -> long-> float -> double
public class Demo5 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i; //溢出
        //强制转换   (类型)变量名   高--低
        //自动转换      低--高

        System.out.println(i);
        System.out.println(b);
        /*
        注意点:
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干类型
        3.精度问题
        4.高--低
         */
        System.out.println("=================");
        System.out.println((int)23.7);
        System.out.println((int)-45.89f);

        System.out.println("=========");
        //JDK7新特性,数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;
        long  total2 = money*years;
        long total3 = money*((long)years);
        System.out.println(total3);
    }
}

变量

  • 类变量
  • 实例变量
  • 局部变量
public class Demo08 {
    //类变量   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 Demo08();
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);

        //类变量 static
        System.out.println(salary);


    }
}

常量

  1. final 变量

变量的命名规范

  1. 所有变量、方法、类名:见名知意;
  2. 类成员变量:首字母小写和驼峰原则:monthSalary;
  3. 局部变量:首字母小写和驼峰原则;
  4. 常量:大写字母和下划线:MAX_VALUE;
  5. 类名:首字母大写和驼峰原则:Man,GoodMan;
  6. 方法名:首字母小写和驼峰原则:run(),runRun();

运算符

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //幂运算 2^3    2*2*2 = 8
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}
package operator;

public class Demo03 {
    public static void main(String[] args) {
        //幂运算 2^3    2*2*2 = 8
        double pow = Math.pow(2,3);
        System.out.println(pow);

        //与         或       非
        boolean a =true;
        boolean b =false;

        System.out.println("a && b: "+(a&&b));
        System.out.println("a || b:"+(a||b));
        System.out.println("!(a&&b):"+!(a&&b));

        //短路运算
        int c =5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);

        //三元运算符
        int a1 = 10;
        int b1 = 20;

        a1+=b1; //a = a+b
        a1-=b1; //a = a-b
        System.out.println(a1);
        //字符串连接符   +  ,String
        System.out.println(""+a1+b1);
        System.out.println(a1+b1+"");
        System.out.println(""+(a1+b1));
        //三目运算
        //x ? y : z
        int score = 80;
        String type = score <60 ?"不及格":"及格";
        System.out.println(type);
    }
}

包机制

  1. 包的本质是文件夹,一般利用公司域名倒置作为包名com.kuangstudy.blog

  2. 为了能够使用某一包的成员,需要在Java程序中明确导入该包。使用"import"语句可完成此功能。

    package com.kuang.operator;
    import java.util.Date;
    import com.kuang.base.*;
    

    package放在import前面

JavaDoc

  • javadoc命令是用来生成自己API文档

    参数信息

Java流程控制

用户交互scanner

Scanner s = new Scanner(System.in);
package com.kuang.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象,用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收: ");
        //判断用户有没有输入字符串
        if(scanner.hasNext())
        {
            //使用next方式接收
            String str = scanner.next();
            System.out.println("输出的内容为: "+str);
        }
        //凡属IO流的类如果不关闭会一直占用资源,要养成好习惯用完就关掉
        scanner.close();
    }
}

package com.kuang.scanner;

import java.util.Scanner;

public class Demo02 {
    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);
        }
        //凡属IO流的类如果不关闭会一直占用资源,要养成好习惯用完就关掉
        scanner.close();
    }
}

package com.kuang.scanner;

import java.util.Scanner;

public class Demo05 {
    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();
            m++;
            sum = sum +x;
        }
        System.out.println(m+ "个数的和为"+sum);
        scanner.close();
    }
}
  1. switch语句中的变量类型可以是:byte、short、int、char。
  2. 从Java SE 7开始 switch支持String类型

for(初始化; 布尔表达式;更新)

九九乘法表

package com.kuang.scanner;

public class Demo06 {
    public static void main(String[] args) {
        for (int j = 1; j <= 9; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(i+"*"+j+"="+(j*i)+"\t");
            }
            System.out.println();
        }

    }
}

增强型for循环

  1. java5引入

  2. for(声明语句:表达式)
    {
    
    }
    
package com.kuang.scanner;

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

             //遍历数组的元素
        for(int x:numbers)
        {
            System.out.println(x);
        }
    }
}

方法

  1. 一个方法只完成1个功能,有利于后期的扩展。

  2. 方法的定义

    修饰符  返回值  方法名(参数类型 参数)
    {
       ...
       方法体
       ...
       return 返回值;
    }
    
  3. 方法的重载

    • 方法名称相同

    • 方法的参数必须有不同

    • 返回类型不足以作为重载的区分

  4. 命令行传参

    • 程序运行时传递参数,
package method;

public class Demo02 {
    public static void main(String[] args) {
        //args.length 数组长度
        for(int i =0;i<args.length;i++)
        {
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}
  1. 可变参数

    JDK 1.5开始

    • 在方法声明中,在指定参数类型后加一个省略号
    • 一个方法只能指定一个可变参数,它必须是方法的最后一个参数。
    package method;
    
    public class Demo03 {
        public static void main(String[] args) {
            Demo03 demo03 = new Demo03();
            demo03.test(1,2,3,4,5,6,7,8,1,1,1,1,1,1,1,1,1,1,1,1);
            printMax(34,3,3,5,56.6);
            printMax(new double[]{1,2,3});
        }
        public void test(int x,int... i)
        {
            System.out.println(i[10]);
        }
    
        public static void printMax(double... numbers){
            if(numbers.length==0){
                System.out.println("No argument passed");
                return;
            }
    
            double result = numbers[0];
    
            //
            for(int i = 1;i< numbers.length;i++){
                if(numbers[i] > result){
                    result = numbers[i];
                }
            }
            System.out.println("The max value is "+ result);
        }
    }
    
  2. 递归

数组

  1. 数组定义

    package method;
    
    public class ArrayDemo01 {
        public static void main(String[] args) {
            int[] nums;//声明一个数组
            nums = new int[10];// 创建一个数组
            for(int i = 0;i<nums.length;i++)
            {
                nums[i] = i+1;
            }
        }
    }
    
  2. 内存分析

    • 声明数组 int[] array = null; 在栈中有一个名字 int array[] = null;
    • 创建数组 array = new int[10];在堆中开辟区间
  3. 数组的特点

    • 数组一旦被创建,其大小不可改变
    • Java中对象是在堆中的,数组可以看成是对象
    • ArrayIndexOutOfBoundsException, 数组下标越界
  4. 数组的使用

    • package method;
      
      public class ArrayDemo02 {
          public static void main(String[] args) {
              int[] arrays = {1,2,3,4,5};
              int sum = 0;
              for(int i = 0;i < arrays.length;i++)
              {
                  sum = sum + arrays[i];
              }
              System.out.println("sum:"+sum);
              for(int array:arrays)
              {
                  System.out.println(array);
              }
      
              int[] reverse = reverse(arrays);
              printArray(reverse);
          }
      
          //反转数组
          public static int[] reverse(int[] arrays){
              int result[] = new int[arrays.length];
              for(int i = 0;i<arrays.length;i++){
                  result[i] = arrays[arrays.length-1-i];
              }
              return result;
          }
      
          //打印数组
          public static void printArray(int[] arrays){
              for(int i = 0; i < arrays.length; i++)
              {
                  System.out.print("arrys["+i+"]:"+arrays[i]+"\t");
              }
              System.out.println();
          }
      }
      
      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]);
          }
      }
      
  5. Arrays具有常用功能:给数组赋值通过fill,对数组排序通过sort,比较数组通过equals方法比较数组中元素是否相等,查找数组元素通过binarySearch方法对排序好的数组进行二分查找法操作。

    • int[] a = {1,2,3,4,6,454,234};
      System.out.println(Arrays.toString(a));
      //输出 [1, 2, 3, 4, 6, 454, 234]
      Arrays.sort(a);
      System.out.println(Arrays.toString(a));
      
  6. 稀疏数组

面向对象编程

  1. 以类的方式组织代码,以对象的组织(封装)数据

  2. 三大特性:封装、继承、多态

  3. String在Java中属于类,不是关键字

  4. 构造方法必须与类名相同,必须没有返回值

    package oop;
    
    //学生类
    public class Student {
        //属性:字段
        String name;
        int age;
        //1.使用new关键字,本质是在调用构造器
        public Student() {
            this.name = "xingk";
        }
        //一旦定义有参构造,无参构造器必须显示定义
        public Student(String name) {
            this.name = name;
        }
        //方法
        public void study(){
            System.out.println("在学习");
        }
    }
    
  5. 封装:高内聚,低耦合。属性私有get,set。

    package oop;
    
    //学生类
    public class Student {
        //属性:字段
        private String name;
        private int age;
        //1.使用new关键字,本质是在调用构造器
        public Student() {
            this.name = "xingk";
        }
        //一旦定义有参构造,无参构造器必须显示定义
        public Student(String name) {
            this.name = name;
        }
        //方法
        public void study(){
            System.out.println("在学习");
        }
        public String getName(){
            return this.name;
        }
    
        public void setName(String name){
            this.name = name;
        }
    }
    
  6. 继承:Java中类只有单继承,没有多继承。

    • Java中类都继承了object类
  7. super注意点:

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

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

    3. super和this不能同时调用构造方法

    4. this();本类的构造

    5. super();父类的构造

      package method;
      
      //基类
      public class Person{
          protected String name = "kuangshen";
      }
      ======================================================
      package oop;
      import method.Person;
      
      //学生类,派生类
      public class Student extends Person {
          private String name = "qinjiang";
          public void print(){
              System.out.println(this.name);
              System.out.println(super.name);
          }
      }
      =============================================================
      package oop;
      
      public class Application {
          public static void main(String[] args) {
      
              /*
              3.对应的引用
                  引用类型:   基本类型(8)
                  对象是通过引用来调用的栈---->堆
              4.属性:字段Filed 成员变量
                  默认初始化:
                  数字:     0   0.0
                  char:       u0000
                  boolean:     false
                  引用:     null
               */
              Student xiaoming = new Student();
              xiaoming.print();
          }
      }
      ====================
      输出
      qinjiang
      kuangshen
      
  8. 方法重写需要有继承关系,子类重写父类的方法

    1. 方法名必须相同

    2. 参数列表列表必须相同

    3. 修饰符:范围可以扩大但不能缩小:public>protected>default>private

    4. 抛出的异常:范围可以被缩小,但不能扩大;ClassNotFoundException–>Exception(大)

    5. Alt+Insert: override

      package method;
      
      //基类
      public class Person{
          protected String name = "kuangshen";
          public void test()
          {
              System.out.println("Person=>test()");
          }
          public static void test1()
          {
              System.out.println("Person=>test1()");
          }
      }
      =======================================================
      package oop;
      import method.Person;
      
      //学生类,派生类
      public class Student extends Person {
          private String name = "qinjiang";
          public void print(){
              System.out.println(this.name);
              System.out.println(super.name);
          }
          public void test()
          {
              System.out.println("Student=>test()");
          }
          public static void test1()
          {
              System.out.println("Student=>test1()");
          }
      }
      ============================================================
      package oop;
      
      import method.Person;
      
      public class Application {
          public static void main(String[] args) {
      
              /*
              3.对应的引用
                  引用类型:   基本类型(8)
                  对象是通过引用来调用的栈---->堆
              4.属性:字段Filed 成员变量
                  默认初始化:
                  数字:     0   0.0
                  char:       u0000
                  boolean:     false
                  引用:     null
               */
              //静态方法是类的方法,非静态方法是对象的方法 ,new创建对象
              Student A = new Student();
              Person B = new Student();
              A.test();
              B.test();
              A.test1();
              B.test1();
          }
      }
      ========================================================
      输出
      Student=>test()
      Student=>test()
      Student=>test1()
      Person=>test1()
      
  9. 多态

  10. instanceof 判断对象是否是类的实例

    package oop;
    
    import method.Person;
    
    public class Application {
        public static void main(String[] args) {
            Person  s1 = new Student();
            System.out.println(s1 instanceof Student);
            ((Student)s1).print();
        }
    }
    
  11. static关键字,final修饰的类不能被继承了。

    package method;
    //静态导入包
    import static java.lang.Math.random;
    public class Student1 {
        private static int age;//静态的变量      多线程!
        private double score; //非静态的变量
        {
            System.out.println("匿名代码块");
        }
        static{ //只运行一次
            System.out.println("静态代码块");
        }
    
        public Student1(){
            System.out.println("构造方法");
        }
    
        public static void main(String[] args) {
            Student1 person = new Student1();
            Student1 person1 = new Student1();
            System.out.println(random());
        }
    }
    ========================================================
    输出
    静态代码块
    匿名代码块
    构造方法
    匿名代码块
    构造方法
    0.8565026626018188
    
  12. 抽象类,abstract修饰符

    package oop;
    //abstract 抽象类
    public abstract class Demo02 {
        //约束,继承子类实现
        //abstract ,抽象方法,只有方法名字,没有方法的实现!
        public abstract void doSomething();
        //1.不能new这个抽象类,只能靠子类去实现它;约束!
        //抽象类可以写普通的方法
        //抽象方法必须在抽象类中
    }
    
  13. 接口

    • 普通类具体实现

    • 具体实现和规范(抽象方法)都有!

    • 接口:只有规范!自己无法写方法~专业的约束!约束和实现分离:面向接口编程

    • 关键字 interface

      • 作用:1.约束,2,定义一些方法,让不同的人实现,3.public abstract 4.public static final, 5. 接口不可以被实例化,接口中没有构造方法

      • implements 可以实现多个接口

      • 必须重写接口中的方法

        package oop;
        //interface 定义的关键字,接口都需要实现
        public interface UserService{
            //接口中的所有定义其实都是抽象的public abstract
            //常量 public static final
            int AGE = 99;
        
            void add(String name);
            void delete(String name);
            void update(String name);
            void  query(String name);
        }
        
        =================================================
        package oop;
        
        public class UserServiceImp1 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) {
        
            }
        }
        ===============================================
        package oop;
        
        public interface TimeService {
        }
        
        
  14. 内部类

    package oop;
    
    public class Outer {
        private int id = 10;
        public void out(){
            System.out.println("这是外部类方法");
        }
    
        public class Inner{
            public void in(){
                System.out.println("这是内部类的方法");
            }
    
            //获得外部类的私有属性
            public void getID(){
                System.out.println(id);
            }
        }
        
    }
    ===============================================================
    package oop;
    
    import method.Person;
    
    public class Application {
        public static void main(String[] args) {
           Outer outer = new Outer();
           //通过这个外部类来实例化内部类
            Outer.Inner inner = outer.new Inner();
            inner.in();
            inner.getID();
        }
    }
    ====================================================
    package oop;
    
    public class Test {
        public static void main(String[] args) {
            //没有名字初始化类,不用将实例保持到变量中
            new Apple().eat();
            UserService1 userService = new UserService1() {
                @Override
                public void hello() {
    
                }
            }
        }
    }
    
    class Apple{
        public void eat(){
            System.out.println("1");
        }
    }
    
    interface UserService1{
        void hello();
    }
    

异常机制

  • 检查性异常

  • 运行时异常

  • 错误ERROR

  • Java把异常当作对象处理,并定义一个基类java.lang.Throwable作为所有异常的超类

  • 处理异常的机制,抛出异常,捕获异常。异常处理的五个关键字

    • try、catch、finally、throw、throws
  • 选中代码 按Ctrl+Alt+t进行代码段包裹选择如异常,if 等

    package com.kuang.exception;
    
    public class Test {
        public static void main(String[] args) {
            int a = 1;
            int b = 0;
            try {
                new Test().test1(1,0);
                new Test().test1(1,2);
            } catch (ArithmeticException e) {
                System.out.println("hahaha");
            }
    
            try{ //try监控区域
                System.out.println(a/b);
            }catch(ArithmeticException e){ //catch(想要捕获异常的类型)捕获异常
                System.out.println("程序出现异常,变量b不能为0");
            }catch(Throwable e){
                System.out.println("Throwable");
            }finally{//处理善后工作
                System.out.println("finally");
            }
        }
    
        //假设在方法中,处理不了这个异常,方法上抛出异常
        public  void test1(int a,int b) throws ArithmeticException{
            if(b == 2){
                throw new ArithmeticException();//主动抛出异常,一般在方法中使用
            }
            System.out.println(a/b);
        }
    }
    
  • 自定义异常

    package com.kuang.exception;
    
    public class MyException extends Exception {
        //传递数字>10
        private int detail;
    
        public MyException(int a) {
            this.detail = a;
        }
        //toString:异常的打印信息
    
        @Override
        public String toString() {
            return "MyException{" +
                    "detail=@@@@@" + detail +
                    '}';
        }
    }
    
<p> <strong> </strong> </p> <p class="MsoNormal" style="text-align:left;margin-left:21pt;text-indent:21pt;"> <br /> </p> <p class="MsoNormal"> <strong><span style="font-size:18px;"></span></strong> </p> <p class="ql-long-24357476"> <strong><span style="font-size:18px;color:#E53333;"><strong>想学好</strong></span><strong><span style="font-size:18px;color:#E53333;">JAVA必须要报两万的培训班吗?</span></strong><span style="color:#E53333;"></span><span id="__kindeditor_bookmark_start_82__"></span><br /> </strong> </p> <p class="ql-long-24357476"> <span id="__kindeditor_bookmark_end_83__"></span><strong><span style="color:#337FE5;">【课程背景】</span></strong> </p> <p class="ql-long-24357476"> <strong>JAVA是市场份额最大的编程语言,每天各大招聘网站上都会有数万个JAVA开发工程师的在招岗位,但是JAVA的技术体系庞大复杂,要想扎实掌握JAVA不是一件容易的事,线上学习相比线下两万起的高昂费用便宜了很多,而且具备学习时间灵活的优势,但是线上学习的劣势也很明显,没有线下那种学习氛围,碰到问题没法解决,在家学习很容易偷懒,极简JAVA学习营充分考虑到这些问题,通过每日实战编程练习,分队pk,助教答疑,作业点评,作业讲解,项目答辩等诸多环节充分激发你的学习热情,解决你学习中碰到的问题,让你花十分之一的钱学到JAVA的精髓,开启你的人生逆袭之路。</strong> </p> <p class="ql-long-24357476"> <strong><br /> </strong> </p> <strong><span style="color:#337FE5;">【专项的贴心服务】</span> <p class="ql-long-24357476"> 1. 学练结合:定期布置视频任务和编程实战练习:通过每天的视频任务统一大家的进度,以便同学更好的交流,针对每天的任务会有相应的编程实战练习,通过练习内化知识。<br /> 2. 分队PK:将就业营的同学分成几队,通过作业统计表统计每队提交作业情况进行PK,激发你的学习动力。<br /> 3. 助教讲师答疑:碰到任何问题,发到群里,助教和讲师十分钟内帮你解决问题,扫清学习中的障碍。<br /> 4. 助教点评讲解作业:你每天提交作业都会有助教进行点评,让你知道有什么问题怎么解决,每三天一次视频讲解作业,互动解答问题<br /> 5. 项目答辩:每个阶段学完会有项目答辩,通过做项目巩固前一阶段的知识点,锻炼编码能力。 </p> <p class="ql-long-24357476"> <img src="https://img-bss.csdnimg.cn/202007070905305336.png" alt="" /> </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">【往期训练营学习展示】</span> </p> <p class="ql-long-24357476"> <img src="https://img-bss.csdnimg.cn/202007070914574571.png" alt="" /> </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">【套餐内容简介】</span> </p> <p class="ql-long-24357476"> 本套课以市场就业和职位需求为核心,从JAVA入门到多领域实战,设计出学习路线,共分为二十大模块,分别是:JAVA面向对象、Object类与常用API、集合框架、IO流、反射注解、多线程与网络编程、Object类与常用API等等。 </p> <p> 同时采用理论讲解加实战演练的方式,既能让学员听懂听明白达到理解透彻,又能够在一个个真实实战案例中,让学员掌握真正有用的开发技能,从而进阶 JAVA 工程师! </p> <p> <br /> </p> <p class="ql-long-24357476"> 套餐中一共包含21门JAVA程,助你从零进阶JAVA工程师! </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">阶段一:</span><span style="color:#337FE5;">JAVA</span><span style="color:#337FE5;">基</span><span style="color:#337FE5;">础</span> </p> <p class="ql-long-24357476"> 课程1:《极简JAVA学习营开营篇》 </p> <p class="ql-long-24357476"> 课程2:《极简JAVAJAVA面向对象》 </p> <p class="ql-long-24357476"> 课程3:《极简JAVA:Object类与常用API》 </p> <p class="ql-long-24357476"> 课程4:《极简JAVA:集合框架》 </p> <p class="ql-long-24357476"> 课程5:《极简JAVA:IO流》 </p> <p class="ql-long-24357476"> 课程6:《极简JAVA:反射注解》 </p> <p class="ql-long-24357476"> 课程7:《极简JAVA:多线程与网络编程》 </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">阶段二:</span><span style="color:#337FE5;">数据库入门</span> </p> <p class="ql-long-24357476"> 课程8:《极简JAVA:MySql数据库》 </p> <p class="ql-long-24357476"> 课程9:《极简JAVA:JDBC与连接池》 </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">阶段三:</span><span style="color:#337FE5;">JAVA WEB</span> </p> <p class="ql-long-24357476"> 课程10:《极简JAVA:HTML5与CSS3》 </p> <p class="ql-long-24357476"> 课程11:《极简JAVA:极简JAVA十一:Javascript与Jquery》 </p> <p> 课程12:《极简JAVA:BootStrap》 </p> <p class="ql-long-24357476"> 课程13:《极简JAVAJAVA Web》 </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">阶段四:框架实战</span> </p> <p class="ql-long-24357476"> 课程14:《极简JAVA:Mavean入门》 </p> <p class="ql-long-24357476"> 课程15:《极简JAVA:MyBatis框架》 </p> <p class="ql-long-24357476"> 课程16:《极简JAVA:Spring框架》 </p> <p class="ql-long-24357476"> 课程17:《极简JAVA:Spring Mvc》 </p> <p class="ql-long-24357476"> <span id="__kindeditor_bookmark_end_251__"></span><span id="__kindeditor_bookmark_end_247__"></span>课程18:《极简JAVA:Oracle数据库》 </p> <p class="ql-long-24357476"> 课程19:《极简JAVA:Git入门》 </p> <p class="ql-long-24357476"> 课程20:《极简JAVA:Linux入门》 </p> <p class="ql-long-24357476"> 课程21:《极简JAVA:SpringBoot》 </p> <p> <br /> </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">【课程特色】</span> </p> <p class="ql-long-24357476"> 1、易理解:讲师思路清晰、节奏明确、从易到难讲解透彻明白; </p> <p class="ql-long-24357476"> 2、知识全:知识全面系统,从JAVA入门到实战,由易到难,让你彻底掌握JAVA开发; </p> <p class="ql-long-24357476"> 3、重实战:涵盖大量实战项目,锻炼你的动手实操能力,面向工作编程; </p> <p> <br /> </p> <p class="ql-long-24357476"> <span style="color:#337FE5;">【面向人群】</span> </p> <p class="ql-long-24357476"> 1、在校计算机专业或者对软件编程感兴趣的学生; </p> <p class="ql-long-24357476"> 2、零基础想学JAVA却不知道从何入手 </p> <p class="ql-long-24357476"> 3、囊中羞涩,面对两万起的JAVA培训班不忍直视 </p> <p class="MsoNormal"> 4、在职没有每天大块的时间专门学习JAVA </p> </strong>
相关推荐
<p> <span style="font-size:14px;">一、课程简介</span><br /><span style="font-size:14px;">这是<span style="color:#E56600;">『Java学习指南系列』</span>的第20篇教程 ,是Java开发的高级课程,介绍JavaFX的高级技术。</span><br /><span style="font-size:14px;">JavaFX教程分为两篇:JavaFX入门篇,JavaFX高级篇。</span><br /><br /><span style="font-size:14px;">本篇课程的主要以实例为主,穿插必要的理论章节。以实际工程运用为背景,演示各种应用级技术的实现方式。</span> </p> <p> <span style="font-size:14px;"><br /></span><span style="font-size:14px;">二、主要内容 </span><br /><span style="font-size:14px;">本篇配备充分的实例,包含以下内容:</span><br /><span style="font-size:14px;">* 界面线程与工作线程的基本原理</span><br /><span style="font-size:14px;">* 定时任务</span><br /><span style="font-size:14px;">* 小任务,即一次性的短任务</span><br /><span style="font-size:14px;">* 进度条定制</span><br /><span style="font-size:14px;">* 对话框定制</span><br /><span style="font-size:14px;">* 滚动窗口ScrollPane的使用</span><br /><span style="font-size:14px;">* 弹出式窗口 Popup的使用方法</span><br /><span style="font-size:14px;">* 拖放技术 Drag And Drop的使用方法</span><br /><span style="font-size:14px;">* 本地程序调用</span><br /><span style="font-size:14px;">* 与网站后台的交互方法</span><br /><br /><span style="font-size:14px;">三、课程体系</span><br /><span style="font-size:14px;"><span style="color:#E56600;">〖Java学习指南系列〗</span>:包含入门与进阶语法,Swing桌面开发,安卓开发,JavaFX开发,网络通信Socket,数据结构与算法等课程。</span><br /><span style="font-size:14px;"><span style="color:#E56600;">〖网站开发系列〗</span>:包含网页基础、网站入门、数据库、网站中级、FreeMarker、网站高级、项目应用、MyBatis、Redis等课程。</span><br /><span style="font-size:14px;"></span> </p>
Java程序员居家旅行必备课程 ☆<br /> <br /> Java学习指南系列的第4篇,介绍基于Java Swing的的高级应用技术。本篇的前一篇是Swing入门篇。<br /> Swing系列教程分为两篇:(1) Swing入门篇 (2) Swing高级篇。<br /> <br /> 本篇内容至少包含:<br /> - 高级绘制技术,包含线型、渐变色、文本的精确绘制<br /> - 不规则形状及图表的绘制<br /> - 工作线程与界面线程的原理<br /> - 短任务、长任务、定时任务的应用举例<br /> - 弹出式窗口 Popup的使用方法<br /> - 短消息提示 Toaster 的设计与使用<br /> - 事件处理机制,鼠标键盘事件处理,以及一个基于键盘操作的“推箱子”游戏 <br /> - 多行文本的显示<br /> - 图片操作:缩放、剪裁、旋转、镜像,以及一个屏幕截图程序的实例<br /> - 管理型应用界面的框架<br /> - 向导型应用界面的框架<br /> - 文档型应用界面的框架<br /> - 拖放支持 Drag & Drop,一个可拖拽排序的列表,以及一个拼图游戏的实现<br /> <br /> * 课程特色 *<br /> 轻快 - 采用小章节教学,学起来轻松<br /> 实用 - 以实际工程需要出发来设计课程<br /> 有趣 - 穿插大量特效实例,增加趣味性和学员的成就感<br /> 专业 - 课程中采用的代码库,就是经过良好封装的成熟的库<br /> <br /> 本篇穿插多个实例,通过实例,综合运用多种技术,使学员对项目的构建有所有认识。<br />
<p> <span><span style="font-size:14px;"><strong>一、课程简介</strong></span></span> </p> <p> <span><span style="color:#E56600;font-size:14px;">  『</span><span style="color:#E56600;font-size:14px;">Java学习指南系列</span><span style="color:#E56600;"></span><span style="color:#E56600;font-size:14px;">』</span></span><span>的第21篇教程 ,MyBatis 篇,是Java系列的高级课程。本篇介绍 MyBatis 的使用方法,使用 MyBatis 进行数据库开发的相关技术。</span> </p> <p> <span><span></span><span>    MyBatis 是一个基于JDBC的数据库工具框架,使用它可以快速地实现对数据库的访问操作。与之相似的框架还有 af-sql 和 Hibernate。</span><span></span><span style="font-size:14px;"></span><span style="font-size:14px;"></span><br /> </span> </p> <p> <span><span style="font-size:14px;"><br /> </span></span> </p> <p> <span><span><strong>二、主要内容 </strong></span><span style="font-size:14px;"><strong></strong></span></span> </p> <span style="color:#3D3D3D;"></span> <p> <span style="font-size:14px;">本篇主要包含以下内容:</span> </p> <p> <span style="font-size:14px;">* 在项目中加入 MyBatis 支持</span> </p> <p> <span style="font-size:14px;">* 基于 MyBatis 的查询</span> </p> <p> <span style="font-size:14px;">* 基于 MyBatis 的插入,自增主键的配置</span> </p> <p> <span style="font-size:14px;">* 基于 MyBatis 的更新与删除操作</span> </p> <p> <span style="font-size:14px;">* ResultMap 自定义结果映射</span> </p> <p> <span style="font-size:14px;">* Dynamic SQL 动态可变的SQL</span> </p> <p> <span style="font-size:14px;">* 注解方式的 Mapper定义</span> </p> <p> <span style="font-size:14px;">* MyBatis 在Web项目中的应用,全局工厂实例的定义</span> </p> <p> <span style="font-size:14px;">* 添加Log4j支持,输出MyBatis的日志</span><br /> <span style="font-size:14px;"></span> </p> <p> <span><span style="font-size:14px;"><strong>三、课程体系</strong></span></span> </p> <p> <span><span style="font-size:14px;">〖Java学习指南</span><span style="font-size:14px;">系列</span><span style="font-size:14px;">〗</span></span><span>:包含入门与进阶语法,Swing桌面开发,安卓开发,JavaFX开发,网络通信Socket,数据结构与算法等课程。</span> </p> <p> <span><span style="color:#E56600;font-size:14px;">〖网站开发</span><span style="font-size:14px;">系列</span><span style="color:#E56600;"></span><span style="color:#E56600;font-size:14px;">〗</span></span><span><span style="color:#E56600;font-size:14px;">:</span><span style="font-size:14px;">包含网页基础、网站入门、数据库、网站中级、FreeMarker、网站高级、项目应用、MyBatis、Redis等课程。</span></span> </p>
<p> <span>一、课程简介</span> </p> <p> <span>这是</span><span><span style="color:#E56600;font-size:14px;">『</span><span style="color:#E56600;font-size:14px;">Java学习指南系列</span><span style="color:#E56600;font-size:14px;"></span><span style="color:#E56600;font-size:14px;">』</span></span><span>的第19篇教程 ,是Java开发的高级课程,介绍JavaFX的入门技术。</span> </p> <p> <span style="font-size:14px;">JavaFX教程分为2篇:JavaFX入门篇 , JavaFX高级篇。</span> </p> <p> <span style="font-size:14px;"></span> </p> <p> <span>二、主要内容 </span> </p> <p> <span><span style="font-size:14px;">本篇介绍JavaFX的基本技术,至少包括以下方法:</span><br /><span style="font-size:14px;">* 基本控件的使用 Label Button ImageView等</span><br /><span style="font-size:14px;">* 基本布局的使用 BorderPane, HBox, VBox等</span><br /><span>* </span><span style="font-size:14px;">常用形状的使用 Shape</span><br /><span>* </span><span style="font-size:14px;">事件处理的基本方法</span><br /><span>* </span><span style="font-size:14px;">ListView,  TreeView,  TableView, TreeTableView的基本用法</span><br /><span>* </span><span style="font-size:14px;">JavaFX CSS样式的用法</span><br /><span>* </span><span style="font-size:14px;">FXML界面和业务分离的用法等。</span><br /></span> </p> <p> <span></span> </p> <span>* 以全局实例管理为例,演示一般性的框架设计方法</span><br /><span style="font-size:14px;"></span><br /><p> <span>三、课程体系</span> </p> <p> <span>〖Java学习指南<span>系列</span>〗</span><span>:包含入门与进阶语法,Swing桌面开发,安卓开发,JavaFX开发,网络通信Socket,数据结构与算法等课程。</span> </p> <p> <span>〖网站开发<span style="color:#E56600;">系列</span>〗</span><span><span style="color:#E56600;font-size:14px;">:</span><span style="font-size:14px;">包含网页基础、网站入门、数据库、网站中级、FreeMarker、网站高级、项目应用、MyBatis、Redis等课程。</span></span> </p>
<span style="font-size:14px;">一、课程简介</span><br /><p> <span style="font-size:14px;"><span style="color:#E56600;">『Java学习指南系列』</span>的第8篇教程 ,介绍MySQL数据库的安装使用,常见SQL语句,以及使用JDBC进行数据库开发的技术。</span> </p> <p> <span style="font-size:14px;"><br /></span> </p> <p> <span style="font-size:14px;">二、主要内容 </span> </p> <p> <span style="font-size:14px;">* MySQL的安装和使用</span> </p> <p> <span style="font-size:14px;">* 常用SQL语句,增删改查操作</span> </p> <p> <span style="font-size:14px;">* 高级SQL查询,多表关联查询</span> </p> <p> <span style="font-size:14px;">* 表的设计:主键,索引,内连接外连接,外键</span><span style="font-size:14px;"> </span> </p> <p> <span style="font-size:14px;">* MySQL配置管理: 用户授权,远程访问,备份还原</span> </p> <p> <span style="font-size:14px;">* JDBC连接: 使用JDBC连接数据库,执行增删改查操作</span> </p> <span style="font-size:14px;">* 基于JDBC数据库框架的设计(afsql框架),以此阐述数据库框架的设计原理</span><br /><p> <span style="font-size:14px;">* JDBC连接池,JDBC数据库开发的必备技术</span> </p> <p> <span style="font-size:14px;">* 数据库事务 Transaction 的支持 </span> </p> <p> <span style="font-size:14px;">* SQL的转义,数据库注入攻击的预防</span> </p> <p> <span style="font-size:14px;">* 数据库的动态访问:获取数据库和表的结构,根据表的结构自动生成POJO</span> </p> <p> <span style="font-size:14px;"><br /></span> </p> <p> <span style="font-size:14px;">三、课程体系</span> </p> <p> <span style="font-size:14px;color:#E56600;">〖Java学习指南</span><span style="font-size:14px;color:#E56600;">系列</span><span style="font-size:14px;"><span style="color:#E56600;">〗</span>:包含入门与进阶语法,Swing桌面开发,安卓开发,JavaFX开发,网络通信Socket,数据结构与算法等课程。</span> </p> <p> <span style="font-size:14px;color:#E56600;">〖网站开发</span><span style="font-size:14px;color:#E56600;">系列</span><span style="font-size:14px;"><span style="color:#E56600;">〗</span>:包含网页基础、网站入门、数据库、网站中级、FreeMarker、网站高级、项目应用、MyBatis、Redis等课程。</span> </p>
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页