Java01

Java安装
4号晚上在我学Java朋友的帮助下还费了一晚上的时间没安好气到胸闷
感谢：https://www.runoob.com/w3cnote/windows10-java-setup.html 和https://blog.csdn.net/weixin_40575457/article/details/81625169
我顺着默认路径安装的之后剪切到了D盘之后在环境配置里将Java的路径往上移了
Java -version javac -version
过去学习编程语言的方法经验和教训：要多敲不要害怕
对Java平台还没有多少了解因为安装实在是废了好久还有eclipse和idea 我找了好久没找到注册码
加油

Java的加载与执行

编译阶段

检查java源程序(xxx.java)是否符合Java语法如果符合则编译(使用jdk自带的javac.exe命令)生成正常的字节码文件(xxx.class)
javac使用规则：javac java源文件路径
一个Java源文件可以生成多个.class文件
.class文件是最终要执行的文件所以.class文件生成后，删除.java源文件并不影响程序执行
字节码文件不是纯粹的二进制，无法在操作系统中直接执行

底层java程序是跨平台的所以就算是在Windows操作系统上写完的.class文件在其他安装了Java虚拟机的操作系统上也行

运行阶段

JDK安装后除了自带的javac.exe之外，还有一个命令/工具：java.exe--------java 类名(xx.class)
java A命令会启动 JVM,JVM会启动类加载器classLoader classLoader会去硬盘上搜索A.class文件,搜索到后将该字节码文件装载到JVM中
JVM将A.class字节码文件解释成二进制文件1001数据
然后操作系统执行二进制和底层硬件平台交互

JDK JVM JRE的关系

JDK/bin 该目录下存放了很多命令 javac负责编译 java负责运行
JDK（Java Development Kit）JAVA开发工具

JRE (Java Runtime Environment）Java运行环境

JVM是Java Virtual Machine（Java虚拟机）

JVM 就是我们常说的java虚拟机，它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行，也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。

只有JVM还不能成class的执行，因为在解释class的时候JVM需要调用解释所需要的类库lib，而jre包含lib类库。

JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。

JRE 是Java运行环境，并不是一个开发环境，所以没有包含任何开发工具（如编译器和调试器），只是针对于使用Java程序的用户

JDK 是整个JAVA的核心，包括了Java运行环境JRE（Java Runtime Envirnment）、一堆Java工具（javac/java/jdb等）和Java基础的类库（即Java API 包括rt.jar）。

　 ①SE(J2SE)，standard edition，标准版，是我们通常用的一个版本，从JDK 5.0开始，改名为Java SE。

　　②EE(J2EE)，enterprise edition，企业版，使用这种JDK开发J2EE应用程序，从JDK 5.0开始，改名为Java EE。

　　③ME(J2ME)，micro edition，主要用于移动设备、嵌入式设备上的java应用程序，从JDK 5.0开始，改名为Java ME。

JDK安装目录里真正在运行java时起作用的是以下四个文件夹：bin、include、lib、 jre。

bin:最主要的是编译器(javac.exe)

include:java和JVM交互用的头文件

lib：类库

jre:java运行环境

一次编译，到处运行
在程序的运行阶段则是在一个特定的平台上，由这个平台来执行编译生成的程序。编译器的作用就是沟通源程序和程序的运行平台。源程序相对于一个运行平台来说是不可识别的，但当编译器将源程序编译成为这个平台所能够识别的目标语言以后，程序就可以在这个平台上运行了。Java虚拟机是一个平台，DOS 和 Windows 也是平台。
1. 生成的这个.class文件就是可以到处运行的文件
2. 2.jAVA提供了各种不同平台上的虚拟机制，所以可以实现“到处”

JAVA代码执行顺序

package w0928;

class HelloA {

    public HelloA() {
        System.out.println("HelloA");
    }
    
    { 
        int aaa = 3;
        System.out.println("这里是A的非静态区 I'm A class 在A构造函数之前完成");
        System.out.println("A变量"+aaa); }
    
    static { 
        String aastatic = "staticA";
        System.out.println("staticA句子");
        System.out.println("staticA变量："+aastatic);}

}

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }
    
    { int bbb = 4;
      System.out.println("这里是B的非静态区 I'm A class 在B构造函数之前完成");
      System.out.println("B变量："+bbb); }
    
    static {         
    String bbstatic = "staticB";
    System.out.println("staticB句子");
    System.out.println("staticB变量："+bbstatic); }
    
    public static void main(String[] args) { 
        System.out.println("la la land 这里是main函数");
        HelloB bb = new HelloB();
    }

}
/*
 *
staticA句子
staticA变量：staticA
staticB句子
staticB变量：staticB
la la land 这里是main函数
这里是A的非静态区 I'm A class 在A构造函数之前完成
A变量3
HelloA
这里是B的非静态区 I'm A class 在B构造函数之前完成
B变量：4
HelloB*/
/*
 * 这个就比较直接了 在public static类里 main函数之前如果有静态代码 先执行这个(此类若恰好又是继承类 先执行父辈的静态代码)
 * 回到main函数 创建对象 赋给对象引用  静态代码只执行一次 所以直接进入非静态代码--构造函数
 * 初始化字段发生在构造函数之前*/

