1，如何理解面向对象？
（1）面向对象的特点
它是一种思想，它可以使复杂的问题简单化，
它可以实现角色转变，是我们从执行者转变为指挥者
（2）举例说明（结合实际场景，遇到什么场景就举什么例子）
例子1：
现在这场面试其实就是在运用面向对象的思想在解决问题，公司老板招聘员工代表公司的业务量大，公司蒸蒸日上在发展，公司需要找一些具备专业知识的对象来完成公司的工作，我们中的某些人就是这个对象，具备这些专业的知识，您就可以指挥这些人来完成这些工作，为公司创造业
绩
 相对来说，如果是面向过程，公司的老板做这些业务，完成这些工作量，就需要具备的这些专业知识，熟悉完成这些业务的
每一个过程。
 老板通过雇佣员工，使用员工的能力，将复杂的问题简单化，同时也从程序的执行者变成了指挥者。

电子数字计算机诞生于1946年，在其后漫长的历史进程中，计算机始终是供养在特殊的机房中，是只能实现数值计算的大型昂贵设备。直到20世纪70年代，微处理器的出现，计算机才出现了历史性的变化。以微处理器为核心的微型计算机以其小型、价廉、高可靠性特点，迅速走出机房；基于高速数值解算能力的微型机，表现出的智能化水平引起了控制专业人士的兴趣，要求将微型机嵌入到一个对象体系中，实现对象体系的智能化控制。现在你看到到的一些智能设备大多数都是嵌入式开发出来的，可以说嵌入式无处不在。
嵌入式的发展大大改善了人们的生存状态，人们可以让机器代替我们去生产，也可以使用更先进的设备来娱乐生活，让我们的生活变得更智能化，可以说嵌入式代表着最先进的生产力。而未来对智能设备和自动化设备的需求肯定也是越来越高，毕竟人总是懒惰的，也总是爱享受的，机器干活了人就可以歇着了，更高端的智能设备也能丰富人们的生活，所以成为一名嵌入式工程师是非常有前途的！
要学习嵌入式就要先学习C和C++这两门编程语言。其实要成为“代码搬运工”，我觉得还是很简单的，为什么呢？编程语言其实也是语言，我们只要将要执行的动作翻译成芯片的语言就可以了。举个例子我们要拿起一个苹果，但是我们不是自己去拿，我们要让一个只听得懂英语的工人去拿，怎么办呢？你要用英语告诉他“pick up this apple”,只有这样讲他才会去拿起苹果；现在我们把这个工人换成了只听得懂C语言的芯片，你该怎么办呢？同样的，你要用C语言告诉芯片去拿起苹果，道理都是一样的，只是C语言有C语言的用法，我们只要按着他的规则写就OK了。
对于嵌入式底层工程师来说，我们要学习的不仅仅是C语言的基本语法，更重要的是如何通过C语言这个工具，去理解我们的计算机系统、CPU架构：
1）程序到底是如何编译、链接、和运行的？
2）运行时各种代码段、数据段、BSS段、堆栈在内存中如何分布，如何管理的？
3）程序在不同的平台(ARM、X86)、裸机环境或有OS的环境(linux、uc/os等)有何不同？
4）静态链接与动态链接的过程有何差异，为什么要使用动态链接？共享库？
5）不同的开发平台、IDE、编译器，C语言的编程有何差异和不一样的地方，如何做到跨平台、增强程序的可移植性和鲁棒性？
6）各种变量名、函数名、数组名、指针的本质是什么？编译器是如何处理的？
搞懂了这些语言背后计算机系统知识，还远远不够，还要去学习操作系统相关的知识：进程、线程、中断、内存管理等。
对于嵌入式开发来说，还要学习ARM等处理器架构知识、GCC编译器对C标准的各种扩展，各种生僻的用法，否则你去看linux内核代码、驱动代码，总感觉“怪怪的”，好像哪里不对，跟平时的C语言不太一样，感觉自己学的是一门假C语言…
C语言的精华是内存、存储管理。各种隐藏很深的bug其实也跟内存有关：内存越界、内存泄露、野指针等等，一个不经意的疏漏，就可能阴沟里翻船。就是有多年工作经验的工程师也不敢保证自己写的代码一定没有问题。C语言默认大家都是大牛、计算机专家，可惜现实中往往太多挖坑小能手，太多猪一样的队友。如何养成良好的编程习惯，避免各种bug，也是C语言进阶学习的一个重点。

