iOS 开发入门指南-HelloWorld

原创 于 2025-09-08 19:53:21 发布 · 1.1k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ios

iOS 开发入门指南

目录

  1. 项目结构解析
  2. iOS vs Android 对比
  3. 核心语法科普
  4. AppDelegate 与 SceneDelegate
  5. 开发工具与快捷键
  6. 总结与建议

项目结构解析

HelloWorldApp 项目目录结构

HelloWorldApp/
├── HelloWorldApp/                    # 源代码目录
│   ├── AppDelegate.swift             # 应用程序委托
│   ├── SceneDelegate.swift           # 场景委托 (iOS 13+)
│   ├── Controllers/
│   │   └── ViewController.swift      # 视图控制器
│   ├── Assets.xcassets/              # 资源文件
│   ├── Base.lproj/
│   │   └── Main.storyboard          # 故事板文件
│   └── Info.plist                   # 应用配置文件
├── HelloWorldApp.xcodeproj/          # Xcode 项目文件
└── HelloWorldApp.xcworkspace/        # Xcode 工作空间文件

目录作用说明

目录/文件作用Android 对应
HelloWorldApp/源代码和资源文件app/src/main/
HelloWorldApp.xcodeproj/项目配置和构建设置.idea/ + build.gradle
HelloWorldApp.xcworkspace/工作空间配置（多项目管理）settings.gradle
Assets.xcassets/图片、颜色等资源res/drawable/
Info.plist应用元数据配置AndroidManifest.xml

iOS vs Android 对比

架构对比

概念iOS (Swift)Android (Kotlin/Java)
应用入口AppDelegateApplication 类
界面控制器ViewControllerActivity
布局方式代码布局 + Auto LayoutXML布局 + ConstraintLayout
生命周期管理viewDidLoad, viewWillAppearonCreate, onStart, onResume

项目管理对比

iOS 特点：

  • Xcode 隐藏技术细节，专注代码开发
  • .xcodeproj 和 .xcworkspace 在 Finder 中可见，Xcode 中隐藏
  • 统一的开发环境和工具链

Android 特点：

  • 项目结构完全可见和可编辑
  • 多种 IDE 选择（Android Studio、IntelliJ IDEA）
  • Gradle 构建系统更加透明

核心语法科普

1. 应用入口：AppDelegate

@main  // 相当于Android的Application类
class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?  // 相当于Android的根Activity
    
    func application(_ application: UIApplication, 
                    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // 相当于Android Application的onCreate()
        window = UIWindow(frame: UIScreen.main.bounds)
        window?.rootViewController = ViewController()  // 设置根控制器
        window?.makeKeyAndVisible()
        return true
    }
}

Android 对比：

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        // 应用初始化
    }
}

2. 界面控制器：ViewController

类声明和继承
// iOS
class ViewController: UIViewController {
    // 相当于Android的Activity
}

// Android
class MainActivity : AppCompatActivity() {
    // iOS的ViewController等价物
}
UI组件声明 - 闭包 vs 传统初始化

iOS 使用闭包初始化UI组件：

private let helloLabel: UILabel = {
    let label = UILabel()  // 创建实例
    label.text = "Hello, World!"  // 设置属性
    label.font = UIFont.systemFont(ofSize: 32, weight: .bold)
    label.textAlignment = .center
    label.textColor = .systemBlue
    label.translatesAutoresizingMaskIntoConstraints = false  // 关闭自动布局转换
    return label  // 返回配置好的实例
}()  // 立即执行闭包

Android 对比：

// 方式一：XML中定义 + 代码引用
<TextView
    android:id="@+id/helloLabel"
    android:text="Hello, World!"
    android:textSize="32sp"
    android:textAlignment="center"
    android:textColor="@color/blue" />

// 在Activity中引用
private lateinit var helloLabel: TextView

// 方式二：纯代码创建（类似iOS）
private val helloLabel: TextView by lazy {
    TextView(this).apply {
        text = "Hello, World!"
        textSize = 32f
        textAlignment = TextView.TEXT_ALIGNMENT_CENTER
        setTextColor(ContextCompat.getColor(context, R.color.blue))
    }
}
iOS vs Android 组件对比详解
特性iOS (UIKit)Android (View System)
组件创建闭包初始化 {}()XML声明 + findViewById 或 by lazy
属性设置点语法 label.text = "..."XML属性或代码设置 setText("...")
布局系统Auto Layout 约束LinearLayout/ConstraintLayout
字体设置UIFont.systemFont()android:textSize 或 setTextSize()
颜色系统.systemBlue 系统颜色@color/blue 资源引用
内存管理ARC 自动管理GC 垃圾回收
常用UI组件对应关系
iOS组件Android组件功能说明
UILabelTextView文本显示
UIButtonButton按钮控件
UITextFieldEditText文本输入
UIImageViewImageView图片显示
UIScrollViewScrollView滚动容器
UITableViewRecyclerView列表视图
UICollectionViewRecyclerView (Grid)网格视图
UISwitchSwitch开关控件
UISliderSeekBar滑动条
UIProgressViewProgressBar进度条
UIAlertControllerAlertDialog弹窗对话框
UINavigationControllerFragment + Navigation导航控制
组件初始化方式对比

闭包概念深度解析

什么是闭包？

闭包（Closure） 是一个可以捕获和存储其所在上下文中任意常量和变量引用的自包含的函数块。简单来说，闭包就是一个**“能记住周围环境的函数”**。

Swift 中的闭包语法

