基本概念 编程语言总共有两大类，一类以汇编语言和c语言为首的最底层的用于嵌入式编程的面向过程编程，另一类就是以JAVA、C++、Python为首的面向对象编程。
面向编程和面向对象的区别有很多，优缺点也很明显。
1.运行效率，面向过程的执行效率比面向对象的执行效率更高，因为他更适用于底层的硬件上，去命令计算机做事情，面向对象是基于操作系统来控制电脑进行执行的，效率慢一点，但是思想更高级。
2.运用场景，软硬件编程的区别
三大特征 封装、继承、多态
或者可以吧抽象也加上
1.封装：把相关的数据封装成一个“类”组件。
就相当于把你的身份信息登记在册。
2.继承：是子类共享父类属性和方法，这是类之间的一种关系。
就相当于子承父业。
3.多态：增强软件的灵活性。
就相当于子承父业之后，进行了拓展业务。
抽象：父类知道子类需要用到什么方法，但是不知道子类怎么实现。
就好像你爸知道你要吃饭，但是不知道你用筷子还是勺子吃饭。
类 1.是JAVA语言中最基本的单位，类似于基本类型
2.类是一种事物的抽象
3.可以看成是基建的图纸，或者设计图
对象 对象的三个特点，对象的状态，对象的行为和对象的标识
是用来描述具体事物的
1.对象的状态是用来描述具体事物的基本特征。
通俗点来说就是对象的成员变量。
2.对象的行为是用来描述具体事物的行为方式。
通俗点来说就是对象的方法。
3.对象的标识是用来区别于其他对象的特征。
通俗点来说就是每个对象在内存中都有自己特定的地址值来表示，我们可以通过地址值来索引到不同的对象。
类和对象的关系 类是一类事物的抽象，对象是具体事物的实现
类的成员变量和方法，用来描述一类事物的属性和方法
对象是类的具体实现。
对象在内存中的存储方式 对象被新建后，被存在内存的堆中，对象在堆中的地址值，被存放在栈中。
ex1:
package tedu.day06_oop;
/**
*分析手机事物：--类（类型）
* 属性：品牌 价格 尺寸 颜色 （成员变量）
* 功能：打电话 发短信 点外卖 （方法）
*/
//在一个java文件中，可以有多个类，但是只能有一个类被public修饰
//并且此类的名字和文件名相同public class Test1_ClassExec {
//4.创建入口函数
public static void main(String[] args) {
//5.在main()中通过new关键词创建手机类对象p
Phone phone = new Phone();
//6.通过.来完成对象功能的调用
phone.call();
phone.eat();
phone.message();
//7.通过.来查看对象的属性值
phone.brand = "华为";
phone.price = 9999.99;
phone.size = 6.1;
phone.color = "粉色";
System.out.print("品牌：" + phone.brand + "\n"
+ "价格：" + phone.price + "\n"
+ "尺寸：" + phone.size + "英寸"+ "\n"
+ "颜色：" + phone.color + "\n");
//8.创建第二个对象
Phone p2 = new Phone();
//9.通过噗对象调用Phone类中的功能
p2.call();
p2.message();
p2.eat();
p2.color = "绿色";
p2.brand = "苹果";
p2.size = 6.1;
p2.price = 6799;
System.out.print("品牌：" + p2.brand + "\n"
+ "价格：" + p2.price + "\n"
+ "尺寸：" + p2.size + "英寸"+ "\n"
+ "颜色：" + p2.color + "\n");
}
}//1.创建手机类
/**通过关键字class穿件手机类--用来描述手机这一类事物--属性+功能*/
class Phone {
//2.定义属性
/**通过成员变量来描述属性，位置：类里方法外，无需手动初始化*/
//品牌
String brand;
//价格
double price;
//尺寸
double size;
//颜色
String color;
//3.定义功能
/**通过类的方法来描述功能--修饰符 返回值类型 方法名(参数){方法体}*/
public void call(){
System.out.println("正在打电话");
}
public void message(){
System.out.println("正在发短信");
}
public void eat(){
System.out.println("正在点外卖");
}
}私有化 对象中可以存在被private控制修饰符修饰的属性或者方法，一旦被private修饰之后，除了这个类本身，外部所有的类都不能直接访问到这个属性。
package tedu.day06_oop;
public class Test2_Private {
//4.在公共类中，创建入口函数main()
public static void main(String[] args) {
//5.创建学生类对象--通过new关键字创建学生类对象
Student s = new Student();
//6.初步测试Student类对象s
System.out.println(s.name);
s.eat();
//可以通过"."来调用对象的study()
//7.给s对象的属性赋值
s.name = "程序猿";
s.sno = "0001";
s.setSubject("Java培优CGB");
//8.查看赋值以后的属性值
System.out.println(s.name);
System.out.println(s.sno);
System.out.println(s.getSubject());
}
}
//1.通过class关键字创建学生类--描述学生这一个类型--属性+方法
class Student{
//2.定义属性--成员变量--类内方法外--无需手动初始化
String name;
//姓名
String sno;
//学号
private String subject;
//科目public void setSubject(String subject) {
this.subject = subject;
}public String getSubject() {
return subject;
}//3.定义行为--方法
private void study(){
System.out.println("正在学习JAVA");
}
public void eat(){
study();
System.out.println("端起我的饭盆，觉醒干翻之魂");
}
}
构造方法 1.在创建新对象的时候调用的方法。
2.是一种特殊的方法，与类同名，且没有返回值类型的方法。
3.可以含参数，也可以不含参数
☆☆☆☆☆☆
1.如果一个类中，没有构造方法，这时候系统会默认这个类有一个无参构造方法。
2.如果一个类中，定义了一个含参数的构造方法，那么这时候系统会默认这个类没有无参构造方法，所以一般在重写第二个构造方法的时候，自己添加一个无参构造方法。
☆☆☆☆☆☆
变量 1.成员变量：在整个类的中都生效的变量，定义在类中，类方法外。
2.局部变量：只在局部生效的变量，定义在方法中，或者在局部代码块中。
代码块的加载顺序
最先加载的是，静态方法和静态变量，然后在新建代码的时候，优先执行静态代码块，在执行构造代码块，在接着执行构造方法，最后执行对象的方法。
为什么要引入构造代码块？
1.不同的构造方法中，可能存在相同的操作，所以把相同的操作提炼出来，减少代码的重复编写，节省代码空间，让查找更加的方便快捷。
this关键字
this表示被类对象的一个引用对象。 继承 继承就是从已有的类中派生出一个新的类，这个类包含了原有类的所有方法和属性，并且可以有自己的特有属性和方法，但是他不能选择只继承原有类中的某些属性和方法，只能全继承，这样就能使代码的服用率提高，不必去重新创建一个大相庭径的类，降低了开发的费用。
1.特点：
1）关键字是extends
2）相当于把父类复制了一份
3）java只支持单继承，子类只能有一个父类，但是一个父类可以有多个子类
4）继承的关系可以传递
5）子类不能继承父类的私有成员
6）继承多用于功能的修改，因为子类可以重写父类的方法，是功能改变
7）像是is a的关系
ex：
package tedu.day07_oopextends;
/**本类是继承的入门案例*/
public class Test5_ExtendsDemo {
//5.创建程序入口函数main()
public static void main(String[] args) {
//6.创建Cat类对象进行测试
Cat cat = new Cat();
cat.eat();
System.out.println(cat.a);
cat.a = 20;
//7.创建DingDang类进行测试
DingDang d = new DingDang();
d.eat();
System.out.println(d.a);
//System.out.println(d.b);
}
}/**
* 1.子类与父类是继承关系，用extends关键词来建立关系
* Java只支持单继承，一个子类只能有一个父类，一个父类可以有多个子类
*/
//1.创建一个动物类Animal
class Animal{
//4.定义父类中的普通方法
public void eat(){
System.out.println("吃啥都行!~");
}
}//2.创建小猫类Cat
class Cat extends Animal{
static int a = 10;
//private int b = 100;
--5.父类的私有资源，子类不能继承
}/**3.子类继承父类以后，相当于把父类的功能进行了赋值
* 4.继承具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给儿子
* 6.继承是is a 的关系，要求子类必须是父类的一种继承结构，依赖性非常强，强耦合性*/
//3.创建DingDang类继承Cat类
class DingDang extends Cat{}
方法的重写 方法的重写只存在于继承关系中，子类重写了父类的方法。
1）父类的私有方法不能被重写
2）子类的控制修饰符要大于等于父类的方法的控制修饰符
3）子类的方法名，方法返回值，方法的参数列表都一样，但是方法体不一样（实现的功能或者业务不一样）的时候，称为方法的重写。
super关键字，子类中可以调用父类，表示父类的引用。
static关键字，被static修饰的属性或者方法，是一个静态属性或者方法，可以使用类名来调用
被static关键字修饰的属性，必须赋值，而且所有本类的对象共享
final关键字，修饰类名、方法、变量之后，该类就不能被继承，该方法就不能被重写，该变量就不能被改变，变成了一个常量这个常量也必须赋值
多态 【学习笔记|JAVA五--面向对象基础】好处：
1）我们可以不用知道一个对象到底是什么类型的，创建了之后就可以调用该对象的某些方法
2）提高了程序的课拓展性和可维护性
特点：
1）成员变量：都是用的父类的。
好比是花木兰替父从军，用的是父亲的名字。
2）成员方法：由于存在重写的现象，使用的是子类的。
但是他不可能用父亲的方式去实现方法，而使用自己重写的方式来使用的
3）静态成员：随着类的加载而加载，谁调用就返回谁的
ex：
package tedu.day08_oopstatic;
/**本类用于完成OOP汽车设计综合案例*/
/**
* 1.分析事物，得出它的属性和功能
* 2.提取类中的共同点，向上抽取，形成父类Car
* 3.子类继承父类后，就拥有的父类的功能
* 4.如果对父类的功能不满意，可以重写
* 5.可以封装某些类的属性，如果封装了，就要提供对应的get()/set()
*/
public class Test7_ExtendsDesignCar {
//3.创建入口函数main()
public static void main(String[] args) {
Car c = new Car();
System.out.println(c.getColor());
c.start();
c.stop();
//5.创建宝马类对象进行测试
BMW b= new BMW();
System.out.println(b.color);
System.out.println("*********");
b.start();
b.stop();
//6.创建保时捷类对象进行测试
Porsche p = new Porsche();
System.out.println(p.color);
p.start();
p.stop();
}
}
//0.创建一个汽车类
class Car{
//0.1定义Car的属性
//0.3通过private对Car类的属性进行封装
private String brand;
//品牌
private String color;
//颜色
//0.4属性封装后，对外提供公共的get()与set()便于外界对属性进行操作
//command+n-->Getter And Setter-->command+a-->Generatepublic String getBrand() {
return brand;
}public void setBrand(String brand) {
this.brand = brand;
}public String getColor() {
return color;
}public void setColor(String color) {
this.color = color;
}
//0.2定义Car类的启动于停止方法
public void start(){
System.out.println("我的车车启动啦～～～");
}
public void stop(){
System.out.println("哎呀妈，我的车车熄火了～～～");
}
}//1.创建一个宝马类并且继承Car类
class BMW extends Car{
String color = "五彩斑斓的黑";
@Override
public void start(){
super.start();
System.out.println("宝马启动，加油们~~冲啊");
}
}//2.创建一个保时捷类并且继承Car类
class Porsche extends Car{
String color = "黑不溜秋的白";
@Override
public void stop(){
System.out.println("保时捷想停的稳当点～～～～");
}
}
推荐阅读
- cgb2108第一阶段复习资料
- CGB2202|CGB2202面向对象第4天
- java|微信上传 wx.chooseMedia和wx.uploadFile使用，java springboot后端跑通
- spring源码|Spring源码解析十八
- 蓝桥杯|【蓝桥杯】看完这些，还在担心自己拿不到奖（）
- 算法解答题目
- 什么是好的错误消息? 讨论一下Java系统中的错误码设计
- 《mongodb经典入门》|四.MongoDB入门-Java操作MongoDB
- 技术|基于canal实现mysql和es增量数据同步