面向对象的特点：它是一种思想，它让复杂的问题简单化，它把执行者变成了指挥者。


结合实际场景来说：其实面试官你就是在用面向对象的思想在思考问题，为什么这么说？因为公司业务蒸蒸日上，需要招更多的人来完成项目，所以才在这里招聘人员，你需要找一些具备专业编程经验的人，来    帮公司完成工作，那么我就是那个对象，因为我具备专业编程能力，你就是那个指挥者，指挥我来做事，至于我怎么去完成编程任务，你是不需要去知道，你只要结果了就可以了，这其实就是把你之前的工作简化了，你不必再事必躬亲了。这就是面向对象思想的体现。

a) 类到底是什么？
类就是对一类事物的归纳。

类就是对现实生活中事物的描述，描述中包含了该类事物的共性内容。
Class Car()
{
Int num;
String color;
Void run(){}
}
在类中定义的变量和函数都称为类中的成员。
成员：
成员变量---属性
成员函数---行为

b) 什么是对象？
对象就是该类事物实实在在存在的个体。
：现实生活中的对象：张三、李四
想要描述：提取对象中的共性内容，对具体的抽象。
描述时：这些对象的共性有姓名年龄性别学习java的功能。
对象也可以理解为其实就是个容器，用来存储更多的数据，存储的都是每一个对象特有的数据，而类就是这些数据所属的属性。
毕向东视频的小车问题：


Class Car
{
String color="red";
Int num=4;
Run()
{
System.out.println(color+""+num);
}
}
Class CarDemo
{
Public static void main(String[] args)
{
Car c=new Car();
C.color="bule";
C.num=5;
C.run();m
Car c1=new Car();
C1.num=8;
C1.color="green";
C1.run();
}
}







6、成员变量和局部变量的区别：
1、源代码中定义位置不同：
成员变量：定义在类中，在整个类中有效。
局部变量：定义在函数中，在局部范围内有效。
简单一句话：作用范围不一样，成员变量作用于整个类中，局部变量作用于函数中，或者语句中。
2、在内存中的位置和事件不同：
生命周期不同：
成员变量：随着对象的创建的而出现在堆内存中，随着对象被回收而消失。
局部变量：随着变量所属局部区域的运行，而出现在栈内存中，随着所属区域运行结束而释放。
3、变量使用的初始化：
成员变量：因为堆内存中都有默认初始化值，对于引用型变量默认值就是null;
局部变量：因为在栈内存中都没有默认初始化值，必须手动初始化后才可以参与运算。


7、匿名对象：
即没有名字的对象，简化书写用的。
基本使用：
1、当对对象的方法只调用一次时，可以用匿名对象来完成
这样写比较简化，如果对一个对象进行这个成员的调用，必须给这个对象起个名字
2、可以将匿名对象作为实际参数进行传递。一旦对对对进行多个成员操作时。必须要对对象起个名字。