1. 基本语法结构：

{ (参数列表) -> 返回类型 in
    // 闭包体
    return 结果
}

2. in 关键字的作用：

in 关键字是Swift闭包语法中的分隔符，用于分隔闭包的参数声明部分和执行体部分：

{ (参数列表) -> 返回类型 in
    // 闭包体 - 实际执行的代码
}
  • in 之前：闭包的"签名"部分（参数列表和返回类型）
  • in 之后：闭包的"实现"部分（具体的执行代码）

语法规则：

  • 当闭包有参数或指定返回类型时，in 是必须的
  • 当闭包无参数且无返回类型声明时，可以省略 in
  • in 总是在参数声明之后，执行体之前

3. 闭包的几种形式：

// 完整形式
let fullClosure: (Int, Int) -> Int = { (a: Int, b: Int) -> Int in
    return a + b
}

// 简化形式（类型推断）
let simpleClosure = { (a: Int, b: Int) in
    return a + b
}

// 更简化（省略return）
let shorterClosure = { (a: Int, b: Int) in a + b }

// 最简化（使用$0, $1参数简写）
let shortestClosure = { $0 + $1 }

3. 立即执行闭包（IIFE - Immediately Invoked Function Expression）：

// 这就是UI组件初始化中使用的模式
private let result: Int = {
    let a = 10
    let b = 20
    return a + b
}()  // 注意这里的 () 表示立即执行

print(result)  // 输出: 30
Kotlin 中的对应概念

Kotlin 有闭包概念吗？ 答案是：有的，但叫法不同。

Kotlin 中对应的概念包括：

  1. Lambda 表达式
  2. 高阶函数
  3. 函数类型
  4. 匿名函数
Swift 闭包 vs Kotlin Lambda 对比
特性Swift 闭包Kotlin Lambda
基本语法{ param in body }{ param -> body }
参数简写$0, $1, $2it（单参数时）
类型声明(Int) -> String(Int) -> String
捕获变量自动捕获自动捕获
立即执行{ }()run { }
实际代码对比

Swift - 闭包的各种用法：

// 1. UI组件初始化（立即执行闭包）
private let titleLabel: UILabel = {
    let label = UILabel()
    label.text = "Hello"
    label.font = UIFont.boldSystemFont(ofSize: 16)
    return label
}()

// 2. 数组操作
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }  // [2, 4, 6, 8, 10]
let filtered = numbers.filter { $0 > 3 }  // [4, 5]

// 3. 异步回调
URLSession.shared.dataTask(with: url) { data, response, error in
    // 处理网络响应
}

// 4. 事件处理
button.addAction(UIAction { _ in
    print("按钮被点击")
}, for: .touchUpInside)

Kotlin - Lambda 的对应用法：

// 1. 延迟初始化（类似立即执行闭包）
private val titleLabel: TextView by lazy {
    TextView(this).apply {
        text = "Hello"
        setTypeface(null, Typeface.BOLD)
        textSize = 16f
    }
}

// 或使用 run 函数（更接近Swift的立即执行闭包）
private val titleLabel: TextView = run {
    val label = TextView(this)
    label.text = "Hello"
    label.setTypeface(null, Typeface.BOLD)
    label.textSize = 16f
    label
}

// 2. 集合操作
val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }  // [2, 4, 6, 8, 10]
val filtered = numbers.filter { it > 3 }  // [4, 5]

// 3. 异步回调
retrofit.getData().enqueue(object : Callback<Data> {
    override fun onResponse(call: Call<Data>, response: Response<Data>) {
        // 处理响应
    }
    override fun onFailure(call: Call<Data>, t: Throwable) {
        // 处理错误
    }
})

// 或使用协程
viewModelScope.launch {
    val data = repository.getData()
    // 处理数据
}

// 4. 事件处理
button.setOnClickListener {
    println("按钮被点击")
}
闭包的核心特性

1. 捕获变量（Variable Capture）：

// Swift
func makeIncrementer(incrementAmount: Int) -> () -> Int {
    var total = 0
    let incrementer: () -> Int = {
        total += incrementAmount  // 捕获了 total 和 incrementAmount
        return total
    }
    return incrementer
}

let incrementByTwo = makeIncrementer(incrementAmount: 2)
print(incrementByTwo())  // 2
print(incrementByTwo())  // 4

// Kotlin
fun makeIncrementer(incrementAmount: Int): () -> Int {
    var total = 0
    return {
        total += incrementAmount  // 捕获了 total 和 incrementAmount
        total
    }
}

val incrementByTwo = makeIncrementer(2)
println(incrementByTwo())  // 2
println(incrementByTwo())  // 4

2. 逃逸闭包 vs 非逃逸闭包：

// Swift - 非逃逸闭包（默认）
func performOperation(_ operation: () -> Void) {
    operation()  // 在函数返回前执行
}

// Swift - 逃逸闭包
func performAsyncOperation(_ completion: @escaping () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        completion()  // 在函数返回后执行
    }
}

// Kotlin - 所有lambda都可以"逃逸"
fun performOperation(operation: () -> Unit) {
    operation()  // 立即执行
}

fun performAsyncOperation(completion: () -> Unit) {
    Handler(Looper.getMainLooper()).postDelayed({
        completion()  // 延迟执行
    }, 1000)
}
UI组件初始化中的闭包优势

iOS - 闭包初始化的优势：

