1JDK的安装   path变量配置  eclipse的安装
a.注释: 注释分为3种  1.文档注释/**  多行注释 /* 单行注释 //  注释作用 :1 解释说明代码 2.帮忙调试代码
b.基本数据类型 整形 ,整数  byte  short int long        浮点型 小数   float (单精度)  double(双精度)    布尔数类型  boolean 只有两个值  true false 字符型  char  例如 '1'    特别注意  long和float类型定义时后面要加L和F
c. 变量 有两种转换关系 1.显示数据转换(强制数据类型转换) 2.隐式数据类型转换(由系统帮我们完成的条件  小范围数据转成大范围数据)

继续努力！

1414225997 发表于 2018-1-7 15:44
继续努力！

fight! fight!

JavaEE8期 day2
1.运算符的概念 运算符分为 算术运算符(+,-,*,/,%,++,-- ) 赋值运算符 ( =,+=,-=,*=,/=,%=)关系运算符(==,!=,>,>=,<,<=) 逻辑运算符( & ,| ,^ , !, && ,|| ) 三元运算符:格式: (关系表达式)?表达式1：表如果条件为true，运算后的结果是表达式1如果条件为false，运算后的结果是表达式2；
2.if语句 有三种格式 1.f(关系表达式) {语句体}  2.f(关系表达式) {
                     语句体1;
        }else {
                     语句体2;
        } 3.if(关系表达式1) {
                     语句体1;
        }else  if (关系表达式2) {
                     语句体2;
        }
    …
        else {
                     语句体n+1;
        }

温故而知新   加油

总结不错，继续加油哟~~~期待继续更新

JavaEE8期  Day3
一丶循环语句
1.*for循环语句  格式  for(初始化语句;判断条件语句;控制条件语句) {
         循环体语句;  
2.1while循环语句  格式  while(判断条件语句) {
         循环体语句;  2.2  do {
         循环体语句;
   }while((判断条件语句);
   }
二丶循环语句控制   1.控制跳转语句break  break的使用场景：
在选择结构switch语句中
在循环语句中
break的作用：
跳出单层循环
2.控制跳转语句continue  在循环语句中
离开使用场景的存在是没有意义的
continue的作用：
单层循环对比break，然后总结两个的区别
break  退出当前循环
continue  退出本次循环
三丶for循环的嵌套使用
四丶Random 类的使用
 作用：
–用于产生一个随机数
•使用步骤(和Scanner类似)
–导包
•import java.util.Random;
–创建对象
•Random r = new Random();
–获取随机数
•int number = r.nextInt(10);
•产生的数据在0到10之间，包括0，不包括10。
•括号里面的10是可以变化的，如果是100，就是0-100之间的数据
2.Scanner对象的创建及使用
A:导包(位置放到class定义的上面)
        import java.util.Scanner;
B:创建对象
        Scanner sc = new Scanner(System.in);
C:接收数据
                int x = sc.nextInt();

每天进步多一点  fighting!!!

期待继续更新

JavaEE8期 Day
今天是预科班的最后的一天,虽然只有短短四天 但我感觉这是我今年过的最充实的四天  每天都在学习进步  这种感觉 我非常喜欢  ,明天过后  就要进入基础班的学习了  我会拿出最好的状态去认真学习  学好Java !
  今天学的东西是这四天我感觉东西最多也最难的 要思考好久  总结下今天的 学习内容
一 .String类   String 东西非常多
1.String类的构造方法
String(String original):把字符串数据封装成字符串对象
                String(char[] value):把字符数组的数据封装成字符串对象
                String(char[] value, int index, int count):把字符数组中的一部分数据
2.String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同
  boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
  boolean startsWith(String str):判断字符串对象是否以指定的str开头
  boolean endsWith(String str):判断字符串对象是否以指定的str结尾
3.String类的转换功能
char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串
4.String类的其它功能
去除字符串两端空格       
*                String trim()
* 按照指定符号分割字符串       
*                String[] split(String str)

今天的东西很多 需要一些时间好好消化.加油  明天可以更好!!!

期待继续更新~~~

JavaEE期 基础班Day_01
今天是基础班的第一天  斌哥变成了我们的助教  源哥现在给我们上基础班的课  废话不多说  每天都有收获  看看今天学了啥
Java概述、helloworld案例
工具安装 、配置环境变量、注释、关键字
常量、变量、数据类型、标识符
1.第1章Java概述(这些口水话都不说了  略过 将重点)
2.1.5helloworld案例  这个我们在预科班已经学习过了  也写过很多次.不过今天是用notepead写的
3.环境配置   这个是每个学JavaEE都应该会的吧  
4.注释  Java中注释分类
单行注释
–格式： //注释文字
多行注释
–格式： /*  注释文字  */
文档注释
–格式：/** 注释文字 */
5.2.4.1关键字概述
–被Java语言赋予特定含义的单词
2.4.2关键字特点
–组成关键字的字母全部小写
–常用的代码编辑器,针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。
6.常量
3.1.2常量分类
–字符串常量        用双引号括起来的内容(“HelloWorld”)
–整数常量        所有整数(12,-23)
–小数常量        所有小数(12.34)
–字符常量        用单引号括起来的内容(‘a’,’A’,’0’)
–布尔常量        较为特有，只有true和false
–空常量                null(数组部分讲解)
7.3.3数据类型
分两类 基本 和引用两类  今天说的基本  引用 还不急
  基本数据类型 分为4类8种
