日常1

zoukankan html css js c++ java

日常1
Java的编译和运行

编译：把.java文件编译成.class文件 javac是Java编译器工具把.java文件编译成.class文件

运行 .class文件在JVM中生成二进制机器码

源文件删除不会影响程序的执行

java.exe 主要负责运行阶段 java 类名

类加载器会在硬盘中找类.class文件装载到JVM中然后JVM会将字节码文件解释成二进制

注释

/**
*/ 这种注释比较专业，注释的内容会被javadoc.exe工具解析提取生成帮助文档

public class 和 class

一个Java源文件中可以定义多个class public class 不是必须的一个class 会生成一个字节码文件但是只能有一个 public class 且 public class 类名这个类名必须和Java源文件名称一致

每一个class当中都可以定义main方法，想用哪个main方法就运行哪个字节码文件

标识符

字母、数字、下划线、美元符号数字不能开头，严格区分大小写，关键字不能做标识符

标识类名、变量名、常量名、方法名、接口名

变量名，方法名：首字母小写，后面每个单词首字母大写

类名，接口名：首字母大写，后面每个单词首字母大写

常量名：全部大写

关键字

字面值

就是一些值比如 “abc” 'a' 3.14 100 true false 等值

变量

变量可以让程序重复的访问某一区间

变量是指向某个内存的，赋值是改变指向，而不是在原来的内存中修改内容。

变量必须先声明，再赋值，然后才可以使用。

在方法体中定义的变量是局部变量，在方法体外是成员变量，成员变量没赋值会系统默认赋值

数据类型

一个字节Byte 8个比特位bit 一个比特位是一个0、1 1B = 8b

存的是补码

基本数据类型

整数型byte -128 到127 short int 八进制0开头十六进制 0x开头 long

浮点型 float double

布尔型 boolean

字符型 char 人为定义二进制表示字符 ‘a’ -97 01100001 ‘A’ -65 ‘0’ - 48 编码和解码必须是同一套对照表

GBK支持简体中文 UTF-8统一了全球的文字 Java用的UTF-8 标识符可以写中文

引用数据类型

字符串 String

转义字符

‘ ’ 换行符

强制类型转换

可能会损失精度将左边的数都砍掉
```
public class Test {
    public static void main(String[] args) {
        char c = 48;
        int i = 97;
        byte b = 1 +5;
     //   b += 5;   //11
        b += 128;
        System.out.println(b);
        System.out.println(c);
        System.out.println(i);
        System.out.println((char) i);
        System.out.println(++c);
        System.out.println(c+1);
    }
}
//-122
//0
//97
//a
//1
//49
```
double 和 float 存储的都是近似值

byte char short 运算时先转成int 类型这是有变量参加运算的时候，如果都是常量就是直接赋值

多种数据类型运算先转成容量最大的类型编译器只会检查语法，不会运行结果

运算符

算术运算符

关系运算符

赋值运算符

逻辑运算符 && 短路与 || 短路或 ^ 异或

位运算符 >>右移 << 左移

赋值运算符 = 先运算右边在赋值给左边 += 是有强制类型转换的

字符串连接
```
public class Test {
    public static void main(String[] args) {
        String s = "Hello";
        System.out.println(s + 1);
        System.out.println(1 + s);
        System.out.println(1 + 3 + s);
        System.out.println(1 + s + 3);
        System.out.println(s + 1 + 3);
    }
}
Hello1
1Hello
4Hello
1Hello3
Hello13
```
三元运算符布尔值？A : B 这是个运算符不是语句完整使用 char c = 2 > 3 ? '男' : '女'；

if语句
```
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        if(i < 0){
            System.out.println("i < 0");
        }else if (i == 0){
            System.out.println("i = 0");//到这里可能会不匹配 ，如果没有else就会直接往后面执行
        }else {
            System.out.println("i > 0");
        }//一定会有一个执行
    }
}
```
switch
```
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        switch (s){
            case "hello":
                System.out.println("haha");
                System.out.println("666");
                break;
            case "java":
                System.out.println("hehe");
                System.out.println("777");
                break;
        }
    }
}
//hello
//haha
//666
//如果不能匹配就直接向下面执行
//switch中可以是int char,byte,short 会自动转为int(可以用 我觉得是错的) String
```
switch 条件判断语句中使用 String 对象

