钢七连实战C3-P2:项目源码结构 面向对象基础 堆分配

钢七连软件培训

C3-P2  面向对象  第2节
1.怎样阅读一套项目源码
2.面向对象基本技术
https://blog.csdn.net/weixin_42644456

一、通用的学习路线，解决办法
学习资源：慕课，样例代码。
通用的解决办法：查资料，分析设计，编码，调试

大学基础课程和基本功的重要性。程序员，设计师，架构师。

二、面向对象具体知识
程序是打出来的。
不要发明一个项目，技术是通过阅读学习的。
20%的讲解，30%的案例阅读，50%的编码。

难点分析。初学者理解困难。当学习了更多课程、有了更多积累之后，就能听懂。
老师做的多个中等案例：
https://blog.csdn.net/weixin_42644456/article/details/103092496
学生能读懂多少，能做出多少，能不能做更好的。

Java难题的原理，是C/C++基础知识.

C3-P1:java的安装、环境变量的含义，命令行的编译和运行。
C3-P1更正:程序文件：JavaGame.java
文件中的类名: public class JavaGame 和文件名一致。
   C3-P2:eclipse或者其他工具。
Java, eclipse都有大量安装教程、配置教程。
Eclipse的版本(32/64)要和jdk匹配32位、64位.
Eclipse配置jdk路径。
Window-- Preferences--搜索JDK： java/installed JRES 添加本机jdk路径。
例如：C:\Program Files (x86)\Java\jdk1.7.0_60

eclipse编辑文本。由eclipse找到jdk,触发java的编译、运行。如果是控制台main, 把运行结果输出在eclipse的窗口上。

三、案例阅读：
初级效果：LegendCarry0925_1 飞机大战源码

中等效果：LegendCarry0927飞机大战源码
游戏角色：飞机、敌机、子弹、BOSS
地图：背景图片。
游戏功能：多个关卡,BOSS1,BOSS2,...
多种运动方式：BOSS怎么动，飞机拐弯，子弹斜着飞，道具飘动
游戏事件的触发，数据刷新：碰撞检测

大二下学期：planegame_finalV2源码
增加了数据库：用户注册、登录，保存玩家生命值、得分等数据。
增加了设计模式：单件、工厂、备忘录。适合于大一、大二初学者。大三、大四是否能改进。

四、怎样阅读一套工程代码：
学习目标：类是什么，答：封装、继承、多态。菜谱。科一。
学习目标：类怎样组成了一个项目。做饭。科二、科三。
程序是打出来的：不是看会了菜谱，再做饭。是会做饭以后，理解了菜谱。

语言无关(c++,java, javascript, python)。
阅读顺序：Model，View，Control。

阅读顺序：Model这个应用软件、游戏软件的数据怎样存放。
View数据、图片怎样输出到屏幕。
Control业务逻辑，行为。

1.按照代码难度，先找到数据类Model类：
玩家积分，飞机类，敌机类，子弹类....
数值设计岗位：王者荣耀的一个英雄，是同一个类，有30多个数值属性。
比如：int hp; int mp; int attack_distance;
   int attack_speed;     int shield;
int magic_distance; 
int attack_type;//攻击范围：1一个点/区域范围
不同角色，是数值高低的组合搭配。
高级数值设计：所有英雄，所有技能，是五个因素的组合搭配：
1.攻击 2.防守 3.控制 4.运动方式 5.伤害范围
攻防技能的数值设计，伤害，防守，有趣，平衡。
Model的设计：
(1)一个数据、一个类。（实训）
(2)父类、子类。复杂设计模式。类、接口的设计。（培训机构）
少量代码、通用代码，实现复杂功能。
(3)复杂数据结构。

2.工程View部分：新建了哪些窗口，有那些界面元素
飞机类，敌机类的图片素材是哪些文件(Model)，怎样输出图片(View)

3.行为Control部分：
（1）鼠标、键盘事件接口
（2）游戏循环，碰撞检测
（3）碰撞检测：事件触发和数值改变，攻防结算，生命值改变，积分，吃到道具。
事件触发和数值改变：
A.简单写法。初学者用分支、循环、函数，用堆积函数的办法，做更多功能。代码越来越多，容易出错，难以调试，不可维护。
B.用了设计模式的改进写法。通用的一段代码，完成多个功能。好的写法，重复、组合各种模块/功能点，由此产生大型复杂游戏。
（4）数据刷新：胜负
（5）数据刷新：事件、状态、动作。产生BOSS，这一关失败，这一关胜利
事件、状态、动作：有限状态机。可以写任何游戏。

以飞机大战/LegendCarry0927为例：
Model类：
BOSS: /LegendCarry0927/src/gamerole/Boss.java
玩家：/LegendCarry0927/src/gamerole/Hero.java
父类：ItemBase
子弹：/LegendCarry0927/src/gamerole/BulletArray.java
敌机：/LegendCarry0927/src/gamerole/EnemyArray.java
...
类和属性（成员变量）
public class ItemBase {
    public int x ; // 横坐标
    public int y ; // 纵坐标
    public int r ; // 感应半径
    public int iseffect ; //是否有效，在屏幕绘制
    public int state ; //当前状态
    
