首先

我平常作为一个iOS工程师，使用Swift进行应用程序开发。
由于服务器主要是用Java编写的，所以我打算学习一下，在此基础上做一个Swift和Java的对照表。
我想从基础开始逐渐更新。
但是由于我对Swift的经验还不够丰富，所以不仅仅是Java，如果有错误或者更好的写法，或者还有其他写法，我希望能够在评论中得到指导和建议。

变量

变量

// 宣言
var num: Int
// 代入
num = 0
// 初期化 (var 変数名 = 値)
var num = 0

var str = "もしもし"
var bool = true

// 宣言
int num;
// 代入
num = 0;
// 初期化 (データ型名 変数名 値;)
int num = 0;

String str = "もしもし";
boolean bool = true

在Java中，分号是必须跟上的。很容易忘记。字符串是以大写字母开头的，原因将在后面解释。

定数 shù) – 这是一个预先设定的数值。

// let 変数名 値
let num = 0
let num: Int = 0

let greetingStr = "もしもし"

// final データ型名 変数名 値;
final int NUM = 0;

final String GREETING_STR = "もしもし";

・在开头添加关键词”final”。
・常数名称全部采用大写下划线格式命名。

数字

// 整数 
var int: Int = 0  // 実行環境によって32bit or 64bit

// 浮動小数点型
var float: Float = 0.1  // 10の38乗の正負 最小で6桁の精度
var double: Double = 0.1 // 10の308乗の正負 最小で15桁の精度

// 整数
byte by = 0; // 8ビット
short sh = 0; // 16ビット
int in = 0; // 32ビット
long lo = 0; // 64ビット

// 浮動小数型
float fl = 0.1; // 32ビット
double dou = 0.1; // 64ビット

// 末尾にF,LをつけることでFloat,Long型になる
num = 100F; // float型
num = 200L; // long型

我之前并不知道Swift的Int类型的范围会根据执行环境而变化。

文字論理：以文字為基礎的邏輯思維

// 文字列
var str: String = "Hello"

// Character型
var character: Character = "a"  

// 論理型
var bool: Bool = true

// 文字列
String str = "Hello";

// Character型
char ch = 'あ';

// 論理型
boolean bool = true;

在Java中，字符类型的数据用单引号括起来。

排列

var stringArray: [String] = ["サウナ", "水風呂", "ロウリュー"]
var boolArray: [Bool] = []

配列名.countで要素数を取得

// データ型[] 配列名 = new データ型[要素数];
String[] stringArray = new String["サウナ", "水風呂", "ロウリュー"];
boolean[] boolArray = new boolean[3]; // 3つの要素が入る配列
boolArray[0] = true;
int[] nums; // 配列の宣言
int[] nums2 = {0, 1, 2}

配列名.length で要素数を取得

声明要素数量是一种奇妙的感觉。

字典

// 辞書
var intDictionary: [String: Int] = ["サウナ": 37, "水風呂": 32, "ロウリュー": 6]

// 辞書 
 //Map, HashMap, Hashtable, LinkedHashMap, TreeMap...
Map<String, int> map1 = new HashMap<String, int>() {
        put("サウナ", 37);
        put("水風呂", 32);
        put("ロウリュー", 6);
};

看起来HashMap支持字典类型，但是我想要更深入地理解并详细记录相关内容。

元组

let position: (Int, Int, Int) = (35, 2, 90)
let x = position.0
let y = position.1
let z = position.2

// Javaにタプルはありませんが、クラスやライブラリを使ってタプルとして使う方法があるようです。

可选的为 nil 或 null。

var str: String?
var int: Int? = 0
var double: Double? = nil
var bool: Bool?

String str;
Integer int = 0;
Double double = null;
Boolean boolean;

下面是原始数据类型。这些变量用于存储具体的值，如整数值和实数值。它们不包含null。

byte、short、int、long、float、double、char、boolean

在Java中，原始数据类型都有对应的类版本（引用类型），称为”包装类”。
例如，Integer和Double等都以大写字母表示。而对于String来说，并不存在原始数据类型，只有类，因此需要以大写字母形式表示。

参照行保存在内存中的地址作为参照值存储在变量中。
类别超过3000种以上。

同样，需要小心处理两个包装类之间的比较。基本上，最好使用equals方法。

比較内容 結果 ラッパークラスとラッパークラスを==で同値比較 false ラッパークラスとラッパークラスをequalsメソッドで同値比較 true ラッパークラスとプリミティブ型を==で同値比較 true ラッパークラスとプリミティブ型をequalsメソッドで同値比較 true

投
【Option 1】演员

var int = 3
var double = 4.5
var result = Double(int) + double

int numInt = 3;
double numDouble = 4.5
double result = (double)numInt + numDouble;

在Java中，可以将int类型的值转换为long类型等进行扩大转换，但是不能将long类型转换为int类型进行缩小转换。

算子

基本的运算符（>、<、==、!= 等）在Swift和Java中是一样的。

虽然话题稍有改变，但是在Swift中，不同类型之间的计算会导致错误。
而在Java中，只要计算结果与被赋值的变量相符，就可以进行赋值操作。

var numInt = 3
var double: Double = 1.1
var double2: Double
double2 = numInt * double // エラー

int num = 3;
double numDouble = 1.1;
double numDouble2;
numDouble2 = num * numDouble; // 実行可能

空值检查 zhí

if let hoge = hoge {
print(hoge)
}

if hoge != nil {
print(hoge)
}

guard let hoge = hoge else { 
  return
}

String str = null;
if (StringUtils.isEmpty(str)) {
    System.out.println("str == null");
}