switch 不支持 long、float、double，是因为 switch 的设计初衷是对那些只有少数几个值的类型进行等值判断，如果值过于复杂，那么还是用 if 比较合适。

for语句

布尔表达式true 执行循环体再执行更新表达式

我认为：知道循环次数的用for不知道次数的用while比较适合我自己

初始值可以有多个但是必须是同一个类型

while

while(布尔表达式){

语句；

}

do while

do{

语句；

}while(布尔表达式);

有分号

循环中break 结束循环

continue 结束本次循环

方法

调用方法提高复用性，而且使用方法代码清晰

修饰符返回值方法名(参数){

语句；

}

static 修饰的方法直接类名.方法调用

return 是结束该方法

方法定义在类当中，没有顺序

有if时 if中有return 但是没有else 的话会报错 因为不一定会百分之百有返回值

方法在执行时JVM内存是如何分配的

1、方法只是定义，不调用，是不会执行的，并且在JVM中也不会给该方法分配“运行所属”的内存空间

2、方法区，堆内存，栈内存三种内存空间

栈内存先进后出

方法代码片段属于.class文件的一部分字节码文件在加载的时候存在方法区中

虽然在方法区中只有一份，但是可以被重复调用

每次调用方法的时候，在栈内存中分配内存方法在调用的瞬间会给该内存在栈内存中分配空间，此时会在栈内发生压栈，方法结束后会发生弹栈

局部变量也在栈中分配

方法重载

功能相似的方法依靠实参的类型判断是哪个方法方法名相同，参数类型不同，返回值可以不同

方法递归

递归：自己调用自己

有结束条件，然后找递归公式

面向对象和面向过程的区别

面向过程：主要关注实现的具体过程

优点：对于业务逻辑比较简单的程序，可以快速开发

缺点：很难解决非常复杂的业务逻辑，且软件元素直接耦合度非常高只要一环出问题，整个系统出现问题。扩展力弱

面向对象：关注点是对象能完成哪些功能

优点：扩展力强，容易解决更加复杂的业务逻辑

缺点：前期投入较大

面向对象的三大特征

封装、继承、多态

类是对象与对象直接具有共同特征进行抽象总结出来的模板是类

对象:实际存在的个体，现实世界中实际存在的

对象内存分析

new的对象在堆内存中

static 修饰的内容是放在堆内存

当对象不被引用之后，垃圾回收器会将对象回收

封装

封装之后，会降低出错的情况安全性高而且可以在方法中进行安全控制，而且适应性较强

构造方法

构造方法没有返回值类型

不能被重写，一般都是重载

父类构造方法不能被子类继承，但是子类构造方法一定会有一个隐含的调用父类构造方法

参数传递

值传递，对象被当作参数的时候，是复制了一份引用

final

final 关键字修饰成员变量的时候，该成员变量要不就是构造方法中赋值，要不就要直接在类中赋初始值。一旦赋值就不能更改了。

泛型

不用泛型容易引起classcastexception异常

在编译期就检测到非法的类型的数据结构

本质是参数化类型

好处类型安全，消除了强制类型转换
```
public class Demo {
    public static void main(String[] args) {
        Generic<String> sgeneric = new Generic<>("hello");
        Generic<Integer> igeneric = new Generic<>(22);
        System.out.println(sgeneric.getClass());
        System.out.println(igeneric.getClass());
        System.out.println(sgeneric.getClass() == igeneric.getClass());
    }
}
结果
class day01.fanxing.Generic
class day01.fanxing.Generic
true
```
泛型类：泛型类型在逻辑上可以看成是多个不同的类型，但是实际上都是相同的类型

从泛型类派生子类

子类也是泛型类子类和父类泛型类型要一致