Main()
{
Show(new  Car（））
}
Public  static void show (Car c)
{
C.num=3；
C.color="back";
C.run();
}


8、面向对象三个特征：
封装：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式，凡是面向对象必须有封装性。
特点：
将变化隔离
便于使用
提高复用性
提高安全性
原则：
1、将不需要对外提供的内容都隐藏起来。
2、把属性都隐藏，提供公共方法对其访问。
在代码中的体现：
1、将成员变量都私有化，并通过共有的方法对其进行访问，这两个方法是:setXxx\getXxx
2、只要不准备对外提供的全部都封装起来，
私有仅仅是封装的一种表现形式，函数是最小的封装体。

Class Person
{
	Private int age;//为了不让其他程序直接访问age属性，避免错误的数据，可以使用一个关键字来完成private私有，它是一个权限修饰符。private是权限等级最小的，public最大
	Public void setAge()//对外提供函数是可以控制你输入的参数。
	//一个成员变量通常对应的两个方法、
	{
		If(a>140||a<0)
		{
			Age=a;
			Speak();
		}
		Else
			System.out.println();
		}
		Public void getAge()
		{
			Return age;
		}
	
		Void speak()
		{
			Sop();
		}

	}



		Class PersonDemo
		{
			Public static void main(String[] args)
		{
			Person p=new  Person();
			P.age=-20;//错误数据是因为对象直接访问age属性造成的。
			P.speak();
		}
}


总结：之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句
对访问的数据进行操作，提高代码的健壮性。凡是set开头的返回值类型是void，get开头的跟它的返回值类型一致。




Day07总结：
1、构造函数：
特点：1、函数名和类名相同
          2、不用定义返回值类型
          3、不可以写return语句
作用：
创建一个对象都会执行这个构造函数，所以构造函数的作用给对象进行初始化。
每一个对象的创建，都必须要通过对应的构造函数进行初始化，对象不初始化是不能用的。

注意
没有定义类的情况下有一个默认的空参数的构造函数，方便该类的对象进行初始化。
如果在类中定义了具体的构造函数，那么默认的空参数构造函数就没有了。





2、构造函数和一般函数的区别：
1、格式：
两种函数的格式不同：
构造函数：修饰符 类名（参数列表）{}
一般函数：修饰符 返回值类型 自定义函数名（参数列表）{}
2、运行方式
构造函数：构造函数是在对象已经建立就执行对应的构造函数，给对象进行初始化。
一般函数：对象创建后，再调用一般函数。
3、作用不同
构造函数：是对对应对象进行初始化的，叫做对象已建立时要做什么事情？
一般函数：给对象提供更多的功能，方便与对象的调用。
4、调用次数
构造函数：对象创建时，就调用一次，因为初始化动作最先执行，只执行一次
一般函数：对象创建后，可以被多次调用。
3、什么时候定义构造函数呢？
分析具体事务时，该事务已经存在，就应该具备一些属性值，或者行为，那么将这些内容都定义在构造函数中。（列：婴儿刚出生都具有哭的属性值，那么就可以定义在构造函数中）
一个类中构造函数可以有多个，而且是以重载的形式存在。
小细节：
a) 构造函数中是可以写return语句的，因为当构造函数中存在判断的时，可以写return，作用就是结束语句。

b) 同样构造函数是可以添加void的，这样的话就不是构造函数了，就成为了一般函数了。


3 构造代码块：
作用：给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。


和构造函数的区别：

构造代码块是给所有对象进行统一初始化，

而构造函数是给对应的对象初始化。
构造代码快中定义的是不同对象共性的初始化内容。
代码示例：

class Person
{
	private String name;
	private int age;
	
	/*
	构造代码块。
        */
	{
		//System.out.println("person code run");
		cry();
	}
	
	//构造函数
	Person()
	{
		System.out.println("A: name="+name+",,age="+age);
		
	}
	/**/
	Person(String n)
	{
		name = n;
		System.out.println("B: name="+name+",,age="+age);

		//cry();
		
	}
	
	Person(String n,int a)
	{
		name = n;
		age = a;
		System.out.println("C: name="+name+",,age="+age);
		//cry();
	}

	public void cry()
	{
		
		System.out.println("cry......");
	}
}

class  PersonDemo2
{
	public static void main(String[] args) 
	{
		Person p1 = new Person();
		Person p2 = new Person("lisi");
	}
}


this关键字：
当成员变量和局部变量重名的时候，为了区分这种情况我们可以使用一个关键字来完成，就是this
它代表的是什么呢？This关键字代表的就是一个对象的引用。
代表哪个对象？ 代表当前对象，它自己不是对象，只是一个引用。
只要是成员，必须被对象所调用。
总的一句话：定义功能时，如果功能中用到了本类对象，这时就使用this这个关键字

