Java之入门JavaWeb

package com.tang;

public class Test {
    public static void main (String args[]) {
        int i = 0; //整形
        double j = 2.2; //浮点数
        char k = 'k'; //字符数
        boolean a = true; //布尔值
        
    }
}

引用型数据类型有对象，接口，类等等

2.基础语法：

基础语法分为两种，一种是循环语句，一种是条件语句。

2.1循环语句:

第一种：

while( i < 100){

System.out.println(i);

}

第二种：

//这里要注意的是while()后面需要加；结尾，相当于是一个语句结尾，其实就是相当于{}这种不需要用；结尾，

其他的都属于暴露的语句都需要用；结尾。

do {

System.out.println(i);

i ++ ;

} while(i < 100);

第三种：for 循环：

基本语句示例如下：

中间是循环条件，满足条件则继续执行下一个语句，括号里面的语句是第一句只执行第一次，大括号里面是判断第二个的循环条件后执行的语句，再执行三个语句，就相当于大括号里面的内容是中间循环里面的内容。

for (int i = 0 ; i < 100 ; i ++){

System.out.println(i);

}

第四种：for each 循环

遍历数组,一维数组或者二维数组都可以。

其实标准的解释就是java底层会给一个个很小的 i 的空间去把需要遍历的东西的最小单位一个个存到底层。

int[] testArray = { 1,3,5,6,7,8,9};

for ( int i : f ){

System.out.println( i );

}

package com.tang;

public class Test {
    public static void main (String args[]) {
        
        
        //while循环
        int j = 0;
        while(j < 100){
            System.out.println(j);
            j++;
        }

        //do while循环
        int k = 0;
        do{
            System.out.println(k);
            k++;
        }while(k<100);

        //for 循环
        for(int f = 0;f < 100; f++){
            System.out.println(f);
        }
        
        /*
        一唯数组的构建，第一个是静态构建的省略式，第二个是静态构建，第三个是动态构建
        */
        int[] testArray = { 1,3,6,7,8,9};
        int[] testArray2 = new int[]{1,4,7,8,9};
        int[] testArray3 = new int[3];

        testArray3[1] = 1;
        testArray3[2] = 5;
        testArray3[0] = 3;


        //for each 循环 
        for(int s : testArray){
            System.out.println(s);
        }

        /*
        二维数组的构建，第一个是静态构建的省略式，第二个是静态构建，第三个是动态构建
        */
        int[][] testTwoArray = {{1,3,5,7,8},{1,4,7,8,9},{4,7,8,9}};
        int[][] testTwoArray2 = new int[][]{{1,3,7,8,9},{4,7,8,9,0},{2,4,7,9,0}};
        int[][] testTwoArray3 = new  int[2][3];
        
        
        for(int[] q : testTwoArray){
            for(int c : q ){
                System.out.print(c + " ");
            }
            System.out.println();
        }
    }
}

2.2条件语句：

条件语句又分为了3种if else , swich 语句 ? : 语句。

第一种： if else 条件语句：

if (){

}else if(){

}else{

}

第二种：

switch ( 变量) {

case 变量1 ：

语句；

break;

case 变量2 ：

语句；

break；

default :

语句；

break;

}

第三种：

三元运算符

// 这里需要主要的点就是问号前面是条件，？后是满足条件执行的语句，：后是不满足条件的语句。

System.out.println( i == 8 ? 9 : 8 );

package com.tang;

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

        //if else 条件语句
       int j = 0;
       if(j < 10){
           System.out.println("yes");
       }else if (j > 4){
           System.out.println("no");
       }{
            System.out.println("god damn good");
        }


       //switch 条件语句
       int k = 8;
       switch ( k ){
           case 1 :
               System.out.println("yes");
               break;
           case 2 :
               System.out.println("no");
               break;
           case 8 :
               System.out.println("god damn god");
               break;
           default:
               System.out.println("default");
               break;
       }

        //三元运算符
        System.out.println(k < 7 ? "yes ": "no") ;
    }
}