.................................

HelloWorld出现

使用dos
1. 在文件夹里新建个txt再改后缀名 win10你能不能别气我了
  
  public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!0928"); } }
  
  之后在dos里切换目录名并执行
  
  C:Users用户名>d:
  
  D:>cd java
  
  D:java>cd dos
  
  D:javados>javac HelloWorld.java javac 源程序
  
  D:javados>java HelloWorld java 类名 Hello World!0928
使用eclipse

创建project--创建包--创建类。。。就这么来吧

1.何谓对象？

　　在Java中有一句比较流行的话，叫做“万物皆对象”，这是Java语言设计之初的理念之一。要理解什么是对象，需要跟类一起结合起来理解。下面这段话引自《Java编程思想》中的一段原话：

　　“按照通俗的说法，每个对象都是某个类（class）的一个实例（instance），这里，‘类’就是‘类型’的同义词。”

Java 变量类型
类变量(static)：类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。静态变量在第一次被访问时创建,无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。静态变量储存在静态存储区。具有默认值
实例变量：声明在一个类中，但在方法、构造方法和语句块之外，不过没有 static 修饰。实例变量具有默认值
局部变量：声明在类的方法、构造方法或者语句块中；当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用

public class Variable{
    static int allClicks=0;    // 类变量
    String str="hello world";  // 实例变量
    public void method(){
 
        int i =0;  // 局部变量
 
    }
}

类变量和实例变量的区别是什么
类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则各归各的；
静态变量属于类，该类不生产对象，通过类名就可以调用静态变量。实例变量属于该类的对象，必须产生该类对象，才能调用实例变量。
只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间/实例变量必须创建实例对象之后才会申请空间

Java类中初始化成员变量(类中声明方法外)不用赋值，而初始化局部变量(方法内)就要赋值 https://blog.csdn.net/x541211190/article/details/75287711

Java变量作用域
根据作用域的不同，一般将变量分为不同的类型：类变量、局部变量、方法参数变量及异常处理参数变量
异常处理参数变量的作用域是在异常处理块中，该变量是将异常处理参数传递给异常处理块，与方法参数变量类似。

float double浮点数如果后面没有跟任何修饰，它的类型为双精度

Java有浮点型有两个，float和double，Java默认浮点类型是double。浮点类型的字段长度和表数范围是固定的，与其它因素无关。
double类型：double类型数值为双精度浮点数，占8个字节，64位。这是Java浮点型的默认类型，如3.14，后面不写D。
float类型：float类型为单精度浮点数，占4个字节，32位。如果想表示float类型，需要在数字末尾加F或者f，例如3.14f,3.14F. (float f=1.2d错误)

public class test01 {
     public static void main(String[] args) {
        float f1= 1.11;
        
        System.out.println(f1);
     }
}
ERROR:Type mismatch: cannot convert from double to float

在没有声明的情况下：float f=3.4; 为默认情况，也就是默认小数3.4此时为double类型，所以float f=3.4;这个写法是错误的，因为此时，

公式是：左边是 float类型=右边是double类型，公式不成立。

自动类型转换

2. 两个整数相加，结果默认转化为int

short s = 5;
s = s + 10; // 这里会出现编译错误，因为s参与运算，这时会自动转换为int型，s + 10 的值为int型，int型不能直接赋值给short型，需要强制转化
s += 10; // 这里不会出现错误，因为扩展赋值运算符自带强转功能

byte b = 27;
byte c = 26;
byte d =(byte)( b + c);

 public static void main(String[] args) {
        byte x = 3;
        double y = 15.0;
        int z = (int)x/y*2;
        System.out.println(z);
     }
