Java基础知识/算法题/内存分析

• 1. 局部变量一定要初始化
• 2. Java是一种强类型语言，每个变量都必须声明其数据类型。python等则没有这么严格的要求。 Java的数据类型可分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。
• 3. Java整数常量四种数据类型：
     byte： 一个字节，就是2的7次方，8个二极管
     short：2的15次方
     int: 2的31次方
     long: 2的64次方

• 4. 浮点数

     
     浮点数

• 5 转义字符

  
  
• 6. 算术运算符 之 自增自减

public class Welcome {
    public static void main(String[] args){
        int a = 3;
        int b = 6;
        int a1 = a ++ ;
        int b2 = ++ b ;
        System.out.println(a1);     # 结果a1是 3，因为先执行 a 赋值给 a1
        System.out.println(b2);     # 结果b2是 7 ，因为 先执行 b自增，1自增
    }
}

• 7. 三目条件运算符

        int score = 80; 
        int x = -100;
        String type =score<60?"不及格":"及格"; 
        int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
        System.out.println("type= " + type);
        System.out.println("flag= "+ flag);

• 8. 字符串连接符

// 打印的结果是 get it: 12，没有 + 号，就会报错，这点不同于python
System.out.println("get it:" + c);  // 整个代码中c 值为12

        String m = "3";
        int n = 4;
        int f = 5;
        System.out.println(m + n + f);    //结果是 345
        System.out.println(n + f + m);    // 结果是 93

• 9. Java 实现乘法表

public class QianTao {
    //用嵌套实现9 9 乘法表
    public static void main(String[] args){

        for(int m=1; m<=9; m++ ){

            for(int n=1; n<=m; n++){
                System.out.print(n + "*" + m + "=" + (m*n) + "\t");

            }
            System.out.println();  //起到换行的作用
        }
    }
}

/* 结果如下，不是代码*/
1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16  
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25  
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81  