整形 ,整数  byte  short int long        浮点型 小数   float (单精度)  double(双精度)    布尔数类型  boolean 只有两个值  true false 字符型  char  例如 '1'    特别注意  long和float类型定义时后面要加L和F\
8.标识符
3.4.1标识符概述
A 作用
–给包,类,方法,变量等起名字
B 组成规则
–由字符，下划线_，美元符$组成
•这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。
–注意事项
–不能以数字开头
–不能是Java中的关键字

C : 命名原则:见名知意
a包
         最好是域名倒过来,要求所有的字母小写 
b类或者接口
         如果是一个单词首字母大写
         如果是多个单词每个单词首字母大写(驼峰标识) 
c方法或者变量
         如果是一个单词全部小写
         如果是多个单词,从第二个单词首字母大写 
d常量
         如果是一个单词,所有字母大写
         如果是多个单词,所有的单词大写,用下划线区分每个单词 
9.数据类型转换
9.1 隐式数据类型转换
9.2强制类型数据转换(不推荐使用)
  大概就这些  明天继续  加油  
  斌哥有句话我喜欢  我什么都不会 就是要8K
但是我不止想要8K  所以加油喽

期待更新............

JavaEE期 基础班Day_02
今天是基础班第二天 来看看今天学了些什么.
一.eclipse
1.eclipse的安装  这个简单  和教程走就行了  
2.eclipse的基本使用  
二.运算符
1.运算符的分类(5类)
算术运算符(+,-,*,/,%,++,-- ) 赋值运算符 (+=,-=,*=,/=,%=)关系运算符(==,!=,>,>=,<,<=) 逻辑运算符 (&,|,^,!
        &&,|| )三元运算符(格式
        (关系表达式)?表达式1：表达式2；
        如果条件为true，运算后的结果是表达式1；
        如果条件为false，运算后的结果是表达式2；)
这里说下重点.1.& | 和&&  || 的区别  
  后者具有断路的功能  我们通常都是使用后者  其功能是一样的.
2.+=:        a+=20;相当于a = (a的数据类型)(a + 20);
3.++/--  如果++或者--在变量的后面，先拿变量参与操作，后变量做++或者--
                如果++或者--在变量的前面，先变量做++或者--，后拿变量参与操作