    public int allBlood ; //总血量
    public int blood ; //当前血量
    public int shield ; //护甲
    
    public Image Img;    //图片
    public String ImgFile;

View：窗口

Hero玩家类的父类ItemBase：
public void paint()
{
//绘制一张图片
}
函数上，右键点击Call Hierarchy。查看该函数在哪些地方被调用。

窗口类JFrame：
窗口添加了一个面板类MyPanel
MyPanel包含一个绘图函数public void paint(Graphics g) {... }
其中，调用hero.paint(); 画出了玩家飞机。

行为Control部分：
了解了Model数据，了解View的绘图输出，最后是业务逻辑、行为Control：
类名MyPanel，创建了一个对象 panel
MyPanel panel = new MyPanel() ;

Java多线程编程：
Thread th = new Thread(panel) ;
        th.start() ;// 触发了panel的run()函数

panel的run()函数：
public void run() {
        
        while(true) {
             //不停的刷新数据，业务逻辑

            /*重画*/ 
repaint() ;     
//触发了MyPanel的绘图函数public void paint(Graphics g) {... }         
        }
    }

小节：
一些类，完成Model。一些类完成View，完成Control。共同组成了一个软件项目。
View和Control，混合写在窗口类、面板类之中，这是不好的写法。
这三部分内容，混合写，还是分开写，类和类的牵连多不多，这就是类的内聚、耦合。
好的设计：分工良好，内聚性高，耦合性低。
《设计模式》：怎么设计类（类的个数、结构、关系），解决某种应用问题。
----
Java函数：不是直接调用，而是间接触发。比如：按键、鼠标的响应函数。线程启动的Run函数。repaint()发出一个消息，间接触发绘图函数。
大一初学者，刚学习了函数、参数、返回值，做《贪吃蛇》，情理之中。
这种项目，是大一学完《java》、大二学完《设计模式》的学习成果，代表学生两年学习的编程能力。

面向对象的技术：
Java环境有问题。C++的浏览器在线编程，学习面向对象的技术。

程序员的工作：
1.高效率的学习过程，事半功倍，成长为软件工程师。
2.解决语法错误 expected ';' after class definition
3.解决功能错误

python123, 浏览器在线C++编程：

#include "stdio.h"
//OOP,面向对象，封装，继承，多态
//封装举例:成员变量，成员函数 组成一个类
class Hero
{
    //成员变量或者成员函数的权限
public:// 默认private, 不可以从外部访问
    int x;
    int y;
public:
    void printhero()
    {
        printf("%d,%d\n", x,y);
    }
};// expected ';' after class definition
int main(){
    Hero h1,h2;
    h1.x=100;   // 对象.成员变量    对象.成员函数
    h1.y=200;
    h1.printhero();
    h2.printhero(  );
    
    return 0;
}

输出结果:

-1116678880,32766
4195728,0
这种输出，是C的变量没有初始化，输出的原始数据。

权限错误。error: 'int Hero::x' is private

C3 -P1, Java的错误举例：对象数组添加十个不同的对象，再次遍历，数值都一样。

C++ 十个对象组成的数组：十个数据，各不相同，结果正确

Hero hArray[10]={};
    int i;
    for(i=0;i<10;i++)
    {
        h1.x=100+i;
        hArray[i]=h1;   // 数组元素是十个具体的对象，各不相同
        h1.printhero();
    }
     printf("\n --- 遍历各个元素 \n");
    for(i=0;i<10;i++)
    {
        hArray[i].printhero();
    }

C++ 十个对象指针组成的数组：重现JAVA的错误

以下指针数组，就是第一节课java代码，编译后的样子。
Hero* hArray[10]={};
    int i;
    for(i=0;i<10;i++)
    {
        h1.x=100+i;     //修改的是同一个对象
        hArray[i]=&h1;   // 数组元素是十个指针，指向了同一个元素
        h1.printhero();
    }
     printf("\n --- 遍历各个元素 \n");
    for(i=0;i<10;i++)
    {
        hArray[i]->printhero();
    }

C++ 十个对象指针组成的数组：指针数组的正确写法。
给数组添加元素的时候，在循环体内，每次创建新对象。
数组元素是不同的指针，指向不同的对象。

Hero* hArray[5]={};
    int i;
    Hero* tmp;
     printf(" one pointer size %d\n",sizeof(tmp) );
    for(i=0;i<5;i++)
    {
        tmp=new Hero;
        tmp->x=100+i;     //每次分配新对象
        hArray[i]=tmp;   // 数组元素是不同的指针，指向不同的对象
        tmp->printhero();
    }
     printf("\n --- 遍历各个元素 \n");
    for(i=0;i<5;i++)
    {
        hArray[i]->printhero();
        //printf("%x\n",hArray[i] );
}
以上对象指针组成的数组，是JAVA数组列表编译之后的样子。

看起来是对象数组、添加的是对象，那是Java程序书写的样子。

堆的分配。

这需要《汇编语言》、《计算机操作系统》、《计算机组成原理》的知识。

函数局部变量，栈的分配。

视频处理工具推荐：视频剪切合并器。