Java学习

迈不过友情╰ 2021-12-10 03:05 245阅读 0赞

### 文章目录 ###

*  基本数据类型
 *  类
 *   *  类的属性
     *  类的方法
 *  基本类型大包器
 *   *  打包基本类型
     *  自动装箱，拆箱
 *  数组
 *   *  一维数组
     *  二维数组
 *  字符串
 *   *  基本
     *  特性
 *  Java只有传值\[地址\]调用

# 基本数据类型 #

*  java是一种强类型语言，每个变量都必须声明类型  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]
 *  java必须先声明后使用：只有在变量声明之后，才能为其分配相应长度的存储单元。
 *  java中的对象是通过引用来对其操作的。
 *  char用于表示Unicode编码的字符单元，尽可额能不要再代码中使用char类型。
 *  Java有一个用于表示任意精度的算术包：大数值bignumber，它是一个Java对象。
 *  Java的每一种类型的机器长度是固定的，比如char为1字节，short为2字节，int为4字节，long为8字节，float是4字节，double为8字节，这保证了移植的安全性。
 *  long类型后面带一个L；浮点数类型后面带一个f。
 *  Java没有任何无符号类型。
 *  不要对浮点数使用==之类的值
 *  浮点数值不适用任何禁止出现舍入误差的金融计算中，因为浮点数采用二进制系统表示：应该采用BigDecimal类。

package com.oceanstar.test_1;
    
    import java.math.BigDecimal;
    
    public class bigNess {
        
        public static void main(String[] args) {
        
            BigDecimal a = new BigDecimal("0.1");
            BigDecimal b = new BigDecimal("0.5");
    
            if(a.add(b).equals(new BigDecimal("0.6"))){
        
                System.out.println("相等");
            }
        }
    }

# 类 #

*  一个类 = 静态属性 + 动态行为【也叫做方法】
 *  类是对象的模板，对象以类的模板组织数据
 *  类常量：使用static final定义，可以再Java的一个类的多个方法中使用
 *  只要有一个类定义，就会产生一个class文件。
 *  创建对象时，如果没有指定初始值，会使用默认值初始化
 *  处理被声明为static的地方，this可以出现在类中的任何地方。
 *  如果对象数据成员被声明为final，但是没有明确初始化，那表示延迟对象成员的指定，在构造函数中，一定要初始化这个成员。
 *  被声明为static的成员，不会让个别对象拥有，而是属于类。
 *  static的方法或者区块中不能出现this关键字，static方法中不能使用非static数据成员。

package com.oceanstar.demo;
    
    public class FinalClass {
        
        static final double PI = 3.14;  // 类常量
        public static void main(String[] args) {
        
            System.out.println(PI);
            func();
        }
    
        static void func(){
        
            System.out.println(PI);
        }
    }

## 类的属性 ##

*  属性，也叫做成员变量
 *  属性用于定义该类/该类对象包含的静态数据，是一个对象固有的。
 *  在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。(数值：0，0.0； char：\\u0000； boolean：false；所有引用类型：null)
 *  属性命名时首字母小写，驼峰原则。

## 类的方法 ##

*  面向对象中，整个程序的基本单位是类，方法是从属于类的。
 *  java中方法参数传递是：值传递。
 *  类的属性可以看成是全局变量，如果不显示初始化，编译器会默认设置为默认值。定义在方法内部的叫做局部变量，必须显示初始化之后才能使用。

# 基本类型大包器 #

## 打包基本类型 ##

*  使用new常见基本类型打包器

package com.oceanstar.test_1;
    
    public class IntergerDemo {
        
        public static void main(String[] args) {
        
            int data1 = 30;
            int data2 =  9;
    
            Integer wrapper1 = new Integer(data1);  // 打包基本类型: 必须传入int类型的数据
            Integer wrapper2 = new Integer(data2);
    
            System.out.println(data1/88); //0  在int空间中计算，结果是int中枢
            
            System.out.println(wrapper1.doubleValue()/9); //3.333333333333333333335   doubleValue将打包值以double类型返回，在double空间中计算
            System.out.println(wrapper1.compareTo(wrapper2));
            // compareTo: wrapper1 - wrapper2  = 0, wrapper1 - wrapper2  > 0 ; wrapper1 - wrapper2  < 0
        }
    }

## 自动装箱，拆箱 ##

编译程序会自动判断能够自动装箱

*  自动装箱

package com.oceanstar.test_1;
    
    public class IntergerDemo {
        
        public static void main(String[] args) {
        
    
            Integer wrapper1 = 10;
            System.out.println(wrapper1.doubleValue()/9);
    
    
            int i = 11;
            wrapper1 = i;
            System.out.println(wrapper1.doubleValue()/9);
    
            
            Number wrapper2 = 11;  // 11 先被自动装箱为int，然后指定给wrapper2
            System.out.println(wrapper2.doubleValue()/3);
            
        }
    }