// strがnull
if (str == null) {
    System.out.println("str == null");
}
// strがnull以外
if (str != null) {
    System.out.println("str != null");
}

· Java不是nil。它是null。

语法

如果…

if dollar > 130 { 
print("円安")
} else if  dollar < 90 {
print("円高")
}

if age >= 18 {
print("成人")
} else {
print("未成年")
}

if (dollar > 130) {
System.out.println("円安");
} else if dollar < 90 {
System.out.println("円高");
}

if (age >= 18) {
System.out.println("成人");
} else {
System.out.println("未成年");
}

转换

switch num {
  case 1: print("1")
  case 2: print("2")
  case 3: print("3")
  default: print("default")
}

switch (num) {
  case 1: { System.out.print("1");
  break;
  }
  case 2: { System.out.print("2");
  break;
  }
  case 3: { System.out.print("3");
  break;
  }
  default: { System.out.print("default") }
}

在这个场景中，使用花括号{}包围节，并添加break;语句。

当

var num = 0
while num < 3 {
  num += 1
}

int num = 0;
while (num < 3) {
 num++;
}

据说Swift 3及以后版本已被废弃。

对于文

for i in 0..<3 {
  print(i)
}

// for(式1; 条件式; 式2)　{ 処理 }
// for(カウンタ変数の準備,カウンタ変数の条件式,　実際に実行する式)

for(int i = 0; i < 3; i++) {
System.out.print(i);
}

・Java的for循环看起来很复杂，但它实际上和Swift做的事情是一样的。
・以前，Swift似乎也像Java一样使用了类似C语言的for循环，但据说已经废弃了。

班级

班级 jí)

class Swift {

}

Class Java {
    // メインメソッド
    public static void main(String[] args) {
    }
}

・类的命名遵循与Swift相似的大写字母形式。
・主方法是在执行程序时首先调用的方法。关于主方法，如果搜索一下可以发现它有一些借鉴自C语言的特点，这也是很有趣的。

初始化（Java 构造方法）

class Human {
    var name:String
    var age:Int

    init(name:String, age:Int){
        self.name = name
        self.age = age
    }
}

let miyamoto = Human(name: "宮本武蔵", age: 29)

class Human {
    String name;
    int age;
 
    // 引数を持つコンストラクタ
    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
 
//インスタンスの生成
Human miyamoto = new Human("宮本武蔵", 29);

结构体

struct Human {
    var name: String
    var height: Int
}

let humanA = Human(name: "サウナ太郎", height: 180)

public class Human {
    private final String name;
    private final int height;

    public Human(String name, int height) {
        this.name = name;
        this.height = height;
    }
}

由于Swift会自动生成初始化函数，所以可以使用基本的初始化函数而不需要编写它。
在Java中没有struct的概念，因此需要声明为不可变（无法更改）的类。

协议

protocol Sauna { ... }

public interface Animal { ... }

接口与协议一样，强制类中方法的定义。
当定义类之间共同的规范时，使用接口；而抽象类则用于定义其他类的框架。

访问修饰符

迅速

修飾子 同クラス モジュール ファイル 継承、オーバーライド open ○ ○ ○ ○ public ○ ○ ○ – fileprivate ○ ○ ○ ○ internal ○ ○ – – private ○ – – –

如果上面的清单有错误，请指正。

・open 如果导入了该模块，则可以访问。还可以继承和重写。
・public 如果导入了该模块，则可以访问。但无法继承和重写。
・fileprivate 只能从同一文件访问。
・internal 可以从同一模块访问。还可以继承和重写。如果没有指定访问修饰符，默认为这个级别的限制。
・private(set) 在设置(set)时具有私有限制，在获取(get)时可以从同一模块内访问。
・private 只能在该类或结构体内部访问（也可以在扩展(extension)内访问）。

Java – 喜茶

修飾子 同クラス 同パッケージ サブクラス 他 public ○ ○ ○ ○ protected ○ ○ ○ – (なし) ○ ○ – – private ○ – – –

函数

没有返回值的函数

private func sayHello() {
    print("Hello")
}

private static void sayHello() {
    System.out.println("Hello");
}

・私有（private）是一个修饰符。

有返回值的函数

func getAge() -> Int {
    return 20
}

public static int getAge(){
    return 20;
}

具有返回值和参数的函数

func happyBirthDay(age: Int) -> Int {
    age += 1
    return age
}

public static int happyBirthDay(int age) {
    age++;
    return age;
}

在方法前加上static修饰符，就会变成静态方法。
静态方法可以直接被调用和使用，无需实例化类。以下是使用静态方法的优点。

・可以在不实例化的情况下使用
・保证不依赖于状态
・保证每个实例的行为都不会改变

调用函数

var age = getAge()
var newAge = happyBirthDay(age: age) // getAgeで取得したageを代入(Intの20)
// newAge 21

int age = getAge;
int newAge = happyBirthDay(age); // getAgeで取得したageを代入(intの20)
// newAge  21

其他

我打算在这里整理一些常用的方法和处理方式。

// IntからStringへ変換
var str = String(5)

// StringからInt?へ変換
var int = Int("5")

// intからStringへ変換
int num = 10;
Integer numInt = Integer.valueOf(num); // Intergerへ変換
String str = numInt.toString(); // Stringへ変換

// StringからIntへ変換
int int1 = Integaer.parseInt("5");

結束

因为有一定程度的整理，所以我先发布了，但以后还会继续添加内容。
在整理Swift和Java的过程中，我有很多收获，并且觉得非常有趣。

#技术文章