Type mismatch: cannot convert from double to int

  Type methodA(byte x, double y) {
     return (short)x / y * 2;       所以x在此被强制转成了short?最终结果因为y还是double
  }
  Type的类型将为double。

单：

整数和浮点数都能进行取余运算。

 int i = 0xFFFFFFF1;  
 int j = ~i;
 System.out.println(i);
 System.out.println(j);
 * 0xFFFFFFF1的二进制表示为：
   1111 1111 1111 1111 1111 1111 1111 0001
       符号位不变，其余各位按位取反，然后加1
   1000 0000 0000 0000 0000 0000 0000 1111
        就是-15.

采用“&&”和“||”的目的是为了加快运算速度

简单数据类型及其对应包装类

自学System，Integer，Math类，总结学习心得
描述一下这些类的用途，特点，基本字段（field），常用方法（method）

Integer类:

包装一个对象中的原始类型int的值。类型为Integer的对象包含一个单一字段，其类型为int
基本字段field：BYTES/MAX_VALUE/MIN_VALUE/TYPE

java int与integer的区别

int 是基本类型，直接存数值，而integer是对象，用一个引用指向这个对象
1.Java 中的数据类型分为基本数据类型和复杂数据类型
int 是前者而integer 是后者（也就是一个类）；因此在类进行初始化时int类的变量初始为0.而Integer的变量则初始化为null.

Java中每种内建类型都有相应的外覆类。float Float;double Double;string String等
当需要往ArrayList，HashMap中放东西时，像int，double这种内建类型是放不进去的，因为容器都是装 object的，这是就需要这些内建类型的外覆类了
int和Integer不能够互用，因为他们两种不同的数据类型；

MATH:

基本字段field：E/PI

SYSTEM:

System类提供的System包括标准输入
field:err /in /out

Java对象与Java对象引用

mark：https://blog.csdn.net/qq_26805137/article/details/52945688

美图秀秀你连拼图都不行吗？？？？？？？？？？？？？？？啊。。

C++与JAVA的创建对象

先mark https://blog.csdn.net/u014453898/article/details/67134952 脚本之家 https://www.jb51.net/article/128419.htm

两种语言里都含有 new 操作符，但它们的含义大不相同，这与它俩的变量管理方式有关。

在 Java 中，只有当你使用 new 操作符时，才会真正在内存中申请一块空间，创建一个新对象，并将该对象绑定到你所定义的变量名上。其它情况下，要么是将已有对象绑定到某个变量名上，要么就是定义的变量名是个空引用，没有绑定任何对象。

也就是说，定义变量名只是创建了一个新的标识符，跟创建对象没有关系，创建对象必须通过 new 来完成，只有创建对象时才会申请内存空间。

但在 C++ 中，当你定义了一个变量 s 时，即使你没有给它赋值，也意味着你不但创建了一个新的标识符，同时还在栈中申请了对应的内存空间。

因此，C++ 中定义的变量名不仅仅是个标识符，还自动关联着栈中的一块内存空间。

而 C++ 中的 new 操作符表示的是在堆中申请内存，因为栈中的内存在运行时期大小是固定且有限的，因此需要动态内存分配的时候就需要用 new 来实现。这类似于 C 里面的 malloc 函数，只不过 new 操作符还封装了其它的操作。

总结而言，Java 中的变量名仅仅是一个用于引用内存中实际对象的标识符，如果你没给它关联对象，它就为空引用。而 C++ 中的变量名（非指针类型），虽然也是标识符，但却始终关联着实际的内存空间，当我们看到一个变量（非指针类型）时，就知道它代表着一块实际的内存空间。

https://blog.csdn.net/new_abc/article/details/37928275 https://blog.csdn.net/bsbhenry/article/details/84842861

咋回事。。每次进来都得重新刷新一次

c++ 虚函数纯虚函数

虚函数：

在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数，用法格式为：virtual 函数返回类型函数名（参数表） {函数体}；实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。

纯虚函数 :

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0” 　virtual void funtion1()=0

虚函数和普通的函数实际上是存储在不同的区域的，虚函数所在的区域是可被覆盖（也称复写override）的，每当子类定义相同名称的虚函数时就将原来基类的版本给覆盖了，另一侧面也说明了为什么基类中声明的虚函数在后代类中不需要另加声明一律自动为虚函数，因为它所存储的位置不会发生改变。而普通函数的存储区域不会覆盖，每个类都有自己独立的区域互不相干。