package com.oceanstar.test_1;
    
    public class IntergerDemo {
        
        public static void main(String[] args) {
        
            Integer i = Integer.valueOf(110);
            System.out.println(i.doubleValue() / 3);
        }
    }

*  自动拆箱

package com.oceanstar.test_1;
    
    public class IntergerDemo {
        
        public static void main(String[] args) {
        
            Integer wrapper2 = 11;  // 11 先被自动装箱为int，然后指定给wrapper2
            int i= wrapper2;  // 自动拆箱子
            System.out.println(i/3);
        }
    }

*  自动拆箱、自动装箱的本质

> 编译程序蜜糖：编译时期根据语法，决定是否拆箱或者装箱

如： Interger number = 10  
在Oracle的JDK上，编译程序会自动将程序代码展开为：  
Integer i = Integer.valueOf(110);

*  易错题

package com.oceanstar.test_1;
    
    public class IntergerDemo {
        
        public static void main(String[] args) {
        
            Integer i1 = 8999;
            Integer i2 = 8999;
            if(i1 == i2){
        
                System.out.println("相等");
            }else{
        
                System.out.println("不相等");   //   不相等
            }
    
            i1 = 10;
            i2 = 10;
            if(i1 == i2){
        
                System.out.println("相等"); //  相等
            }else{
        
                System.out.println("不相等");   
            }
        }
    }

原因：