二.java基础类和重要概念：泛型，集合，异常，数组，面向对象，jvm的入门学习，类和方法的书写。

1.泛型 = 参数化数据类型：

1.1为什么会出现泛型：

在一开始我们每次写相同逻辑时的方法，类，接口时，每次因为传入里面的数据类型都不

一样结果因此要多写几个类和多几个方法或者接口，所以就出现了泛型，泛型的目的就是要同一套逻辑的程序但是

不同传入的数据类型的类，方法，接口用相同的代码。

1.2什么是泛型：

意思就是一套逻辑的方法，接口，方法不同传入数据类型用同一个方法，类或者接口。

再简单点就是把传入的数据类型变成可变的。 = 参数化类型。

1.3实现方法如下：

泛型实现其实就是接口，类，方法的撰写的时候做操作。

//类的实现方式：

public  class TestClass< E >{



}



//接口的实现方式：

public Interface TestInterface <E > {



}

//方法的实现方式：



public  <T>   T TestMethod (T t) {

}

2.集合：

2.1背景：

我们用基本的数组存数据的时候总是出现，一次定义太多的数组不能做到每次用多少就分配多少内存，会造成

内存浪费，那么这时候就出来了一个存数据的类，集合，为了让分配内存不浪费。

集合出现的原因其实就是为了合理的利用内存去存数据不要像数组一样，一次性new数组的时候，发现数组每次new的时候都是有部分的数组的空间没有使用，所以为了合理的利用内存去存储数据，就出现了集合。

2.2分类：

而集合的本质其实也是一个类，而我们每次用的时候是去new这个类，而调用类的方法。如下是集合的继承关系。

集合这个是object的子类

按照数据对象的不同分为了 Collection 对象和 Map对象。

按照数据对象的总类分为如下两个类，第一个用来存储传统的数据，单个数字或者单个对象。第二个是用来存(key,value)的对象的类。而又按照存储数据的方式，

Map类按照存数据的方式分为了： HashMap 类和 TreeMap类。

Collection 对象又按照数据是否排序和数据是否重复分为了 List 和 Set 类。

而List 类又按照存数据的方式分为了 LinkedList 和 ArrayList 。

而Set 类又按照存数据的方式分为了HashSet 和 TreeSet 类。

2.3实现方法如下：

具体使用场景：

List和Set使用场景：（1）List,Set都是继承自Collection接口，Map则不是（2）List特点：元素有放入顺序，元素可重复，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）（3）Set和List对比： Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。（4）ArrayList与LinkedList的区别和适用场景 Arraylist：优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低

1.Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。 2.如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

.TreeSet 是二差树（红黑树的树据结构）实现的,Treeset中的数据是自动排好序的，不允许放入null值 2.HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束 3.HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例

适用场景分析:HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。为快速查找而设计的Set，我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。

适用场景分析： HashMap和HashTable:HashMap去掉了HashTable的contains方法，但是加上了containsValue()和containsKey()方法。HashTable同步的，而HashMap是非同步的，效率上比HashTable要高。HashMap允许空键值，而HashTable不允许。

HashMap：适用于Map中插入、删除和定位元素。 Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

5.线程安全集合类与非线程安全集合类 LinkedList、ArrayList、HashSet是非线程安全的，Vector是线程安全的; HashMap是非线程安全的，HashTable是线程安全的; StringBuilder是非线程安全的，StringBuffer是线程安全的。

数据结构 ArrayXxx:底层数据结构是数组，查询快，增删慢 LinkedXxx:底层数据结构是链表，查询慢，增删快 HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals() TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

如上的关于集合的原文链接：java集合超详解_phial03的博客-CSDN博客

具体的实现方法：

类的多态来使用即可：

Set hashset = new HashSet();

3.数组：

3.1实现方式：

一维数组：