7、this关键字：
当成员变量和局部变量重名的时候，为了区分这种情况我们可以使用一个关键字来完成，就是this
它代表的是什么呢？This关键字代表的就是一个对象的引用。
代表哪个对象？ 代表当前对象，它自己不是对象，只是一个引用。
只要是成员，必须被对象所调用。
总的一句话：定义功能时，如果功能中用到了本类对象，这时就使用this这个关键字表示这个对象。
用毕老师的话说
哪个对象在调用this所在的函数，this就代表哪个对象



总结：构造函数之间的调用，构造函数中调用其他构造函数的this语句必须定义在构造函数的第一行，因为构造函数是用来初始化的。初始化的动作必须先执行。





7、static静态关键字 
1、它是一个修饰符，只能修饰成员(成员变量和成员函数)
2、被static修饰的成员变量的数据，可以被所有的对象们共享。
3、被静态修饰的成员多了一种调用方式，就是除了被对象调用以外，还可以被类名直接调用，类名.静态成员。
4、静态之所可以被类名调用，那是因为静态成员是随着类的加载而加载进内存的。非静态的特点随着对象的加载而加载。
5、静态优先于对象加载进内存，所以不能访问对象的内容，但是对象可以访问它的内容。
6、被静态修饰的成员为共有数据，对象里面自身村存储的是特有数据。
Eg:饮水机是共有的，但是喝水的杯子是特有的。
怎么理解共性？只要在描述事物的时候发现这特点是大家都有的。
10、静态的使用注意事项：
1、静态成员函数只能访问类中的静态成员，不能访问非静态的。非静态方法可以访问静态方法。
2、静态方法中不可能定义this spuer关键字，因为This代表的是对象，但是静态加载的时候都没有对象存在。
主函数是静态的。


成员变量和静态变量的区别：
1、成员变量只能被对象所调用，静态成员变量除了可以被对象调用还可以被类名调用
2、成员变量也称为对象变量或者实列变量。因为成员变量是被对象使用的变量。静态变量也称为类变量。
3、成员变量是随着对象的出现而出现，随着对象的回收而消失。静态变量随着类的加载而加载，随着类的消失而消失。
一个代码中一个静态都不写是可以的，不写静态是因为静态的生命周期特别长，但是我们要考虑到代码的严谨性是需要写一些静态的。


什么时候使用静态？
成员变量：如果该变量的数据值每个对象都一样。就将其静态修饰，否则就是非静态。
成员函数：如果功能中没有访问到对象中的特有数据，那么就需要将该函数定义成静态，因为创建对象调用除了浪费堆内存空间没有意义。


静态代码块：
格式：
Static
{
静态代码块中的执行语句。
}
特点：随着类的加载而加载而且只执行一次，类一加载静态代码块就执行。
作用：用于给类进行初始化的，注意区别构造代码块：给对象都进行初始化。





1、单列设计模式：
a) 什么是设计模式：解决某一类问题最行之有效的方法。
b) 单列设计模式：解决一个类在内存中只存在一个对象。


1 为了避免其他程序过多的建立该类对象。先控制禁止其他程序建立该类对象
2 还为了让其他程序可以访问到该类对象只好在本类中自定义一个对象。
3 为了方便其他程序对自定义对象的访问可以对外提供一些访问方法。


怎么代码体现：
1、将构造函数私有化。
2、在类中创建一个本类对象。
3、提供一个方法可以获取到该类对象。
对于事物该怎么描述，还怎么描述。

当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。



饿汉式：
Class Single 恶汉式：定义单列时，建议使用恶汉式。
{
	Private int num;
	Public void setNum(){}
	Public int getNum(){}
	Private static Single s=new Single();

	//为什么要私有？对成员数据可控？因为方法很有可能有参数，所以不用把S暴露出去，加private;
	
	Public static Single getIntnstance()
	{
	Return s;
	}
}





单列延迟加载方式：
懒汉式：增加了一个判断

//只有对象被调用的时候才会被加载，才被初始化，称之为懒汉式。