// ✅ 优点：配置集中、类型安全、立即执行
private let customButton: UIButton = {
    let button = UIButton(type: .system)
    button.setTitle("点击我", for: .normal)
    button.backgroundColor = .systemBlue
    button.layer.cornerRadius = 8
    button.translatesAutoresizingMaskIntoConstraints = false
    return button
}()

// 🔄 等价的Android写法
private val customButton: Button by lazy {
    Button(this).apply {
        text = "点击我"
        setBackgroundColor(ContextCompat.getColor(context, R.color.blue))
        background.cornerRadius = 8.dpToPx()
    }
}

为什么iOS偏爱闭包初始化？

  1. 配置集中：所有属性设置在一个地方
  2. 类型安全：编译时检查类型
  3. 立即执行：对象创建时就完成配置
  4. 代码清晰：避免在viewDidLoad中大量UI配置代码
  5. 性能优化：只执行一次，之后直接使用
总结

闭包的本质：

  • Swift的闭包和Kotlin的Lambda本质上都是**“函数式编程”**的体现
  • 它们都能捕获上下文、作为参数传递、延迟执行
  • 主要区别在于语法糖和使用习惯

学习建议：

  • 如果熟悉Kotlin的Lambda，理解Swift闭包会很容易
  • 重点掌握立即执行闭包的UI初始化模式
  • 理解逃逸闭包的概念，这在异步编程中很重要

**Android - XML声明的优势：**
```xml
<!-- ✅ 优点：可视化编辑、资源管理、主题适配 -->
<Button
    android:id="@+id/customButton"
    android:text="点击我"
    android:background="@drawable/rounded_button"
    style="@style/PrimaryButton" />
事件处理对比

iOS - Target-Action 模式详解：

核心概念解释：

  • Target：目标对象（通常是 self，即当前视图控制器）
  • Action：要执行的方法（通过 #selector 指定）
  • for：触发事件的类型（如点击、长按等）
// 方式一：addTarget（传统方式）
customButton.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
//                    ↑      ↑                              ↑
//                  目标对象  要执行的方法                    触发事件类型

@objc private func buttonTapped() {
    print("按钮被点击")
}

// 方式二：闭包（iOS 14+，现代方式）
customButton.addAction(UIAction { _ in
    print("按钮被点击")
}, for: .touchUpInside)

详细参数解释：

1. #selector 是什么？

  • #selector 是Swift中的选择器语法，用于将方法名转换为Objective-C可识别的选择器
  • 相当于告诉系统：“当事件发生时，调用这个方法”
  • 被 #selector 引用的方法必须标记为 @objc

2. for 参数 - 事件类型：

事件类型含义Android对应
.touchUpInside手指在按钮内部抬起（标准点击）OnClickListener
.touchDown手指按下OnTouchListener.ACTION_DOWN
.touchUpOutside手指在按钮外部抬起无直接对应
.valueChanged值改变（如滑块、开关）OnSeekBarChangeListener
.editingChanged文本编辑中TextWatcher.afterTextChanged
.editingDidEnd文本编辑结束OnFocusChangeListener

3. 完整的事件绑定流程：

// 步骤1：创建按钮
let button = UIButton(type: .system)
button.setTitle("点击我", for: .normal)

// 步骤2：绑定事件（Target-Action模式）
button.addTarget(self,                    // 目标：当前控制器
                action: #selector(handleButtonTap),  // 动作：要执行的方法
                for: .touchUpInside)     // 事件：手指在按钮内抬起

// 步骤3：实现响应方法
@objc private func handleButtonTap() {
    print("按钮被点击了！")
    // 处理点击逻辑
}

Android - 监听器模式：

// 方式一：setOnClickListener
customButton.setOnClickListener {
    println("按钮被点击")
}

// 方式二：XML中声明
// android:onClick="buttonTapped"
fun buttonTapped(view: View) {
    println("按钮被点击")
}
布局系统深度对比

iOS - Auto Layout 约束系统：

重要概念：view 是什么？

  • view 是 UIViewController 的根视图属性，相当于Android中的父容器
  • 它代表整个屏幕的主视图区域（除了状态栏、导航栏等系统UI）
  • 所有子视图都添加到这个 view 上，并相对于它进行布局约束

视图层级关系：

屏幕
├── 状态栏 (系统)
├── 导航栏 (可选)
└── view (ViewController的根视图) ← 约束代码中的 view
    ├── helloLabel
    ├── button
    └── 其他子视图...

// 代码方式设置约束
helloLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
//                                           ↑
//                                    ViewController的根视图
helloLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor, constant: -50).isActive = true
helloLabel.widthAnchor.constraint(equalToConstant: 200).isActive = true
helloLabel.heightAnchor.constraint(equalToConstant: 50).isActive = true

// 或使用 NSLayoutConstraint
NSLayoutConstraint.activate([
    helloLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    helloLabel.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 100)
    //                                        ↑
    //                                   安全区域（避开刘海、底部指示器）
])

iOS vs Android 对比：

iOSAndroid含义
viewparent父容器/根布局
view.centerXAnchorparent（水平居中）父容器的水平中心
view.safeAreaLayoutGuide无直接对应安全区域布局指南

**Android - ConstraintLayout 约束系统：**
```xml
<!-- XML方式设置约束 -->
<androidx.constraintlayout.widget.ConstraintLayout>
    <TextView
        android:id="@+id/helloLabel"
        android:layout_width="200dp"
        android:layout_height="50dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintBottom_toBottomOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

