Tag Archives: Java

Java基本语法的几个笔记

1 需要注意的点

1.1 运算赋值操作

  1. 复合赋值运算中(如:+=、-=等),隐含了类型强制转换。如:
    byte b = 126;
    // 按常理2是int型,byte + int 结果应该是int,但这里会强转为byte
    b += 2;  // 结果会溢出
    System.out.println(b); // -128
    
  2. 三目运算不能单独存在,运算结果必须要有“接收方”
    OperationDemo.java:10: 错误: 不是语句
                   a > b ? a : b;
                         ^
    1 个错误
    
  3. 整数类型中byte、short、int、long四种的前三种在运算时都会先转换为int类型;
    byte a = 10;
    byte b = 20;
    // 事实上是byte = int + int,所以编译时会报错
    byte ret = a + b;
    
    OperationDemo.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
                   byte ret = a + b;
                                ^
    1 个错误
    
  4. 如果表达式的右边为常量,编译时会先将表达的进行计算,用结果替换原来的表达式,如:
    // 上述示例中ret = a + b,表达式右边是int型,左边是byte,有转换失真的风险所以编译会报错;
    // 但如果右边是常量则不会,byte ret = 10 + 20类似直接写byte ret = 30;
    byte ret = 10 + 20;
    

1.2 函数与方法

  1. 方法重载中如果返回值类型不一样,不构成方法重载。(想想看,返回值是可以强制类型转换的,那么编译器到底该给哪个方法呢?所以此处有歧异)
    public static int sum(int a, int b) {
       return a + b;
    }
    // 编译报错,方法重名了,仅返回值类型不同不构成方法重载
    public static float sum(int a, int b) {
       return (float) (a + b);
    }
    

1.3 数组

  1. 数组初始化的几种方式,主要有静态初始化(指定值)与动态初始化(指定长度);
  • 所谓的静态与动态区别是即时指定长度还是直接赋值;
  • Java中指定值有两种方式,一种是类型前缀,一种不加(所谓的标准格式与省略格式);
  • 在其他高级语言中如C++,静态初始化不能拆开写(即省略格式),但Java标准格式可以;
  • 动态初始化数组时,内存中全部写0,即int为0、float为0.0、对象为null、char为\u0000
    // 动态初始化,在创建数组时指定数组长度
    int[] array1 = new int[10];
    System.out.println(array1);
    int[] array2 = new int[10];
    System.out.println(array2);
    
    // 静态初始化,创建数组时直接以数据长度为准
    int[] array3 = new int[] {1, 2, 3, 4};
    System.out.println(array3);
    int[] array4 = {1, 2, 3, 4};
    System.out.println(array4);
    
    // 初始化可以先定义变量再赋值,但有一种情况例外
    int[] array5;
    array5 = new int[10];
    int[] array6;
    array6 = new int[] {1, 2, 3, 4};
    int[] array7;
    array7 = {1, 2, 3, 4}; // 注意:这种情况是非法的,编译报错
    

2 相关总结

2.1 类与对象

[……]

继续阅读

随机存储实现动态数组ArrayList

1、List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package com.yusian;
 
public interface List<e> {
 
	static final int ELEMENT_NOT_FOUND = -1;
	/**
	 * 获取数组长度
	 * @return 数组长度
	 */
	public int size();
 
	/**
	 * 是否为空
	 * @return true / false
	 */
	public boolean isEmpty();
 
	/**
	 * 是否包含某元素
	 * @param element
	 * @return true / false
	 */
	public boolean contains(E element);
 
	/**
	 * 添加元素,默认添加到末尾位置
	 * @param element
	 */
	public void add(E element);
 
	/**
	 * 获取元素
	 * @param index 索引
	 * @return 值
	 */
	public E get(int index);
 
	/**
	 * 替换元素
	 * @param index 索引
	 * @param element 元素
	 * @return 原元素内容
	 */
	public E set(int index, E element);
 
	/**
	 * 添加元素
	 * @param index 索引
	 * @param element 元素值
	 */
	public void add(int index, E element);
 
	/**
	 * 移除元素
	 * @return 返回被移除元素
	 */
	public E remove(int index);
 
	/**
	 * 获取元素索引
	 * @param element
	 * @return 索引
	 */
	public int indexOf(E element);
 
	/**
	 * 清除数组
	 */
	public void clear();
}
 
</e>

2、AbstractList


[……]

继续阅读

Java基础之多线程的基本实现

1、实现方式一:继承Thread类,重写run方法

1
2
3
4
class Demo{
	public static void main(String [] args){
		SAThread thread1 = new SAThread();
		SAThread thread2 = new SAThrea[......]<p class="read-more"><a href="https://www.yusian.com/blog/java/2017/03/17/140012953.html">继续阅读</a></p>

Java基础之synchronized同步的使用

0、有关多线程的实现先参考:Java基础之多线程的基本实现
1、两个线程访问同一个对象,如果没有同步的限制,会出现一个意想不同的问题;
2、比如对象成员属性int i = 100;某方法每执行一次都会对该值进行减1操作,直接为0结束;
3、单次调用的基本流程应该是:start->{body}->end;[……]

继续阅读

Java基础知识之IO流的简单使用

1
2
3
4
5
6
7
import java.io.*;
class Demo{
	public static void main(String args[]){
		// 声明输入流的引用
		FileInputStream input = null;
		// 声明输出流的引用
		FileOutputStream[......]<p class="read-more"><a href="https://www.yusian.com/blog/java/2017/03/16/154032945.html">继续阅读</a></p>