三.键盘录入
键盘录入数据的步骤:
A:导包(位置放到class定义的上面)
        import java.util.Scanner;
B:创建对象
        Scanner sc = new Scanner(System.in);
C:接收数据
        int x = sc.nextInt();
差不多就是这些  全是干货  
加油加油!!!

JavaEE期 基础班Day_03
今天是基础班第三天  是自习  基本都是在教室复习学过的东西  然后我在复习至于  学习到了一种新的for循环
今天主要就是说这种循环
//   for (声明语句 : 表达式) {
                //       代码句子
                //   }
        // 主要用于数组的增强型for循环.
        // 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
        //        表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
然后举个例子
public class Day03 {
        public static void main(String[] args) {
             int[] numbers = { 10, 20, 30, 40, 50 };

                for (int x : numbers) {
                        System.out.print(x);
                        System.out.print(",");
                }

                System.out.print("\n");
                String[] names = { "James", "Larry", "Tom", "Lacy" };

                for (String name : names) {
                        System.out.print(name);
                        System.out.print(",");
                }

        }

}
  还学了点面向对象  但是
感觉没听老师讲 还是有点不懂  所以就不说了  自习的一天基本都是这样 复习  学习  不懂的就问斌哥.

期待每天都看到你的进步~~~

期待你的更新······

JavaEE期 基础班Day_05
昨天没账号 断更了 好在内容都是学过的  然后说下今天的新知识;
1.第1章Random
产生随机数的
放个最有代表性的案例
public class RandomTest {
        public static void main(String[] args) {
                // 系统产生一个随机数1-100之间的。
                Random r = new Random();
                int number = r.nextInt(100) + 1;

                while(true){
                        // 键盘录入我们要猜的数据
                        Scanner sc = new Scanner(System.in);
                        System.out.println("请输入你要猜的数字(1-100)：");
                        int guessNumber = sc.nextInt();
       
                        // 比较这两个数据(用if语句)
                        if (guessNumber > number) {
                                System.out.println("你猜的数据" + guessNumber + "大了");
                        } else if (guessNumber < number) {
                                System.out.println("你猜的数据" + guessNumber + "小了");
                        } else {
                                System.out.println("恭喜你,猜中了");
                                break;
                        }
                }
        }
}
2.数组  (一维 二维)
二维更多是了解
一维是重点'
2.2.1数组概念
数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
2.2.2数组的定义格式
格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。                          
2.3数组的初始化
2.3.1数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
2.3.2数组的初始化方式
2.3.2.1动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
案例
public class ArrayTest2 {
        public static void main(String[] args) {
                //定义数组
                int[] arr = {12,98,45,73,60};
               
                //定义参照物
                int max = arr[0];
               
                //遍历数组，获取除了0以外的所有元素，进行比较
                for(int x=1; x<arr.length; x++) {
                        if(arr[x] > max) {
                                max = arr[x];
                        }
                }
                System.out.println("数组中的最大值是："+max);
        }
}
数组这个今天要好好回家复习下  做题有点懵比;

今天学的东西用了不少时间才搞清楚 怎么回事
今天的内容  :  面向对象  然后重点是 它的三大特性之一  封装
A:什么是面向过程
面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
例如:吃煎饼果子利用面向过程的思想:
                1.学习摊煎饼的技术
     2.买材料鸡蛋,油,葱等等
     3.开始摊
     4.吃
     5.收拾
B:什么是面向对象
面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
例如:吃煎饼果子利用面向对象的思想
1.找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
2.调用其摊煎饼的技能(功能),传递进去钱参数
3.返回给我们一个煎饼
4.吃
1.1.2面向过程特点与面向对象特点
A:面向过程：
强调的是过程，所有事情都需要自己完成
B:面向对象:
是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
          可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
将我们从执行者变成了指挥者角色发生了转换
类和对象  
这个说的很绕  用个例子   类 就是学生  而 对象就是  学生里面某一个具体的
来个案例
public class Student {
        //成员变量
        //姓名
        String name;
        //年龄
        int age;
       