int[] i = {1,4,7,8,9,0};

int[] j = new int[4];

int[] k = new int[]{ };

二维数组：

int [] [] k = { { 1,3,6,7} , {4,7,8,9,0} } ;

4.面向对象：

4.1概念：

什么是面向对象，我把编程比喻成我们人拿洗衣机洗衣服这件事。

面向过程编程，就是我们先创建好洗衣机的各个区域，放洗衣液的区域，放衣服的区域等等，

然后再写放水的程序，搓衣服的程序，烘干的程序，拿衣服的程序。每一个过程我们都一个个编好程序。

面向对象编程，就是我们写俩个对象，一个人对象，他有属性和方法，方法是拿衣服等等。

一个是洗衣机，他又方法和属性，属性是放洗衣液的槽，放衣服的筒，方法是搓，烘干，和放水。

那么我们就简化成对两个对象编程了。

4.2特性：

继承，封装，多态

继承就是可以继承父类，封装就是可以用private修饰词把属性变成其他不能访问的属性。

多态就是父类的引用指向子类的对象。 Set <Integer> testSet = new HashSet() ;

5.jvm的入门学习：

5.1为什么用jvm：

在多个不同的操作系统上有不同的jvm，jvm的作用是：

java代码也就是.java文件通过javac 变成了字节码也就是 .class结尾的文件

字节码通过jvm编译变成的不同操作系统可以识别的机器代码 01010010101010 这种代码

5.2 jvm原理：

jvm说白了其实也是一个程序，这个程序虚拟的我们可以分为四个大部分：

方法区，栈区，堆区，程序计数器。

原理：

我们的class文件里面有类和对象和方法，和变量等等，但是我们的jvm是基于线程为基本单位来进行

识别和转化为底层代码的，所以就有了程序计数器，程序技术器就是记住哪一个线程执行到哪了。

一个线程进入到jvm，首先是把类加载到方法区，把属性都存好，在开始扫描类的方法，和对象，有扫到对应的对象放到堆里面，而扫到方法就放到方法区以栈的原理这样先进后出的方式使用起来，再就是对象的里面可能有些属性没有值在对应方法的时候会把类里面的属性赋值到对象中去，其实就是这样的基础的流程。

当然上面就是最基础的一个演练，细节还是要去研究一下jvm。

6.类和方法的书写：

其实就是大概的意思就是我们写类，方法，和接口其实在java语法的框架里面就是就是

class + 名词 {

}

这上面就是最简单的定义一个类的方式了，只是说我们有一些为了安全起见或者有一些特性的标识，我们就把

修饰词写到前面，而我把修饰词分为了三类且书写顺序都是按照如下：

外部修饰词 + 内部修饰词 + 特性修饰词：

举例：

public static final class TestClass {

}

public 是指外部的类可以调用这个类和使用这个类，对比还有private类

static 指的是类内部可以使用和调用这个类

final 指的是定下来的东西也就是定论的东西，定死了不能变了。

三.javaweb的基本流程和每一个的原理和使用，基本javaweb的代码的实现，servletcontext，response对象，request对象，如何衍生到mvc 。

javaweb的来源可以这么说：

我们创造了一个需求: 需要通过互联网获取到网络另一端的资源，并且任何数据都能以页面的方式呈现出来。

我们通过网络和网络设备，比如供应商(供应商其实本质就是一个类似于门的角色，把外网和内网隔绝，只能说你通过交钱，供应商愿意让你访问外网)交换机，路由器，无线wlan设备，ac，ap，和一个统一的交互数据的规则(也就是OSI七层模型)把世界上的所有终端连接在一起。

通过http响应请求协议(通过域名和url访问其他终端的协议)再结合浏览器这种在客户端的程序(客户端和服务端的概念其实就是相比较的，其实都是终端，访问数据的一方就是客户端，被访问的一端就是服务端)和在服务端的webServer(也就是服务端的程序)结合就可以实现从世界上的另一端访问世界的另一端的数据并且以页面的方式呈现出来。客户端的而浏览器负责发请求和渲染响应的数据，服务器的web Server用来从底层调用数据和给响应给客户端。