// 代码方式设置约束
val constraintSet = ConstraintSet()
constraintSet.connect(helloLabel.id, ConstraintSet.TOP, ConstraintSet.PARENT_ID, ConstraintSet.TOP, 100)
constraintSet.connect(helloLabel.id, ConstraintSet.START, ConstraintSet.PARENT_ID, ConstraintSet.START)
constraintSet.connect(helloLabel.id, ConstraintSet.END, ConstraintSet.PARENT_ID, ConstraintSet.END)
constraintSet.applyTo(constraintLayout)
样式和主题管理对比

iOS - 外观代理和样式：

// 全局样式设置
UILabel.appearance().font = UIFont.systemFont(ofSize: 16)
UIButton.appearance().tintColor = .systemBlue

// 个别组件样式
helloLabel.layer.cornerRadius = 8
helloLabel.layer.borderWidth = 1
helloLabel.layer.borderColor = UIColor.systemGray.cgColor
helloLabel.backgroundColor = .systemBackground

Android - 样式和主题系统：

<!-- styles.xml -->
<style name="CustomLabelStyle">
    <item name="android:textSize">16sp</item>
    <item name="android:textColor">@color/primary_text</item>
    <item name="android:background">@drawable/rounded_background</item>
</style>

<!-- 应用样式 -->
<TextView
    style="@style/CustomLabelStyle"
    android:text="Hello, World!" />
数据绑定和状态管理对比

iOS - 属性观察器和KVO：

class ViewController: UIViewController {
    @IBOutlet weak var countLabel: UILabel!
    
    var count: Int = 0 {
        didSet {
            countLabel.text = "计数: \(count)"
        }
    }
    
    // 或使用 Combine (iOS 13+)
    @Published var count: Int = 0
    
    override func viewDidLoad() {
        super.viewDidLoad()
        $count
            .map { "计数: \($0)" }
            .assign(to: \.text, on: countLabel)
            .store(in: &cancellables)
    }
}

Android - 数据绑定和LiveData：

// 使用 LiveData 观察数据变化
class MainActivity : AppCompatActivity() {
    private val viewModel: MainViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // 观察数据变化
        viewModel.count.observe(this) { count ->
            findViewById<TextView>(R.id.countLabel).text = "计数: $count"
        }
    }
}
导航和页面跳转对比

iOS - Navigation Controller：

// 推入新页面
let detailVC = DetailViewController()
navigationController?.pushViewController(detailVC, animated: true)

// 模态展示
let modalVC = ModalViewController()
present(modalVC, animated: true)

// 使用 Storyboard Segue
performSegue(withIdentifier: "showDetail", sender: self)

Android - Intent 和 Fragment：

// Activity 跳转
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("data", "传递的数据")
startActivity(intent)

// Fragment 切换
supportFragmentManager.beginTransaction()
    .replace(R.id.fragment_container, DetailFragment())
    .addToBackStack(null)
    .commit()

// 使用 Navigation Component
findNavController().navigate(R.id.action_main_to_detail)
核心差异总结
方面iOS 特点Android 特点
UI创建代码优先，闭包初始化XML优先，声明式布局
布局系统Auto Layout，约束驱动多种布局，ConstraintLayout推荐
样式管理代码设置，Appearance代理XML样式，主题系统完善
数据绑定手动绑定，Combine框架LiveData观察者模式
导航模式Navigation Controller栈Intent系统，Fragment管理
开发工具Interface Builder可选Layout Editor主流
预览功能SwiftUI PreviewLayout Preview
热重载有限支持Instant Run/Apply Changes
学习建议

从Android转iOS：

  1. 🎯 重点掌握Auto Layout约束系统
  2. 🎯 熟悉闭包初始化UI组件的模式
  3. 🎯 理解Target-Action事件处理机制
  4. 🎯 学习Navigation Controller的栈式导航

从iOS转Android：

  1. 🎯 掌握XML布局和ConstraintLayout
  2. 🎯 熟悉样式和主题系统
  3. 🎯 理解Activity和Fragment生命周期
  4. 🎯 学习Intent系统和数据传递

3. 生命周期方法

iOS：

override func viewDidLoad() {
    super.viewDidLoad()  // 相当于Android的onCreate()
    setupUI()           // 初始化UI
    setupConstraints()  // 设置约束
    setupActions()      // 绑定事件
}

Android：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)  // 设置布局
    setupUI()          // 初始化UI
    setupListeners()   // 绑定事件
}

4. 布局系统：Auto Layout vs ConstraintLayout

iOS Auto Layout (代码方式)：

NSLayoutConstraint.activate([
    // 水平居中
    helloLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    // 垂直位置
    helloLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor, constant: -60),
    // 边距约束
    helloLabel.leadingAnchor.constraint(greaterThanOrEqualTo: view.leadingAnchor, constant: 20)
])

Android ConstraintLayout (XML方式)：

<TextView
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintBottom_toBottomOf="parent" />

5. 事件处理：Target-Action vs Listener

iOS Target-Action 模式：

// 绑定事件
tapButton.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)

// 事件处理方法
@objc private func buttonTapped() {
    tapCount += 1
    // 处理点击事件
}

Android Listener 模式：

// 绑定事件
tapButton.setOnClickListener {
    tapCount++
    // 处理点击事件
}

6. 动画系统

iOS UIView 动画：

UIView.animate(withDuration: 0.3, animations: {
    self.tapButton.transform = CGAffineTransform(scaleX: 0.95, y: 0.95)
}) { _ in
    UIView.animate(withDuration: 0.3) {
        self.tapButton.transform = .identity
    }
}

