Java最全Scala 基础 （六）：面向对象（下篇），mysql索引面试题索引失效

最后

无论是哪家公司，都很重视基础，大厂更加重视技术的深度和广度，面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，是不是能真的得到锻炼。

针对以上面试技术点，我在这里也做一些分享，希望能更好的帮助到大家。

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

class Student extends Person{

// 实现抽象属性和方法

var age: Int = 18

def sleep(): Unit ={

println("student sleep")

}

// 重写非抽象属性和方法

override val name: String = “Student”

override def eat(): Unit = {

super.eat()

println("Student eat")

}

}

**匿名子类**



和 Java 一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类。匿名子类只针对抽象类和接口。



举个栗子：

object Test10_AnnoymousClass {

def main(args: Array[String]): Unit = {

// 匿名子类实现

val person = new Person {

  override var name: String = "alice"



  override def eat(): Unit = println("person eat")

}



println(person.name)

person10.eat()

}

}

abstract class Person {

var name: String

def eat():Unit

}

[]( )二、单例对象（伴生对象）

=========================================================================



Scala是一门完全面向对象的语言，没有静态操作。为了能够和Java语言进行交互，使用单例对象来取代`static`关键字的语义，伴生类的`静态声明`都可放在伴生对象中。



基本语法：

object 伴生对象名{

val country: String="China"

}

*   编译后会生成两个类，伴生对象是伴生类（类名为对应类后加$符号）的单例对象。

*   单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致，必须在同一个文件中。

*   单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

*   Scala 中 `obj(arg)`的语句实际是在调用该对象的 `apply` 方法，即 `obj.apply(arg)`。用以统一面向对象编程和函数式编程的风格。

*   Scala底层对于伴生对象的`apply`方法进行了优化，调用时可以省略方法名，直接使用`单例对象的名称+调用apply方法的参数`

*   当使用 `new` 关键字构建对象时，调用的其实是类的构造方法，当直接使用类名构建对象时，调用的其实时伴生对象的 `apply` 方法



举个栗子：

// 伴生类

// 构造器私有化

class Student private(val name: String, val age: Int) {

def printInfo(): Unit = {

println(s"Student11: $name $age ${Student11.school}")

}

}

// 伴生对象

object Student {

// 看作静态的属性

val school: String = “清华”

// 定义类对象实例创建的方法

def newStudent(name: String,age: Int): Student11 = new Student11(name,age)

def apply(name: String, age: Int): Student11 = new Student11(name, age)

}

object Test11_Object {

def main(args: Array[String]): Unit = {

val student = Student.newStudent("alice", 12)

student.printInfo()



val student1 = Student.apply("haha", 12)



val student2 = Student("lolo", 34)

student2.printInfo()

}

}

[]( )三、特质

=================================================================



如何定义特质？

trait 特质名 {

// 代码块

}

*   Scala 语言中，采用特质 `trait`（特征）来代替接口的概念

*   多个类具有相同的特征时，就可以将这个特征提取出来，用继承的方式来复用

*   Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（`mixin`）多个特质。这种感觉类似于 Java 中的抽象类。



基本语法：

有父类 class extends baseClass with trait1 with trait2 … {}

没有父类 class extends trait1 with trait2 … {}

*   如果一个类在同时继承特质和父类时，应当把父类写在 `extends` 后。

*   特质中可以定义抽象和非抽象的属性和方法。



**特质叠加引发两种冲突**



> 第一种：一个类（`Sub`）混入的两个 trait（`TraitA`，`TraitB`）中具有相同的具体方法，且两个 trait 之间没有任何关系



![在这里插入图片描述](https://img-blog.csdnimg.cn/0caf06e3ae7d4e56907a40dee36fc513.png)  

如果当前父类和特质里面出现了相同的属性和方法，就会起冲突，必须在当前实现的子类(`sub`)中进行重写。



举个栗子：

class Person {

val name: String = "Person"

var age: Int = 18



def sayHi(): Unit = {

    println(s"hello from : $name")

}

}

trait Young {

// abstract and non-abstract attribute

var age: Int

val name: String = "young"



// method

def play(): Unit = {

    println(s"young people $name is playing")

}

def dating(): Unit

}

trait Knowledge {

var amount: Int = 0

def increase(): Unit = {

    amount += 1

}

}

trait Talent {

def increase(): Unit = {

    println("increase talent")

}

}

class Student extends Person with Young with Knowledge with Talent{

override val name: String = "alice"



def dating(): Unit = {

    println(s"Sutdent $name $age is dating")

}



def study(): Unit = println(s"Student $name is studying")



override def sayHi(): Unit = {

    super.sayHi()

    println(s"hello from : student $name")

}



override def increase(): Unit = {

    super.increase() 

    println(s"studnet $name knowledge increase: $amount")

}

}

object Trait {

def main(args: Array[String]): Unit = {

    val s = new Student()

    s.sayHi()

    s.increase()



    s.study()

    s.increase()



    s.play()

    s.increase()



    s.dating()

    s.increase()

}

}

> 第二种：一个类（`Sub`）混入的两个 trait（`TraitA`，`TraitB`）中具有相同的具体方法，且两个 trait 继承自相同的 trait（`TraitC`）



![在这里插入图片描述](https://img-blog.csdnimg.cn/1781221b0f624e4aa1d8cb5a51378659.png)  

Scala采用了特质叠加的策略来解决这类冲突。



举个栗子：

trait Ball {

def describe(): String = “ball”

}

trait ColorBall extends Ball {

val colorBall: String = “red”

override def describe(): String = {

 colorBall+"-----"+super.describe()

}

}

trait CategoryBall extends Ball{

val categoryBall: String = “foot”

override def describe(): String = categoryBall+“-----”+super.describe()

}

// 叠加顺序 MyFootBall -> ColorBall -> CategoryBall -> Ball

class MyFootBall extends CategoryBall with ColorBall {

override def describe(): String = “my ball is a” + super.describe()

}

*   当一个类混入多个特质的时候，scala 会对所有的特质及其父特质按照一定的顺序进行排序，而此案例中的`super.describe(`)调用的实际上是排好序后的下一个特质中的 `describe()`方法。

*   要调用某个指定的混入特质中的方法，可以增加约束：`super[]`





# 总结

虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。

架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。

如果你也想成为一名好的架构师，那或许这份**Java成长笔记**你需要阅读阅读，希望能够对你的职业发展有所帮助。

![image](https://img-blog.csdnimg.cn/img_convert/6c3cbf253faa7fce5b420641b61c4722.webp?x-oss-process=image/format,png)



> **本文已被[CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**

**[需要这份系统化的资料的朋友，可以点击这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

混入特质中的方法，可以增加约束：`super[]`





# 总结

虽然我个人也经常自嘲，十年之后要去成为外卖专员，但实际上依靠自身的努力，是能够减少三十五岁之后的焦虑的，毕竟好的架构师并不多。

架构师，是我们大部分技术人的职业目标，一名好的架构师来源于机遇(公司)、个人努力(吃得苦、肯钻研)、天分(真的热爱)的三者协作的结果，实践+机遇+努力才能助你成为优秀的架构师。

如果你也想成为一名好的架构师，那或许这份**Java成长笔记**你需要阅读阅读，希望能够对你的职业发展有所帮助。

[外链图片转存中...(img-sqz37AU2-1715323351483)]



> **本文已被[CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)收录**

**[需要这份系统化的资料的朋友，可以点击这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**