因为子类构造方法要先调用父类构造方法父类的类型是子类传过去的
```
class Child<T> extends Father<T>
```
子类进行泛型扩展也要包含父类的泛型
```
class Child<T,K,E> extends Father<T>
```
子类不是泛型类子类和父类泛型类型要明确
```
class Child extends Father<String>
```
泛型接口

如果实现类不是泛型类那么接口的泛型必须明确

如果实现类是泛型类那么接口的泛型一定要包含实现类的泛型
```
public class ImpleGen<T,V> implements Generor<T>{
    private T key;
    private V value;
    @Override
    public T getKey() {
        return key;
    }
    public V getValue(){
        return value;
    }
}
```
泛型方法只有声明了的方法才是泛型方法泛型类中使用了泛型的成员方法并不是泛型方法

泛型方法的调用，类型是通过调用方法的时候来指定的

而且泛型方法的泛型和泛型类的泛型是独立的

就算看着一样也是不同的
```
public class Generic<T> {
        private T key;
    
        public Generic(T key) {
            this.key = key;
        }
    
        public T getKey() {
            return key;
        }
    
        public void setKey(T key) {
            this.key = key;
        }
        public<T> T show(T []arr){
            return arr[0];
        }
    }
{
    main 方法
    Generic<String> g = new Generic<>("hello");
        Integer[] i = {64,7131,54,354};
        System.out.println(g.show(i));
    }
```
泛型类的成员方法不能用static修饰

但是泛型方法可以用static修饰

泛型方法：可变参数方法名(E... e)

类似于数组

可变数组

通配符
```
public class Fan {
    public static void main(String[] args) {

    }
    public static void showProduct(Product<?> product){
        Object o = product;
        System.out.println(o);
    }
}
```
就是方法参数我不知道是什么类型，直到使用该方法时我才指定的时候用通配符

通配符上限 <? extends 实参类型> 只能是实参类型及其子类

通配符下限<? super 实参类型> 只能是实参类型及其父类

类型擦除

泛型只存在于编译期，进入jvm之前会被擦除
```
  public static void main(String[] args) {
        ArrayList<Integer>  intArrayList = new ArrayList<>();
        ArrayList<String> stringArrayList = new ArrayList<>();
        System.out.println(intArrayList.getClass() == stringArrayList.getClass());
    }
结果：true
```
桥接方法

桥接方法保证接口和类的实现关系

编译器为了让子类有一个与父类的方法签名一致的方法，就在子类自动生成一个与父类的方法签名一致的桥接方法。

保证重写？

泛型数组

可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象

这样是不会报错的，但是这样违反了泛型的初衷
```
String s = listArr[0].get(0);
Syetem.out.println(s);
会报错
```
ClassCastException

如果要用泛型数组的话

数组在整个运行期都会保持自己的类型，但是泛型只会在编译期存在所以两者本来的目的就不一样

![](D:截[

]()图2.png)

这样是不对的

这样才可以，在构造方法中创建
```
Fruit<String> fruit = new Fruit<>(String.class,2);
```
泛型和反射
查看全文

相关阅读:
磁盘io测试工具
 SqlServer性能瓶颈分析
 sqlserver镜像相关资料
 sqlserver数据库镜像运行模式
 Sqlserver2008 FileStream解决图片存储问题
 nginx负载均衡配置
 cacti-不出图形，cacti.log中出“ERROR: SQL Assoc Failed!
Nginx的配置文件详解
 Linux环境（Centos) 安装mysql
centos 命令行和图形桌面模式的切换

原文地址：https://www.cnblogs.com/my-diary/p/14237590.html

Java的编译和运行

注释

public class 和 class

标识符

关键字

字面值

变量

数据类型

转义字符

强制类型转换

运算符

if语句

switch

for语句

while

do while

方法

方法在执行时JVM内存是如何分配的

方法重载

方法递归

面向对象和面向过程的区别

面向对象的三大特征

对象内存分析

封装

构造方法

参数传递

final

泛型

通配符

类型擦除

泛型数组

泛型和反射