Android 属性动画：

val scaleDown = ObjectAnimator.ofFloat(tapButton, "scaleX", 1f, 0.95f)
val scaleUp = ObjectAnimator.ofFloat(tapButton, "scaleX", 0.95f, 1f)
AnimatorSet().apply {
    play(scaleDown).before(scaleUp)
    duration = 300
    start()
}

AppDelegate 与 SceneDelegate

历史背景

AppDelegate 是 iOS 应用的传统架构核心，从 iOS 2.0 开始就存在。而 SceneDelegate 是 iOS 13.0 引入的新概念，用于支持多窗口应用。

核心区别

职责范围

AppDelegate（应用级别）：

  • 管理整个应用的生命周期
  • 处理应用启动、终止、后台等全局事件
  • 管理应用级别的配置和服务
  • 在 iOS 13 之前，也负责窗口管理

SceneDelegate（场景级别）：

  • 管理单个窗口/场景的生命周期
  • 处理窗口的创建、激活、失活等事件
  • 支持多窗口应用（iPad 分屏、Mac Catalyst）
  • 只在 iOS 13+ 中可用
代码对比分析

AppDelegate.swift 中的关键代码：

// iOS 12 及以下的窗口管理方式
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    window = UIWindow(frame: UIScreen.main.bounds)
    window?.rootViewController = ViewController()
    window?.makeKeyAndVisible()
    return true
}

// iOS 13+ 的场景配置方法
@available(iOS 13.0, *)
func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
    return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
}

SceneDelegate.swift 中的关键代码：

// iOS 13+ 的窗口管理方式
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    guard let windowScene = (scene as? UIWindowScene) else { return }
    
    window = UIWindow(windowScene: windowScene)
    window?.rootViewController = ViewController()
    window?.makeKeyAndVisible()
}

执行流程

iOS 13+ 设备上的执行顺序：
  1. AppDelegate.application(_:didFinishLaunchingWithOptions:) - 应用启动
  2. AppDelegate.application(_:configurationForConnecting:options:) - 配置场景
  3. SceneDelegate.scene(_:willConnectTo:options:) - 创建窗口
  4. SceneDelegate.sceneDidBecomeActive(_😃 - 场景激活
iOS 12 及以下设备：
  1. AppDelegate.application(_:didFinishLaunchingWithOptions:) - 应用启动并创建窗口
  2. 直接使用 AppDelegate 管理窗口生命周期

AppDelegate 和 SceneDelegate 的连接机制

重要发现：AppDelegate 中没有直接引用 SceneDelegate

很多开发者会疑惑：AppDelegate 和 SceneDelegate 之间是如何连接的？ 实际上，它们之间是"松耦合"的关系，通过系统配置文件连接，而不是直接的代码引用。

连接机制详解

1. Info.plist 配置文件是关键

<key>UISceneDelegate</key>
<dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
        <dict>
            <key>UISceneConfigurationName</key>
            <string>Default Configuration</string>
            <key>UISceneDelegateClassName</key>
            <string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
        </dict>
    </array>
</dict>

2. AppDelegate 的间接连接

// AppDelegate.swift 中的关键方法
@available(iOS 13.0, *)
func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
    // 返回配置名称，对应 Info.plist 中的 UISceneConfigurationName
    return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
}

3. 完整的连接流程

应用启动
    ↓
AppDelegate.didFinishLaunchingWithOptions
    ↓
系统请求场景配置
    ↓
AppDelegate.configurationForConnecting 返回 "Default Configuration"
    ↓
系统查找 Info.plist 中名为 "Default Configuration" 的配置
    ↓
找到对应的 UISceneDelegateClassName: SceneDelegate
    ↓
系统自动实例化 SceneDelegate 类
    ↓
SceneDelegate.scene(_:willConnectTo:) 被调用
    ↓
创建和管理窗口
关键理解点

松耦合设计的优势：

  • 灵活性：可以通过修改 Info.plist 更换不同的 SceneDelegate 类
  • 可配置性：支持多种场景配置，适应不同的应用需求
  • 向后兼容：iOS 12 及以下版本会忽略 Scene 相关配置
  • 系统管理：由系统负责实例化和生命周期管理，减少样板代码

为什么不直接引用？

  • 支持多场景应用（一个应用可以有多个不同的 SceneDelegate）
  • 允许动态配置场景类型
  • 保持架构的清晰分离

是否有必要都存在？

建议保留两者的情况：

  1. 需要支持 iOS 12 及以下版本

    • AppDelegate 处理旧版本的窗口管理
    • SceneDelegate 处理新版本的场景管理

  2. 计划支持多窗口功能

    • iPad 分屏应用
    • Mac Catalyst 应用

  3. 渐进式迁移

    • 保持向后兼容性
    • 逐步采用新架构
可以简化的情况：

  1. 只支持 iOS 13+

    • 可以移除 AppDelegate 中的窗口管理代码
    • 专注使用 SceneDelegate

  2. 简单的单窗口应用

    • 可以在 Info.plist 中移除 Scene 配置
    • 只使用 AppDelegate（传统方式）

开发工具与快捷键

Xcode 常用快捷键