而上面这个的流程细化下来就是如下的流程，那这个流程里面的webServer调用底层的数据和调用的servlet的技术，以及前端的浏览器，和浏览器沟通的技术，jsp，html，css,javascript,这些都是javaweb技术。

也就是说，我们为了实现让世界上每个人都可以看到其他人终端的数据资源并且以页面的方式呈现出来一定要满足如下的

几点：

1.网络。

2.客户端，服务端，http协议。

而我们的javaweb技术的本质也就是实现客户端和服务端之间沟通的技术。

1.基本流程如下：

什么是客户端：

客户端其实就是为用户提供需求的一个软件，比如浏览器：他可以发请求到服务器，他可以渲染和接受响应。
什么是请求，什么是响应？

请求其实就是基于http协议也就是基于OSI 七层协议上的应用层上的一个数据报文发给了服务器。

请求分：

1.get和post的本质是方法，是调用的方法，再往下的本质就是http协议下的tcp的链接也就是数据+各种头。

可以参考一下如下文章的解释响应和请求的分类，其实都是行头体，请求行，请求体，请求头。

(125条消息) HTTP响应（作用，格式，响应码的组成和分类，常见响应状态码）_小宝的宝呢的博客-CSDN博客

2.get和post的区别。

1.一个是从服务器要数据。一个是要给服务器东西。 2.本质其实都是tcp链接 3.get只要发一下包。post要发两次，第一次是确认，第二次是发数据包。

3.浏览器的本质其实就是一个解析和渲染和访问域名的一个应用程序
什么是web服务器，web服务器其实说白了也是服务器上的一个程序，他的作用就两个：

1.把客户端发来的请求转化为HttpServletRequest对象给到servlet程序。

2.把servelt 的 HttpServletResponse对象转化为响应给到客户端。

3.访问服务器的文件系统里面的静态资源转化为响应给客户端。
什么是servlet ，servlet是javaweb的一个程序，他的目的两个

1.访问数据库提出数据出来。

2.处理请求和回响应对象。
如何在webserver 能够匹配对应的servlet程序呢，又如何能够有正确的依赖包呢，那么web.xml文件会把请求

的请求行和我们的servelet的名字通过，servlet-mapping 和 servlet 进行绑定，就可以实现对应的请求访问对应

的servlet程序。

而依赖的导入依靠的就是pom.xml的依赖的导入了。

2.javaweb中 servlet的程序编写要完成两个东西:

一个是环境的准备，建一个 maven的 webapp的项目，jdk，mvn，tomcat，准备好

二个是项目框架，有java，有source，有pom.xml的东西和web.xml的东西

2.1webapp的项目：

2.2maven的配置：

2.3JDK的配置：

2.4tomcat配置：

二个是项目框架，有java，有source，有pom.xml的东西和web.xml的东西

2.5项目框架：

2.6web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                      https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
</web-app>

web.xml也可以在tomcat里面的example里面去寻找，如下：

2.7pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tang</groupId>
  <artifactId>TestReview</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>JavaWeb_Test1 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>

    <!-- https://mvnrepository.com/artifact/org.apache.tomcat/tomcat-servlet-api -->
    <dependency>
      <groupId>org.apache.tomcat</groupId>
      <artifactId>tomcat-servlet-api</artifactId>
      <version>10.0.4</version>

    </dependency>
    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <version>5.0.0</version>
    </dependency>
    <dependency>
      <groupId>jakarta.servlet.jsp</groupId>
      <artifactId>jakarta.servlet.jsp-api</artifactId>
      <version>3.0.0</version>
    </dependency>
    <dependency>
      <groupId>org.glassfish.web</groupId>
      <artifactId>jakarta.servlet.jsp.jstl</artifactId>
      <version>3.0.1</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>


  </dependencies>

  <build>
    <finalName>TestReview</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