        //成员方法
        //学习的方法
        public void study() {
                System.out.println("好好学习，天天向上");
        }
       
        //吃饭的方法
        public void eat() {
                System.out.println("学习饿了要吃饭");
        }
}
手机类案例
package com.itheima_02;
/*
* 手机类：
*                 成员变量：品牌，价格，颜色...
*                 成员方法：打电话，发短信...
*/
public class Phone {
        //品牌
        String brand;
        //价格
        int price;
        //颜色
        String color;
       
        //打电话
        public void call(String name) {
                System.out.println("给"+name+"打电话");
        }
       
        //发短信
        public void sendMessage() {
                System.out.println("群发短信");
        }
}
手机类的测试类package com.itheima_02;
/*
* 手机类的测试类
*/
public class PhoneDemo {
        public static void main(String[] args) {
                //创建对象
                Phone p = new Phone();
               
                //输出成员变量值
                System.out.println("品牌："+p.brand);//null
                System.out.println("价格："+p.price);//0
                System.out.println("颜色："+p.color);//null
                System.out.println("------------");
               
                //给成员变量赋值
                p.brand = "锤子";
                p.price = 2999;
                p.color = "棕色";
               
                //再次输出成员变量值
                System.out.println("品牌："+p.brand);//锤子
                System.out.println("价格："+p.price);//2999
                System.out.println("颜色："+p.color);//棕色
                System.out.println("------------");
               
                //调用成员方法
                p.call("林青霞");
                p.sendMessage();
        }
}
package com.itheima_03;
/*
* 手机类的测试类
*/
public class PhoneDemo2 {
        public static void main(String[] args) {
                Phone p = new Phone();
                p.brand = "小米5s";
                p.price = 1999;
                p.color = "银色";
                System.out.println(p.brand+"---"+p.price+"---"+p.color);
                p.call("林青霞");
                p.sendMessage();
               
                Phone p2 = new Phone();
                p2.brand = "IPhone7S";
                p2.price = 7999;
                p2.color = "土豪金";
                System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
                p2.call("张曼玉");
                p2.sendMessage();
        }
}package com.itheima_03;
/*
* 手机类的测试类
*/
public class PhoneDemo3 {
        public static void main(String[] args) {
                Phone p = new Phone();
                p.brand = "OPPO";
                p.price = 2999;
                p.color = "白色";
                System.out.println(p.brand+"---"+p.price+"---"+p.color);
               
                Phone p2 = p;
                p2.brand = "魅族";
                p2.price = 1999;
                p2.color = "蓝色";
                System.out.println(p.brand+"---"+p.price+"---"+p.color);
                System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
        }
}
第面向对象特性之封装
2.1.1private关键字
A:private关键字：
a:是一个权限修饰符。
b:可以修饰成员(成员变量和成员方法)
c:被private修饰的成员只在本类中才能访问。
2.1.2private最常见应用
A:把成员变量用private修饰
B:提供对应的getXxx()/setXxx()方法
2.1.3封装的概述和好处:
A:封装概述
是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
B:封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法
C:好处：
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性
2.2his关键字
2.2.1this关键字由来和使用:
A:this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
B:什么时候使用this呢
局部变量和成员变量重名
第3章面向对象之构造方法
主要用来给对象的数据进行初始化
3.1.1构造方法格式:
A:构造方法格式
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
3.1.2构造方法注意事项与重载
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的,重载条件和普通方法相同
3.1.3包含private,无参,有参构造的标准学生类代码:
A:类:
a:成员变量
b:构造方法
无参构造方法
带参构造方法
c:成员方法
getXxx()
setXxx()
B:给成员变量赋值的方式
a:无参构造方法+setXxx()
b:带参构造方法
今天学的东西  有点混  我要好好消化下才能OK

