中软国际Java EE全栈应用开发实训记录-Day1-锐单电子商城

一、软件安装

1.jdk

1.1 jdk安装

一般安装目录使用全英文

1.2 jdk环境配置

jdk版本：1.8 安装环境：win10 安装教程：可参考https://blog.csdn.net/weixin_44084189/article/details/98966787?ops_request_misc=%7B%22request%5Fid%22%3A%22165871027916781647525687%22%2C%22scm%22%3A%2220140713.130102334…%22%7D&request_id=165871027916781647525687&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_positive~default-1-98966787-null-null.142^v33new_blog_fixed_pos,185^v2control&utm_term=jdk1.下载和安装教程&spm=1018.2226.3001.4187

2.idea

2.1 idea安装

idea版本：2019 链接：https://pan.baidu.com/s/1e2QR4Kqf3trqgIRpc-lwaA 提取码：0n82

2.2 idea配置

idea安装后，安装软件注册后进行相应配置。这里需要配置的是maven所以需要环境maven安装包：链接：https://pan.baidu.com/s/1NdZMAfm_Ea6RkZpPIn7G5g 提取码：0g98 有关maven可参考配置https://blog.csdn.net/qq_42057154/article/details/106114515?ops_request_misc=%7B%22request%5Fid%22%3A%22165871390016781432962621%22%2C%22scm%22%3A%2220140713.130102334…%22%7D&request_id=165871390016781432962621&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_positive~default-1-106114515-null-null.142^v33new_blog_fixed_pos,185^v2control&utm_term=ideamaven配置&spm=1018.2226.3001.4187 下载完成后进行idea的配置：

在Configure的Settings配置全局环境(避免每次创建项目都要配置环境): 点击Apply后配置Mave：配置好maven后即可。

3.MySQL

3.1 MySQL安装

安装版本：5.7版(自行安装) 安装环境：win10 安装步骤：由于安装较早，具体安装步骤可参考https://blog.csdn.net/weixin_43579015/article/details/117228159?ops_request_misc=%7B%22request%5Fid%22%3A%22165870444716781685372682%22%2C%22scm%22%3A%2220140713.130102334…%22%7D&request_id=165870444716781685372682&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_positive~default-1-117228159-null-null.142^v33new_blog_fixed_pos,185^v2control&utm_term=mysql安装配置教程&spm=1018.2226.3001.4187(教程为8版) 可视化工具：可同时安装MySQL推荐的可视化工具Navicat

二、Java泛型

1.泛型的本质

一般类型的本质是参数类型，即所操作的数据类型被指定为参数。该参数类型可用于类、接口和方法的创建，分别称为泛型类、泛型接口和泛型方法泛型是JavaSE1.5的新特性

2.泛型的好处

Java引入泛型语言的好处是安全简单。在编译过程中，可以提前解释与操作类型相关的错误：泛型的优点是在编译过程中检查类型的安全性，所有强制转换都是自动和隐式的，以提高代码的重用率。在JavaSE1.5之前，没有泛型的情况的下，通过对类型Object参数的数实现任意化（Java所有类型都是Object类的子类)，任意化的缺点是在开发者可以预测实际参数类型的情况下进行显式强制类型转换。强制类型转换错误在错误的情况下，编译器可能不会提示错误，只有在运行过程中才会出现异常，这是一个安全隐患。

3.泛型理解前的基础练习

java package com.*;  public class SimpleGen { //    成员变量，结构时接受传输值，不确定什么类型     private Object obj; //    定义结构方法     public SimpleGen(Object obj){         this.obj=obj;     }  //    set和get方法     public void setObj(Object obj){         this.obj=obj;     }     public Object getObj(){         return this.obj;     }  //    定义普通方法 //    this.obj.getClass().getName()是反射     public void shoeType(){         System.out.println("obj的类型：" this.obj.getClass().getName());     }      public static void main(String []args){ //        创建对象         SimpleGen s = new SimpleGen(99);         s.shoeType(); //        强制转换 //        String obj1 = (String) s.getObj();         Integer obj1 = (Integer) s.getObj();         System.out.println(obj1);          SimpleGen s2 = new SimpleGen("zhangsan");         s2.shoeType();         String obj2 = (String)s2.getObj();         System.out.println(obj2);      } }

4.泛型基础练习

java package com.*;  public class SimpleGen1<T> {     //    成员变量，结构时接受传输值，不确定什么类型     private T obj;     //    定义结构方法     public SimpleGen1(T obj){         this.obj=obj;     }      //    set和get方法     public void setObj(T obj){         this.obj=obj;     }    public T getObj(){
        return this.obj;
    }

    //    定义普通方法 //    this.obj.getClass().getName()是反射
    public void shoeType(){
        System.out.println("obj的类型："+this.obj.getClass().getName());
    }

    public static void main(String []args){ //        创建对象
        SimpleGen1<Integer> s = new SimpleGen1<Integer>(99);
        s.shoeType(); //        强制转换 //        String obj1 = (String) s.getObj();
        Integer obj1 = (Integer) s.getObj();
        System.out.println(obj1);

        SimpleGen1<String> s2 = new SimpleGen1("张三");
        s2.shoeType();
        String obj2 = (String)s2.getObj();
        System.out.println(obj2);

    }

}

5.泛型类