三个就可以开始写程序了。

3.代码实现：

servlet的来源：

前面开头说了javaweb的来源，而servlet的来源其实就是在客户端给到我们服务端请求后，我们需要用web servet去解析请求后，得让服务器有一个程序去执行这个请求，也就是去取底层数据，去进行一个不同请求的逻辑的切换和操作数据给到回应给客户端，而此时就有了很多个server applet的程序，他就是去做这件事，只要web server 把请求给到servlet，servlet就会去取数据，操作响应对象给webserver，进行不同的servlet程序之间的切换。

servlet的本质又是什么呢？

第一步：

其实就是在客户端访问服务端的时候，服务端的web server 要调用servlet ，而每个客户端发来的请求(也就是url里面的get方法或者就是http请求给到web server)而我们会通过我们编的web.xml去把对应请求的关键字和我们的servlet的类进行匹配。

第二步：

匹配好之后，我理解的是，每一个web服务器，编译器会编一个类在main方法里面new一个servletContext对象和去new 对应的类的对象，调用对象里面的方法，一般都是doGet方法，或者doPost方法。而这两个对应的方法中会对两个对象进行操作，一个是response对象，一个是request对象，而这里的这个servlet里面的方法里面操作的两个对象就会被web服务器给解析对应为http响应的格式最好给到客户端的浏览器，浏览器再对响应进行渲染。

按照上面的操作步骤把环境和框架结构弄好后就可以开始写servlet。

servlet的操作步骤如下：

第一,写web.xml的映射和写servlet的java程序

加两个java程序：

web.xml程序：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
                      https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
    
    <servlet>
        <servlet-name>Hello</servlet-name>
        <servlet-class>com.tang.ServletTest1</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>Hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    
    <servlet>
        <servlet-name>Hello2</servlet-name>
        <servlet-class>com.tang.ServletTest2</servlet-class>
        
    </servlet>
    
    <servlet-mapping>
        <servlet-name>Hello2</servlet-name>
        <url-pattern>/hello2</url-pattern>
    </servlet-mapping>
</web-app>

第二，继承HttpServlet

第三，crtl + o 把 doGet 方法和 doPost 方法写处理。按住crtl 进行多选。

第四，开始写三大宝器： resp 对象， req 对象， servletcontext对象。

ServletTest1:

package com.tang;


import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class ServletTest1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter testOutput = resp.getWriter();
        testOutput.println("Hello world");
        ServletContext context = this.getServletContext();
        String array = " this is what you get from context"; //写一个String对象，放入一串字符
        context.setAttribute("fromContext" , array ); //setAttribute去把这个对象对应一个字符串方便后续进行get出来，  前面是Sting ， 后面是 object 类 

    }

    @Override
    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
ServletTest2:

package com.tang;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class ServletTest2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter out = resp.getWriter();
        ServletContext context = this.getServletContext();
        String test =  (String)context.getAttribute("fromContext");//从servletcontext中get出来在转换一下，因为在set的时候是object类。
        out.println(test);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

浏览器结果：

YoYoYoWhatIsUp

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java之入门JavaWeb

中间是循环条件，满足条件则继续执行下一个语句，括号里面的语句是第一句只执行第一次，大括号里面是判断第二个的循环条件后执行的语句，再执行三个语句，就相当于大括号里面的内容是中间循环里面的内容。1.get和post的本质是方法，是调用的方法，再往下的本质就是http协议下的tcp的链接也就是数据+各种头。一个线程进入到jvm，首先是把类加载到方法区，把属性都存好，在开始扫描类的方法，和对象，有扫到对应的对象就。这上面就是最简单的定义一个类的方式了，只是说我们有一些为了安全起见或者有一些特性的标识，我们就把。
复制链接

扫一扫