导航和搜索
功能XcodeAndroid Studio (macOS)
全局搜索⌘ + Shift + F⌘ + Shift + F
文件搜索⌘ + Shift + O⌘ + Shift + O
类/符号搜索⌘ + Shift + O⌘ + O
快速打开⌘ + T⌘ + Shift + A
代码编辑
功能XcodeAndroid Studio (macOS)
代码补全Ctrl + SpaceCtrl + Space
格式化代码Ctrl + I⌘ + Alt + L
注释/取消注释⌘ + /⌘ + /
重命名⌘ + Ctrl + EShift + F6
跳转和导航
功能XcodeAndroid Studio (macOS)
跳转到定义⌘ + Ctrl + J 或 ⌘ + 点击⌘ + B 或 ⌘ + 点击
返回上一位置⌘ + Ctrl + ←⌘ + Alt + ←
前进下一位置⌘ + Ctrl + →⌘ + Alt + →
查找用法⌘ + Shift + FAlt + F7
构建和运行
功能XcodeAndroid Studio (macOS)
构建项目⌘ + B⌘ + F9
运行应用⌘ + RCtrl + R
停止运行⌘ + .⌘ + F2
清理构建⌘ + Shift + K无直接对应

自定义快捷键

在 Xcode 中自定义快捷键：

  1. 打开 Xcode → Preferences → Key Bindings
  2. 搜索要修改的功能
  3. 双击快捷键列进行修改
  4. 可以导出/导入快捷键配置文件

总结与建议

关键语法特点总结

  1. Swift vs Kotlin/Java：

    • Swift 更函数式，大量使用闭包
    • 可选类型 (?) vs Nullable types
    • 属性观察器 vs 传统getter/setter

  2. 布局哲学：

    • iOS：代码布局为主，约束系统
    • Android：XML布局为主，声明式

  3. 生命周期：

    • iOS：viewDidLoad → viewWillAppear → viewDidAppear
    • Android：onCreate → onStart → onResume

  4. 事件处理：

    • iOS：Target-Action 模式，需要 @objc 标记
    • Android：Listener 接口，Lambda 表达式

学习建议

  1. 从基础开始：理解 MVC 架构和生命周期
  2. 实践为主：多写代码，熟悉 Swift 语法
  3. 对比学习：利用已有的 Android 经验类比学习
  4. 关注差异：重点理解两个平台的设计哲学差异
  5. 工具熟练：掌握 Xcode 的使用和调试技巧

下一步学习方向

  1. UI 进阶：学习 UIKit 更多组件和布局技巧
  2. 数据管理：Core Data、UserDefaults、网络请求
  3. 架构模式：MVVM、Coordinator 等现代架构
  4. SwiftUI：苹果的声明式 UI 框架
  5. 性能优化：内存管理、性能调试工具

UIKit 框架详解

什么是 UIKit？

UIKit 是苹果公司为 iOS 和 tvOS 开发提供的核心用户界面框架。它是构建 iOS 应用程序用户界面的基础框架，提供了创建和管理应用程序界面所需的所有基本组件和功能。

UIKit 的核心定位

import UIKit  // 导入UIKit框架

// UIKit是iOS应用开发的核心框架
// 几乎所有的UI相关类都来自UIKit
class ViewController: UIViewController {  // 继承自UIKit的UIViewController
    let label = UILabel()      // UIKit的标签组件
    let button = UIButton()    // UIKit的按钮组件
    let imageView = UIImageView()  // UIKit的图片组件
}

UIKit 框架的组成部分

1. 视图和控件 (Views and Controls)

基础视图类：

  • UIView - 所有视图的基类
  • UILabel - 文本显示
  • UIButton - 按钮控件
  • UIImageView - 图片显示
  • UITextField - 文本输入框
  • UITextView - 多行文本编辑

容器视图：

  • UIScrollView - 滚动视图
  • UITableView - 表格视图
  • UICollectionView - 集合视图
  • UIStackView - 堆栈视图

控制组件：

  • UISwitch - 开关
  • UISlider - 滑动条
  • UISegmentedControl - 分段控制
  • UIProgressView - 进度条
  • UIStepper - 步进器
2. 视图控制器 (View Controllers)
// 视图控制器是UIKit的核心概念
class MyViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        // 视图加载完成后的初始化
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        // 视图即将出现时的处理
    }
}

// 特殊的视图控制器
class MyTableViewController: UITableViewController {
    // 专门用于管理表格视图
}

class MyNavigationController: UINavigationController {
    // 用于导航管理
}
3. 布局系统 (Layout System)

Auto Layout：

// UIKit的约束布局系统
NSLayoutConstraint.activate([
    label.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    label.centerYAnchor.constraint(equalTo: view.centerYAnchor),
    label.widthAnchor.constraint(equalToConstant: 200),
    label.heightAnchor.constraint(equalToConstant: 50)
])

Frame-based Layout：

// 传统的坐标布局方式
label.frame = CGRect(x: 100, y: 200, width: 200, height: 50)
4. 事件处理系统 (Event Handling)

Target-Action 模式：

// UIKit的事件处理机制
button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)

@objc func buttonTapped() {
    print("按钮被点击了")
}

手势识别：

// 手势识别器
let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))
view.addGestureRecognizer(tapGesture)
5. 动画系统 (Animation System)
// UIKit提供的动画API
UIView.animate(withDuration: 0.3) {
    self.view.backgroundColor = .red
    self.label.alpha = 0.5
}

// 更复杂的动画
UIView.animate(withDuration: 0.5, 
               delay: 0.1,
               usingSpringWithDamping: 0.8,
               initialSpringVelocity: 0.2,
               options: .curveEaseInOut) {
    self.button.transform = CGAffineTransform(scaleX: 1.2, y: 1.2)
}