• 10. 用while循环或其他方式输出1-1000之间被5整除的数，且每行5个;用while循环计算100内的奇数和偶数的和，并输出

 //用while循环或其他方式输出1-1000之间被5整除的数，且每行5个
        //用while循环计算100内的奇数和偶数的和，并输出

        int sum01 = 0;
        int sum02 = 0;
        for(int i=1; i<=100; i++){
            if(i%2==0){
                sum01 += i;
            }else{
                sum02 += i;
            }
        }
        System.out.println("奇数和:"+sum01);
        System.out.println("偶数和："+sum02);

        System.out.println("****************");

        for (int j=1; j<=1000;j++){
            if(j%5==0 && j%25 != 0){
                System.out.print(j + "\t");
            }else if(j%25==0){
                System.out.println(j + "\t");

            }    //代码为节选

\* 下面为结果，非代码 *\
奇数和:2550
偶数和：2500
****************
5   10  15  20  25  
30  35  40  45  50  
55  60  65  70  75  
80  85  90  95  100 
105 110 115 120 125 
130 135 140 145 150 
155 160 165 170 175 
180 185 190 195 200 ......

• 11. 编程求：∑1+∑2+……+∑100

        System.out.println("************");   // 节选

        int add = 0;
        int x = 0;
        int add1 = 0;
        while( x <=100){
            x++;
            add += x;
            add1 += add;
        }
        System.out.println(add1);   // 结果是 176851

---

Java内存分析

Java虚拟机内存可以分为3个区域：栈stack、堆heap、方法区method area(本质上就是前两种)

栈的特点

1. 栈描述的是 方法执行的内存模型，每个方法被调用就会创建一个栈帧（存储局部变量、操作数、方法出口等）
2. JVM 为每一个线程创建一个栈，用以执行该线程中方法的信息（实际参数、局部变量等）
3. 栈属于线程私有，不能线程间共享
4. 栈存储的特点是 先进后出，后进先出
5. 栈是由系统分配的，速度快！栈是一段连续的内存空间 放执行的方法，存放局部变量

堆heap的特点

1. 堆用于存储建好的对象和数组（数组也是对象）
2. JVM只有一个堆，被所有线程共享
3. 堆 是不连续的内存空间，分配灵活，速度慢 说白了当类生成对象了，对象及对象信息都放这里，存放new放出来的对象

方法区（又叫静态区）特点

1. JVM只有一个方法区，被所有线程共享
2. 方法区实际也是堆heap，只是用来存储常量、类 相关的信息
3. 用来存放程序中永远不变或者是唯一的内容（类信息、CLASS对象，静态变量，字符串常量等）存放类的信息及代码，static变量，常量池

模拟学生学习的范例程序

class Computer {
    String brand;  //品牌   brand就是且确定 是对象的属性
}
public class SxtStu {
    // field 属性
    int id;
    String sname;
    int age;
    Computer comp;   // 类之间可以相互嵌套，表示每个人都该有个电脑
    void study() {      //这是方法，注意区分和 属性 的区别
        System.out.println("我正在学习！使用我们的电脑，"+comp.brand);     // comp是一个对象，通过 .brand 访问这个它的属性
    }

    SxtStu() {
    }   //构造方法，用于创建这个类的对象，无参的方法可以由系统自动创建

    public static void main(String[] args) {  //程序执行的入口，必须有
        SxtStu stu1 = new SxtStu();
        stu1.sname = "张三";
        Computer comp1 = new Computer();  // comp1是新建了一个对象
         comp1.brand = "联想";
        stu1.comp = comp1;  //前面是stu1这个对象的comp方法，然后把comp1这个电脑对象赋给他，所有这个学生对象就有了一个具体的电脑对象，进而知道了电脑的品牌
        stu1.study();
    }
}

图上箭头及堆栈有顺序的，注意
⚠️注：实际Java这段代码执行 是从 javac SxStu 接着 java SxStu 开始的，所以，我们可以发现，程序先从 SxStu 这个public类开始执行的，所以上图应该是先加载 SxStu类开始。接着，就是先从程序 main 开始，即static静态方法

---

static 关键字的使用

public class User2 {
    int id; // id
    String name; // 账户名
    String pwd; // 密码
     
    static String company = "北京"; // 公司名称
     
     
    public User2(int id, String name) {
        this.id = id;
        this.name = name;
    }
     
    public void login() {
        printCompany();
        System.out.println(company); 
        System.out.println("登录：" + name);
    }
     
    public static void printCompany() {
//         login();//调用非静态成员，编译就会报错
        System.out.println(company);
    }
     
    public static void main(String[] args) {
        User2 u = new User2(101, "高小七");
        User2.printCompany();
        User2.company = "北京阿里爷爷";
        User2.printCompany();
    }
}

关于 Static

static 定义的变量 是存在 heap中的 方法区中，所以，static定义的变量，对象无法调用，而类可以直接调用。想想为什么？ 方法区就是速度慢，但比较稳定的区域，所以适合存所谓的静态变量

类比于python，Static 是用来定义 类属性和类方法的，类属性类方法可以被对象及对象的方法调用，而类方法不可以调用对象的属性和方法。根本原因是它们在内存中的位置不同，某种来说就是 继承关系

查看模块源码

选中该模块名，按住 command 键，点击后就可以跳转过去，查看源码

Java访问权限

访问权限修饰符

---

抽象类 抽象方法 abstract

抽象的单词是 abstract , 体现在多态上，当一个父类下有个方法，而子类很多，且都会修改这个方法时，定义一个抽象方法（含有抽象方法的必须是抽象类），表示

public abstract class Animal(){     // 有抽象类的方法必须是抽象类， 抽象类Animal不可以实例化，即 new 一些实例出来
     public abstract void run() ;     //Animal有许多子类，子类都有不同的run方法，所以此处采用抽象方法仅表示一个概念，子类必须强制重写该方法，否则报错
}

class Cat extends Animal(){
     @Override  //表示注解重写，即子类有和父类同名方法时，带上它。如果带上它，子类方法和父类不同名，也会报错
     public void run();   // 抽象方法的意义在于将抽象方法的设计和抽象方法的实现分离类
}

通过抽象类，可以避免子类设计的随意性，抽象类不能实例化，只能用来被继承

---

接口 interface

比抽象类还抽象的类就叫接口，同样，它的意义就是 设计和实现的分离