Class Single
{
	Private Single(){}
	Private static Singel s=null;
	Public static Single getIntance()
	{
	If(s==null)
	S=new Single();
	Return s;
	}
}




继承：
a) 概述：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无序再去定义这些属性和行为，只要继承那个类即可。
b) 那多个类成为子类，单独这个类成为父类或者基类超类，
c) 子类可以直接访问父类重的非私有的属性和行为。
d) 通过extends关键字让类与类之间产生继承关系。
特点：
1、继承的而出现提高了代码的复用性。
2、继承的出现让类与类之间产生了关系，提供了多态的前提。
3、Java支持单继承，对于多继承，java保留了这种机制并进行了改良，避免了多继承调用时的不确定性。



什么时候使用继承？
当事物之间存在着所属关系时，就可以使用继承，
所属：xxx是yyy的一种，即x继承y
如果A真继承了B，B中的锁有的功能是不是A都具备了。

继承子父类中的成员变化。 
1、成员变量：
a) 当子父类中出现同名的成员变量时，可以使用super关键字来区分，父类的成员变量。
b) Super和this用法很相似，this代表的是本类的对象，super代表父类的所属的空间，
c) 先有父类在有子类。面试中会出现，开发中几乎没有，因为父类的成员都是从下到上抽取的，子类中还保留相同的变量干嘛？
2、成员函数
   当子父类出现一模一样(返回值、函数名、参数列表全部相同)的函数时，就会出现调用时运行子类的方法的情况。
   这种情况，形象成为覆盖或者重写或者覆写。
   什么时候用覆盖？
   当对一个类中的功能的内容进行重新定义时，可以定义该类的子类，并保留父类中的功能声明，重新定义功能内容，并建立子类对象调用该功能。
   
    
实现代码：