今天学的内容有点多有点  慢慢梳理下
1.API
1.1API概念
API(Application Programming Interface) : 应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类
1.2快速使用API步骤:
A:打开帮助文档
B:点击显示，找到索引，看到输入框
C:你要学习什么内容，你就在框框里面输入什么内容
          举例：Random
D:看包
java.lang包下的类在使用的时候是不需要导包的
E:看类的描述
        Random类是用于生成随机数的类
F:看构造方法
        Random():无参构造方法
                Random r = new Random();
G:看成员方法
           public int nextInt(int n):产生的是一个[0,n)范围内的随机数
                调用方法：
                        看返回值类型：人家返回什么类型，你就用什么类型接收
                        看方法名：名字不要写错了
                        看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
                        int number = r.nextInt(100);
2.Scanner 类和String类
Scanner类作用
用Scanner类的方法可以完成接收键盘录入的数据
案例
public class ScannerDemo {
        public static void main(String[] args) {
                //创建键盘录入对象
                Scanner sc = new Scanner(System.in);
                //接收数据
                System.out.println("请输入一个字符串数据：");
                String s = sc.nextLine();
               
                //输出结果
                System.out.println("s:"+s);
        }
}
然后说下String类 这个是重点.
2.2.2String类的构造方法
                String(String original):把字符串数据封装成字符串对象
                String(char[] value):把字符数组的数据封装成字符串对象
                String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
2.2.3String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同
  boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
  boolean startsWith(String str):判断字符串对象是否以指定的str开头
  boolean endsWith(String str):判断字符串对象是否以指定的str结尾
String类的获取功能 这个来个案例
public class StringTest {
        public static void main(String[] args) {
                //创建一个字符串对象
                String s = "abcde";
               
                //原始做法
                System.out.println(s.charAt(0));
                System.out.println(s.charAt(1));
                System.out.println(s.charAt(2));
                System.out.println(s.charAt(3));
                System.out.println(s.charAt(4));
                System.out.println("---------");
               
                //用for循环改进
                for(int x=0; x<5; x++) {
                        System.out.println(s.charAt(x));
                }
                System.out.println("---------");
               
                //用length()方法获取字符串的长度
                for(int x=0; x<s.length(); x++) {
                        System.out.println(s.charAt(x));
                }
        }
}

2.2.5String类的转换功能
2.2.5.1转换方法演示
char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串
2.2.6String类的其它功能
package com.itheima_06;
/*
* 去除字符串两端空格       
*                String trim()
* 按照指定符号分割字符串       
*                String[] split(String str)
*/
public class StringDemo {
        public static void main(String[] args) {
                //创建字符串对象
                String s1 = "helloworld";
                String s2 = "  helloworld  ";
                String s3 = "  hello  world  ";
                System.out.println("---"+s1+"---");
                System.out.println("---"+s1.trim()+"---");
                System.out.println("---"+s2+"---");
                System.out.println("---"+s2.trim()+"---");
                System.out.println("---"+s3+"---");
                System.out.println("---"+s3.trim()+"---");
                System.out.println("-------------------");
                                                               
                //String[] split(String str)
                //创建字符串对象
                String s4 = "aa,bb,cc";
                String[] strArray = s4.split(",");
                for(int x=0; x<strArray.length; x++) {
                        System.out.println(strArray[x]);
                }
        }
}
3.StringBuilder类
3.1StringBuilder类概述
StringBuilder:是一个可变的字符串。字符串缓冲区类。  
String和StringBuilder的区别：
        String的内容是固定的
        StringBuilder的内容是可变的
3.2StringBuilder类的常用方法
  A:构造方法:
     StringBuilder()
  B:成员方法:
     public int capacity():返回当前容量 (理论值)
     public int length():返回长度(已经存储的字符个数)
public StringBuilder append(任意类型):添加数据，并返回自身对象
public StringBuilder reverse():反转功能

学无止境   路还很长  加油哦