public static Integer valueOf(int i) {
        
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    * 如果传入的int在 IntegerCache.low与 iIntegerCache.high之间，先看看前面的Cache中有没有打包过相同的值，如果有，直接返回，否则new一个。IntegerCache.low=-128，IntegerCache.high=127.
    
    IntegerCache.low默认-128，执行时期无法更高，IntegerCache.high可以在启动JVM时，使用系统属性指定：
    
    备注：IntegerCache是Interger类别内部的一个类，缓存会在首次使用IntegerCache时建立

# 数组 #

## 一维数组 ##

public class TwoArrayTest {
        
        public static void main(String[] args) {
        
            int []points = {
        
                    1, 2, 3
            };
            int []point2 = points
    
            for(int i = 0; i < points.length; i++){
        
                System.out.println(i);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]

*  数组复制

package com.oceanstar.test_1;
    
    import java.util.Arrays;
    
    public class TwoArrayTest {
        
        public static void main(String[] args) {
        
            int [] array = new int[10];
            Arrays.fill(array, 10);
            System.out.println(array);
    
            // 数组复制
            int []array_2 = new int[array.length];
            System.arraycopy(array, 0, array_2, 0, array.length);
            int []array_3 = Arrays.copyOf(array, array.length * 2);
            array_2[0] = 999;
            for(int i : array_2){
        
                System.out.print(i + "、");
            }
            System.out.println();
            for(int i : array_3){
        
                System.out.print(i + "、");
            }
            System.out.println();
      }
    }

*  浅拷贝

package com.oceanstar.test_1;
    
    public class ClothesTest {
        
        public static void main(String[] args) {
        
            Clothes [] c1 = {
        new Clothes("red", 's'), new Clothes("blue", 'm')};
            Clothes [] c2 = new Clothes[c1.length];
    
            for(int i = 0; i < c1.length; i++){
        
                c2[i] = c1[i];
            }
    
            c1[0].setColor("greet");
            System.out.println(c1[0].getColor());
            System.out.println(c2[0].getColor());
        }
    }
    
    class Clothes{
        
        private String color;
        private char size;
    
        Clothes(String color, char size){
        
            this.color = color;
            this.size = size;
        }
    
        public String getColor() {
        
            return color;
        }
    
        public void setColor(String color) {
        
            this.color = color;
        }
    }

*  深拷贝

package com.oceanstar.test_1;
    
    public class ClothesTest {
        
        public static void main(String[] args) {
        
            Clothes [] c1 = {
        new Clothes("red", 's'), new Clothes("blue", 'm')};
            Clothes [] c2 = new Clothes[c1.length];
    
            for(int i = 0; i < c1.length; i++){
        
                c2[i] = new Clothes(c1[0].getColor(), c1[0].size) ;
            }
    
            c1[0].setColor("greet");
            System.out.println(c1[0].getColor());
            System.out.println(c2[0].getColor());
        }
    }
    
    class Clothes{
        
        private String color;
        public char size;
    
        Clothes(String color, char size){
        
            this.color = color;
            this.size = size;
        }
    
        public String getColor() {
        
            return color;
        }
    
        public void setColor(String color) {
        
            this.color = color;
        }
    }

## 二维数组 ##

package com.oceanstar.test_1;
    
    public class TwoArrayTest {
        
        public static void main(String[] args) {
        
            int [][]points = {
        
                    {
        1, 2, 3},
                    {
        2, 3, 5},
            };
    
            for(int i = 0; i < points.length; i++){
        
                for (int j = 0; j < points[i].length; j++){
        
                    System.out.print(points[i][j] + " \t");
                }
                System.out.println();
            }
    
            for(int []row: points){
        
                for(int value:row){
        
                    System.out.print(value + " \t");
                }
                System.out.println();
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]

package com.oceanstar.test_1;
    
    public class TwoArrayTest {
        
        public static void main(String[] args) {
        
            int [][]points = new int[2][]; //声明数组会有两个索引
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]

package com.oceanstar.test_1;
    
    public class TwoArrayTest {
        
        public static void main(String[] args) {
        
            Integer [] a = new Integer[3];
    
            for (Integer t: a) {
        
                System.out.println(t);
            }
      }
    }

# 字符串 #

## 基本 ##

*  字符串本质是一个char数组

package com.oceanstar.test_1;
    
    public class String_Test {
        
        public static void main(String[] args) {
        
            char sc[] = {
        'h', 'e', 'l', 'l', '0'};
            String str = new String(sc);
    
            System.out.println(str);
    
            char c1r[] = str.toCharArray();
            for(char i: c1r){
        
                System.out.println(i);
            }
        }
    }

*  字符串解析：用户输入数字【以0为分界点】，求他们的和。

package com.oceanstar.test_1;
    
    
    
    import java.util.Scanner;
    
    public class String_Test {
        
        public static void main(String[] args) {
        
            Scanner in = new Scanner(System.in);
    
            int sum  = 0;
            int i ;
            do{
        
                i = Integer.parseInt(in.nextLine());
                sum = sum + i;
            }while(i != 0);
            System.out.println(sum);
        }
    
    }

package com.oceanstar.test_1;
    
    
    
    import java.util.Scanner;
    
    public class String_Test {
        
        public static void main(String[] args) {
        
            int sum = 0;
            for(String arg : args){
        
                sum = sum +  Integer.parseInt(arg);
            }
            System.out.println(sum);
        }
    
    }

## 特性 ##

*  在Java中，为了效率，以""包括的字符串，只要内容相同，无论在程序中出现几次，JVM都只会建立一个String实例，并且在字符串池中维护。

package com.oceanstar.test_1;
    
    
    
    import java.util.Scanner;
    
    public class String_Test {
        
        public static void main(String[] args) {
        
            String name = "hello";
            String name2 = name + "world"; /*
            使用+连接字符串，会变成建立Java.lang.StringBuilder对象，使用其append()方法来进行字符串相加，然后转换toString返回
            */
    
            String name3 = (new StringBuilder().append(name).append("world")).toString();
        }
    
    }

# Java只有传值\[地址\]调用 #

package com.oceanstar.test_1;
    
    public class CallByValues {
        public static void main(String[] args) {
            Customer c1 = new Customer("aaaa");
            System.out.println(c1); // com.oceanstar.test_1.Customer@b4c966a
            some(c1);  //1
            System.out.println(c1.name);  // jonha
    
    
            Customer c2 = new Customer("aaaa");
            System.out.println(c2);  //com.oceanstar.test_1.Customer@2f4d3709
            some_a(c2);  // 2
            System.out.println(c2.name);  // aaaa
    
    
        }
    
        static void some(Customer c){
            System.out.println(c);  // com.oceanstar.test_1.Customer@b4c966a
            c.name = "jonha"; // 1
        }
    
        static void some_a(Customer c){ // com.oceanstar.test_1.Customer@2f4d3709
            System.out.println(c); //  v
            c = new Customer("avcdsa");  // 4  c新指向一个地址
            System.out.println(c); // com.oceanstar.test_1.Customer@4e50df2e
        }
        
        /*
        * 
        * Java中调用函数时要传输参数的话：一定会将这个参数的地址传过去。
        * */
    
    }
    
    class Customer{
        String name;
        Customer(String name){
            this.name = name;
        }
    }

就算是返回参数，也是返回一个地址。  
即：Java中只会传地址，不会传值。----只有一个实例。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20211209/e74383a4f9854a36a47426a26a25b233.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20211209/3f19538ef54647a39ce09d6d783888a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: /images/20211209/d104164e62f94d9cb997c8e46ae3cbd8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]: /images/20211209/b89e1a3db70d4512a08b406f18a9f0b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 4]: /images/20211209/7188fb48e18e4da0adee9cdbd4477903.png