/*
当子父类中出现一模一样的函数时，就会出现调用时运行子类的方法的情况。
这种情况，形象的称为 覆盖或者重写或者叫做覆写 override。


什么时候用覆盖?
当对一个类中的功能的内容进行重新定义的时，可以定义该类的子类，并保留父类中的功能声明，
重新定义功能内容。并建立子类对象调用该功能。


覆盖小细节：

1，子类方法覆盖父类方法时，权限必须大于等于父类的权限。

2，静态只能覆盖静态，或者被静态覆盖。



构造函数
   特点：
   在运行时，发现父类构造方法先运行了，然后才是子类构造函数。
   原因：是因为子类的所有的构造函数中都有一句默认的隐式语句：super()；会默认调用父类重空参数的构造函数。
   为什么有super默认语句呢？
   因为子类对象在初始化时，必须要到父类先去初始化。
   为什么要到父类中去初始化呢？
   因为子类继承了父类，可以获取父类中的数据，所以在使用父类数据之前必须要明确父类是如何对自己的成员进行初始化的。
这也是子类一定要访问父类构造函数的原因。所以父类的构造函数有两个作用：1、给本类初始化

如果父类中的没有空参数的构造函数，
   那么此时在手动就必须通过super语句或this语句指定要访问父类的构造函数。

   注意:super关键字必须定义第一行。任何构造函数中的默认第一句都是super.
   面试题：为什么super和this不能再构造函数中同时出现？
   为什么super语句必须放在第一行？
   因为只有父类初始化完之后才初始化子类。
    Object是java中所有类的父类。

额，我发现这么把概念堆在一起，纯属蛋疼。

一、MySQL概述
1.什么是数据库
数据库（Database）就是按照数据结构来组织，存储和管理数据的仓库。
专业的数据库是专门对数据进行创建，访问，管理，搜索等操作的软件，
比起我们自己使用文件读写的方式对象数据进行管理更加的方便，快速，安全。
2.数据库的特点及作用

对数据进行持久化的保存。
方便数据的存储和查询，速度快，安全，方便。
可以处理并发访问。
更加安全的权限管理访问机制。

3.常见的数据库

MySQL
ORACLE
PostgreSQL
SQLServer

特殊数据库（配合上面的常见数据库使用）：
redis:最大特点是可以把数据存储在内存中
mongoDB:文档型数据库

4.MySQL内部简介
库：Database

表：Table  一个库可以创建多个表，表有不同的引擎，代表内部不同的存储机制，常用的为InnoDB

表中：存储的数据。

格式：行row 列col 表头Header内部存储的是一个个的字段Field。
二、MySQL基本代码
1.mysql -h localhost -u root -p
功能：在终端连接MySQL数据库

-h是服务器地址  -u后面跟的root是用户名，-p是密码，可以在后面直接写密码。
2.show databases
功能：查看所有库。
3. select * from users；




代码
含义




select * from users；
查看列中的数据


select
关键字，代表查询


*
代表查询的列（字段）有哪些   *表示所有列


from
关键字  表示从哪个表查询


users
表示要查询的表


；
MySQL中默认的语句结尾符


4.desc 表名
功能：查看表结构。返回的信息如下：




Field
Type
Null
Key
Default
Extra




字段
该字段的数据类型
代表是否允许为空
索引：PRI是主键的缩写
默认值
自动增加


id
int(10)
NO
PRI
NULL
auto_increment


name
varchar(20)
YES
/
NULL
auto_increment


age
int(11)
YES
/
NULL
auto_increment


5.show create table users\G；
功能：查看users这个表的创建语句，并格式化结果使看的更清晰




代码
含义




show
关键字：表示查看/显示


create
关键字：表示创建


table
关键字：表示表


users
查看的表


\G
格式化结果


；
表示sql语句的结尾


三、MySQL的基本操作
1.使用方法：

方式一：通过在命令行敲命令来操作（有助于命令的掌握）
方式二：通过图形界面工具，如Navicat等（在熟练掌握后使用）
方式三：通过编程语言（Python，php，java…）执行MySQL命令

2.SQL（Structure query language）结构化查询语言
SQL语言分为4个部分：DDL（定义）、DML（操作）、DQL（查询）、DCL（控制）
3.SQL语句中的快捷键

\G		格式化输出
\s		查看服务器端信息
\c		结束命令输入操作
\q		退出当前sql命令行模式
\h		查看帮助

4.操作数据库的步骤
连接，打开库，操作，关闭退出
①.通过命令行连接MySQL
mysql -h localhost -u root -p -P 3306

-P:端口号，MySQL默认端口号为3306
②数据库语法的特点

SQL语句可以换行，要以分号结尾
命令行不区分大小写，关键字和函数建议用大写
提示符：如果提示符为’>那么需要输入一个’回车，同理如果提示符为“>那么同样需要输入一个"
命令打错并换行后不能修改上一行的命令，可以用\c取消

5.数据库操作

查看数据库 show databases;
创建数据库 create database 库名 default charset=utf8mb4;
删除数据库 drop database 库名;
打开数据库 use 库名;

6.数据库操作
数据库管理系统中，可以有很多库，每个数据库中可以包括多张数据表。

表头每一项称为字段FIeld，每一条数据称为一行Row。

查看表

show tables;

创建表

create table 表名（字段名1 类型，字段名2 类型）engine=innodb default charset=uft8mb4;

创建表第二种语法：如果表不存在，则创建，如果存在就不执行这条命令

create table if not exists 表名(字段名1 类型，字段名2 类型);

建表例子：
create table if not exists users(
	id int not null primary key auto_increment,
	name varchar(4) not null,
	age tinyint,
	sex enum('男','女')
)engine=innodb default charset=utf8mb4;

查看表结构

desc 表名;

查看建表语句

show create table users;
7.数据操作 增删改查
插入

insert into 表名(字段1，字段2，字段3）values(值1，值2，值3);

insert into 表名(字段1，字段2）values(a值1，a值2)(b值1，b值2）;
查看

select * from 表名;

select 字段1，字段2，字段3 from 表名;

select * from 表名 where 字段=某个值;
修改

update 表名 set 字段=某个值 where 条件;

update 表名 set 字段1=值1，字段2=值2 where 条件;

update 表名 set 字段=字段+值 where 条件;
删除

delete from 表名 where 字段=某个值;