5.1 泛型类例子

java package com.*;

//定义泛型类型<>内可以用任何字母或单词 
public class Generic<A> { //   
使用定义的泛型定义A类型，A类型由使用者new的时候制定
    private A key;

//    定义另一个成员变量
    private String str; //    构造方法
    public Generic(A key) {
        this.key = key;
    }

    public A getKey() {
        return key;
    }

    public void setKey(A key) {
        this.key = key;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    public static void main(String []args){
        Generic<Integer> g1 = new Generic<>(100);
        Integer key = g1.getKey();
        System.out.println(key);

        Generic<String> g2 = new Generic("张三");
        String key1 = g2.getKey();
        System.out.println(key1);
    } }

5.2 运行时出现错误

5.2.1 版本不兼容

这是由于jdk版本的问题

解决办法 1.file菜单下的Project Structure的： 2.file菜单下的Project Structure的： 3.file下的settings里面的Java Compiler下的：

根据以上三种解决办法可以了解到引起上述问题的原因是因为jdk版本的原因。需要将其更改为8即可。

5.2.2 类型引用错误

解决办法

使用引用类型String Interger Long，不能使用基础类型int long short byte boolean double float。

6.泛型方法

6.1 注意事项

(1)public 与返回值中间的<T,E…>可以理解为声明此方法为泛型方法; (2)与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T，E，K，V等形式的参数常于表示泛型 (3)在泛型类中使用泛型的方法无需再声明泛型 (4)是否拥有泛型方法，与其所在的类是否泛型类没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前。

6.2 泛型方法例子基础练习

java package com.*;

//定义普通类 
public class MyGenericMethod {
 //    定义泛型方法
  //    mvp  参数 
// <MVP>  定义的泛型
    public <MVP> void show(MVP mvp){
        System.out.println(mvp.getClass().getName());
    }

    public <MVP> MVP show2(MVP mvp){
        System.out.println(mvp.getClass().getName());
        return mvp;
    }


    public <MVP,ABC> MVP show3(MVP mvp,ABC abc){
        System.out.println(mvp.getClass().getName()+" "+abc.getClass().getName());
        return mvp;
    }

    public static void main(String[] args) { //        创建MyGenericMethod对象
        MyGenericMethod m = new MyGenericMethod(); //        mvp传字符串参数
        m.show2("daasan"); //        返回值的类型取决于传进来的第一个参数
        Integer mvp = m.show3(90,"张三");
        System.out.println(mvp);
    } 
    }

7.泛型接口

7.1 泛型接口例子的基础练习

首先定义接口

//定义泛型接口
public interface MyGenericInterface<E> { 
        
    void add(E e);
    E getE();
}

第一种实现方法，确定泛型类型：

//第一种方式实现泛型接口，在实现的时候就把泛型确定下来 
public class MyImpl implements MyGenericInterface<String>{ 
         
    @Override
    public void add(String s) { 
         
        System.out.println(s+"调用了myimpl的add()方法......");
    }

    @Override
    public String getE() { 
         

        return "调用了getE()方法......";
    }

    public static void main(String[] args) { 
         
        MyGenericInterface my = new MyImpl();
        my.add("张三");
        System.out.println(my.getE());
    } 
}

第二种实现方法，并未确定泛型类型，在创建对象时再确定泛型类型：

//第二种实现泛型接口方式定义了实现类，仍然不确定类型，new的时候确定类型
public class MyInpl2<T> implements MyGenericInterface<T>{ 
         
    @Override
    public void add(T t) { 
         
        System.out.println(t+"调用了不确定类型的add()方法......");
    }

    @Override
    public T getE() { 
         
        System.out.println("调用了不确定类型的getE()方法......");
        return null;
    }

    public static void main(String[] args) { 
          // 创建对象的时候确定了泛型类型
        MyGenericInterface<String> my = new MyInpl2<>();
        my.add("张三");
        my.getE();
    }
 }

8.泛型不支持协变

8.1 泛型不支持协变例子的基础练习

java import java.util.ArrayList;

public class ArrayTest {

    public static void main(String[] args) { 
    //        textArray();
        testGeneric();
    }

    private static void testGeneric(){
     //        泛型不支持协变，编译报错
        ArrayList<Fruit> fruits = new ArrayList<Fruit>();
        
    }

    private static void textArray() { 
    //        创建数组,new的时候，Apple是Fruit的子类
        Fruit[] fruits = new Apple[10]; 
        //        第一个元素是Apple
        fruits[0] = new Apple();
         //        第二个元素是HongFuShi
        fruits[1] = new HongFuShi(); 
        //        第三个元素是Fruit
        //        Fruit真正的类型是Apple，所以存放Fruit对象是可以编译但不能运行
         //        fruits[2] = newFruit(); 
         //        Fruit真正的类型是Apple，所以存放Orange对象是可以编译但不能运行
        fruits[3] = new Orange();
   	 } 
  } 
  //定义父类 
  class Fruit{} 
  //Apple是Fruit的子类 
  class Apple extends Fruit{ } 
  //HongFuShi是Apple的子类 
  class HongFuShi extends Apple{} 
  class Orange extends Fruit{}

结论：数组可以支持协变，但是泛型不支持协变。

资讯详情

中软国际Java EE全栈应用开发实训记录-Day1