UIKit 与其他框架的关系

UIKit vs SwiftUI
特性UIKitSwiftUI
发布时间2008年 (iOS 2.0)2019年 (iOS 13.0)
编程范式命令式编程声明式编程
布局方式Auto Layout + Frame声明式布局
状态管理手动管理自动响应式
学习曲线较陡峭相对平缓
兼容性iOS 2.0+iOS 13.0+
// UIKit 方式
class UIKitViewController: UIViewController {
    @IBOutlet weak var label: UILabel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        label.text = "Hello UIKit"
    }
}

// SwiftUI 方式
struct SwiftUIView: View {
    var body: some View {
        Text("Hello SwiftUI")
    }
}
UIKit 与 Foundation 的关系
import Foundation  // 基础框架
import UIKit      // UI框架，依赖Foundation

// Foundation提供基础数据类型
let string: String = "Hello"        // Foundation
let array: Array<Int> = [1, 2, 3]   // Foundation
let url: URL = URL(string: "https://apple.com")!  // Foundation

// UIKit提供UI组件
let label: UILabel = UILabel()       // UIKit
let button: UIButton = UIButton()    // UIKit
let view: UIView = UIView()          // UIKit

UIKit 的核心设计模式

1. MVC (Model-View-Controller)
// Model - 数据模型
struct User {
    let name: String
    let age: Int
}

// View - 视图 (UIKit组件)
class UserView: UIView {
    let nameLabel = UILabel()
    let ageLabel = UILabel()
}

// Controller - 控制器
class UserViewController: UIViewController {
    let userView = UserView()
    var user: User?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        updateUI()
    }
    
    func updateUI() {
        userView.nameLabel.text = user?.name
        userView.ageLabel.text = "\(user?.age ?? 0)"
    }
}
2. Delegate 模式
// UIKit大量使用委托模式
class MyViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
    
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return 10
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
        return cell
    }
}

UIKit 的优势和特点

优势：
  1. 成熟稳定 - 经过15年的发展和优化
  2. 功能完整 - 提供了构建复杂应用所需的所有组件
  3. 性能优秀 - 经过高度优化，运行效率高
  4. 兼容性好 - 支持从iOS 2.0到最新版本
  5. 生态丰富 - 大量第三方库和资源
  6. 精确控制 - 可以精确控制每个像素和动画
特点：
  1. 命令式编程 - 需要明确告诉系统如何做
  2. 手动内存管理 - 需要注意循环引用等问题
  3. 生命周期管理 - 需要理解视图控制器的生命周期
  4. 事件驱动 - 基于事件和回调的编程模式

学习 UIKit 的建议

学习路径：
  1. 基础概念 - 理解视图、视图控制器、生命周期
  2. 基本组件 - 掌握常用的UI组件使用
  3. 布局系统 - 学习Auto Layout约束布局
  4. 事件处理 - 理解Target-Action和手势识别
  5. 高级特性 - 动画、自定义控件、性能优化
实践建议：
  1. 从简单开始 - 先做Hello World类型的应用
  2. 多写代码 - UIKit需要大量实践才能熟练
  3. 阅读文档 - 苹果官方文档是最好的学习资源
  4. 参考示例 - 学习优秀的开源项目代码
  5. 调试技巧 - 掌握Xcode的调试和性能分析工具

总结

UIKit 是 iOS 开发的核心框架，它提供了构建用户界面所需的所有基础组件和功能。虽然苹果推出了 SwiftUI 作为新的 UI 框架，但 UIKit 仍然是 iOS 开发的重要基础，特别是在需要兼容旧版本 iOS 或需要精确控制 UI 的场景下。

对于初学者来说，理解 UIKit 的核心概念（视图、视图控制器、生命周期、事件处理）是掌握 iOS 开发的关键。通过实际项目练习，逐步掌握 UIKit 的各种组件和特性，是成为优秀 iOS 开发者的必经之路。