Java反射

感谢大佬 (破音)

连等赋值

关于连等赋值首先是发现了一个这个帖子：https://blog.csdn.net/liuyonglei1314/article/details/72778996 然后又搜了搜发现关于这个的题(有的更难一点)或者讲解都差不多

package S1010;

public class MainTest {
    public MainTest note;
    public int i;
    public  MainTest(int j){
        this.i=j;
        
        }
        public void println(){
            System.out.println(" "+i);
        }
    
    public static void main(String[] args) {
        
        MainTest n1=new MainTest(1);
        MainTest n2=new MainTest(2);
        MainTest n3=new MainTest(3);
        n1=n1.note=n2;//------1-------
        n1.note=n1=n2;//------2-------分开写 下面两句都能执行
        
        n1.println();
        n1.note.println();
    }
/*
 * 老师：两个注释掉的语句里面第一句 n1=n1.note=n2;这句话是肯定有问题的，无论是否连等分开写，这句话n1.note都为null，所以会发生空指针异常，可以像我上课一样画一个图分析，就很明了了
至于第二句话n1.note=n1=n2;，从实际运行情况来说，就是连等赋值的问题了。如果连等赋值分开写成n1=n2;  n1.note = n1; 那运行结果就是正确的，n1.note并不为空，不会发生空指针异常。但是如果不分开写，就会发生异常。具体原因我猜想是赋值连等写的时候，这两个赋值语句并不是顺序执行的，即并不是按照从右到左这么分开来写的顺序执行的，很可能是编译器或者虚拟机进行了优化，并行即同步的执行了这两句话，即n1=n2;  n1.note = n1;这两句话很可能是同步执行的，把n2赋给n1的同时也执行了把n1赋给n1.note，所以，很可能n1还没有获得n2的值就把n1的值赋给了n1.note，这样的话，n1.note就指向了原来n1所指向的对象，而我们知道这个对象一开始的数据成员note并为初始化，所以后面再调用相应方法就会产生空指针异常
并未初始化
所以在写java时避免赋值连等，分开顺序写
我们看上去的一个赋值操作，实际上编译成具体指令，是好几条指令，并不是一个原子操作，所以编译器优化的时候，如果有两条赋值语句，很可能优化后其指令成交替的顺序
我不理解的是为啥n1.note为空，我试验的是将第一句话分开写，n1无论是等于n1.note还是n2还是新建个对象n3 下面的n1.println都能执行但是n1.note.printlen不行
https://zhuanlan.zhihu.com/p/55377370
我他妈是瞎了嘛 博客园的登录呢*/

}

就是说连等没有那么想象的那么简单连i++都是分三步完成的

Scoket https://software.intel.com/zh-cn/blogs/2012/12/18/java-socket-socket 官方

简书怎么回事。我一搜就直接给我打开淘宝京东支付宝我好烦

eg客户端要连接到服务器端：
Socket socket = new Socket("127.0.0.1",4700)
套接字里的id，port都是服务器的而不是客户端的
不连到服务器端
public Socket() {};
之后自己再connect()

https://www.jianshu.com/p/b18af52d4f37

ServerSocket server=new ServerSocket(9000);//相当于服务器启动了，并且监听了9000
Socket socket=server.accept();//等待客户端 连接9000端口

Socket ServerSocket

当发送消息时，你需要知道对方的ip和端口，在java中，socket指的是java.net.Socket类。

在java中，socket指的是java.net.Socket类。在java.net.Socket中，可以看到socket有多种构造函数

以public Socket(String host, int port)为例，host为远程机器名称或ip地址，port为端口号。若连接本地的Server，其端口号为8080，可以写成如下格式 new Socket(“localhost”, 8080)；一旦成功创建一个Socket类的实例，可以用它来发送和接收字节流，

发送时调用getOutputStream方法获取一个java.io.OutputStream对象，接收远程对象发送来的信息可以调用getInputStream方法来返回一个java.io.InputStream对象。

Socket类代表一个客户端套接字，即任何时候连接到一个远程服务器应用时构建所需的socket，现在，要实现一个服务器应用，需要不同的做法。服务器需随时待命，因为不知道客户端什么时候会发来请求，此时，我们需要使用ServerSocket，对应的是java.net.ServerSocket类。 ServerSocket与Socket不同，ServerSocket是等待客户端的请求，一旦获得一个连接请求，就创建一个Socket示例来与客户端进行通信。

1讲解