iPhone开发【一】从HelloWorld开始
长弓的专栏
09-24 2万+
转载请注明出处，原文网址：http://blog.csdn.net/m_changgong/article/details/8013553 作者：张燕广 从经典的HelloWorld开始踏入iPhone开发的大门吧！ 关键字：HelloWorld iPhone IOS 1、打开xcode，选择“Create a New Xcode project” 2、xcode中的工程分
关于iOS中的布局向导（Layout Guide）和安全区域（Safe Area）
热门推荐
Puzhi的专栏
01-30 1万+
iOS在默认情况下，竖屏会显示状态栏，横屏自动隐藏状态栏。而视图控制器的主视图默认位于屏幕顶端，在竖屏时会被顶部状态栏遮挡。如果我们希望不被状态栏遮挡，则需要先判断横竖屏，然后动态显示隐藏状态栏。如果界面中还存在导航栏、分页栏，情况就更复杂一些。总之，自己处理是一件很麻烦的事情。 布局向导 在iOS 7中，苹果引入了Top Layout Guide（顶部布局向导）和Bottom Layout Gu...
笨鸟学iOS开发（1） HelloWorld
weixin_30485291的博客
11-30 100
目的 HelloWorld，开发入门！ 环境 Mac OS X 10.7.2 Xcode4.2 步骤 1：构建界面（相当于写.aspx） 拖放一个文本框和一个按钮到MainStoryboard_iPhone.storyboard上 2：映射控件（相当于写.aspx.desig...
创建iOS应用HelloWorld
cnjsyzgl的博客
06-05 811
第一个Swift程序 在应用文件夹打开 Xcode开发工具，打开后在屏幕顶部选择 File => New => Playground
ios - Guide（新手引导）页
xu9441213的博客
01-19 1185
AppDelegate.h#import <UIKit/UIKit.h> #import <CoreData/CoreData.h> #import "ViewController.h" #import "HelperViewController.h"@interface AppDelegate : UIResponder <UIApplicationDelegate>@property (stro
iOS开发入门指南：从HelloWorld到表格应用
"ios开发入门" 本文档是一份关于iOS开发入门的教程，主要针对初学者，旨在引导读者逐步学习如何使用iOS 5进行应用程序开发。教程由EntLib.com小组翻译整理，提供了从创建第一个“HelloWorld”应用到构建更复杂的...
iOS开发入门：从HelloWorld到AppStore发布
《iOS6开发指南》详细介绍了从创建简单的“HelloWorld”程序开始，直到在App Store发布完整应用的所有关键步骤和技术。书中通过实例演示了如何使用Xcode创建项目，以及如何配置和理解工程设置，如产品名称、组织标识...
掌握Android与iOS开发：Hello World入门指南
4. **Hello World程序：** “Hello World”是初学者入门的第一个示例程序，通常会介绍如何创建一个简单的界面，并在屏幕上显示“Hello, World!”文本。 5. **实例代码分析：** 通过分析具体的代码实例，初学者可以...
iOS平台OpenCV入门指南——HelloWorld示例
在iOS开发中，一个简单的OpenCV的Hello World程序可能只是读取一张图片，然后显示出来。这个过程看似简单，却涉及到iOS应用开发中的基本知识，包括图像的加载、显示以及UI界面的管理。 要创建一个iOS的OpenCV Hello...
iOS开发入门指南：搭建第一个Hello World应用
# 一、iOS开发入门指南概述 ## 1.1 什么是iOS开发 iOS开发是指基于苹果公司的iOS操作系统进行应用程序开发的过程。iOS操作系统是一种专门为苹果设备（如iPhone、iPad和iPod Touch）设计的操作系统。开发者可以使用...
iPhone的第一个程序HelloWorld开发图解
08-08
iPhone的第一个程序HelloWorld开发图解.
Xcode下的HelloWorld
04-15
Xcode下的HelloWorld，很简单的Sample。
基于Xcode4开发第一个iPhone程序：“HelloWorld”
02-26
写一个iPhone程序，在屏幕正中显示文字“HelloWord”，粗体，字体大小26磅，字体颜色红色，有黑色阴影，阴影光源为左上角，偏移1像素，支持设备旋转。在开始之前，我们首先来分析一下项目需求，这是一个非常简单的项目，只要在屏幕上显示一段“HelloWorld”的文字，当然还有一些附加条件：根据这些需求，我们将从简单到复杂，逐步来实现，分成2步来实现：iPhone4之前的屏幕是320x480，到iPhone4的时候，支持了高清屏，屏幕分辨率变成了640x960。iPhone支持四个方向的旋转的，横屏和竖屏表现略有差异，因为项目需求要求支持屏幕旋转，所以针对横屏和竖屏，界面表现有所差异，简单
xcode 3.2.6 最入门的hello world程序
07-11
本人学习xcode的 step1 帮助最初学习者了解xcode的属性。
教程：使用 Xcode 编写 Mac OS X 下的"Hello, World!"
niqinwen520的博客
05-16 1058
教程：使用 Xcode 编写 Mac OS X 下的"Hello, World!" 这篇短小的教程展示了如何创建一个 Mac 应用程序工程，这个 Mac 应用程序在一个窗口里显示一串文字。通过这篇教程，您将熟悉在 Xcode 下软件开发的整个流程：创建工程，设计用户界面，编码并运行。同时还能学到如何调试在代码编写过程中 Xcode 发现的错误，进而了解 Xcode 的调试工具。 ...
Xcode 建立 UIKit 项目（Hello World）
iOS 开发
07-25 1300
如何建立一个 Xcode 项目
使用 Xcode 创建第一个 Objective-C 命令行程序 HelloWorld
wuyujin1997的博客
02-21 2616
可以运行当前选中的Target(点击上图中顶部红圈位置可以切换要运行的Target)。点击左上角表示项目(带有App图标)的栏目，可以看到项目基本信息。在 Xcode 左上角和右上角有两个按钮(已标红圈)，点击可以。要么按左上角的启动按钮(小三角)，要么按快捷键。依旧是 Objective- C 的命令行工具。运行的Target名(不是项目名)这次只需要填本次的Target名（即。填好项目名、组织标识符(没有的写个。本次要新增的Target是怎样的？，切换成本次要运行的那个，我们输出的日志字符串。
Xcode创建一个Hello World项目（2021-4-8）
qq_51476492的博客
04-08 952
1.在项目文件夹中选择Main.storyboard文件，这个文件会在编辑器面板中打开，在纯白色背景中会看到一个完全空白的IOS设备屏幕，这就是Xcode的Interface Builder，用来设计应用的用户界面。 每个storyboard都是由一个或多个视图控制器构成的，且每个视图控制器至少有一个视图。视图就是眼睛可以看到并可以在Interface Builder中进行编辑的部分，而控制器则是你编写的应用代码，用来处理用户的交互事件。应用的实际操作都是在控制器内执行的。 点击矩形轮廓（IOS设备屏幕）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

低调小一

您的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值