A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© chen66 中级黑马   /  2017-12-27 18:16  /  1180 人查看  /  2 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

变量的定义格式:
                数据类型 变量名 = 初始化值;
               
        基本数据类型:
                byte,short,int,long,float,double,char,boolean
               
        注意:
                整数默认是int类型,定义long类型的数据时,要在数据后面加L。
                浮点数默认是double类型,定义float类型的数据时,要在数据后面加F。

变量定义注意事项:
                1:变量未赋值,不能直接使用
                2:变量只在它所属的范围内有效
                        变量属于定义他的那行代码所在的那对大括号
               
                3:一行上可以定义多个变量,但是不建议
                4.变量必须在使用前先定义。
标识符:就是给包,类,方法,变量起名字的符号。
       
        组成规则:
                A:unicode字符
                        数字字符,英文大小写,汉字(不建议使用汉字)
                B:下划线_
                C:美元符$
               
        注意事项
                A:不能以数字开头
                B:不能是java中的关键字
               
        常见命名规则:
                A:基本要求
                        见名知意
                B:常见的命名
                        a:包(其实就是文件夹,用于对类进行管理)
                                全部小写,多级包用.隔开
                                举例:com,com.itheima
                        b:类
                                一个单词首字母大写
                                        举例:Student,Car
                                多个单词每个单词的首字母大写
                                        举例:HelloWorld
                        c:方法和变量
                                一个单词首字母小写
                                        举例:age,show()
                                多个单词从第二个单词开始每个单词的首字母大写
                                        举例:maxAge,getAge()

常量:在程序执行的过程中,其值不可以发生改变的量
       
        常量分类:
                A:字符串常量        "HelloWorld"
                B:整数常量                12,-23
                C:小数常量                12.34
                D:字符常量                'a','0'
                E:布尔常量                true,false
                F:空常量                null(后面讲解)
关键字:被Java语言赋予特定含义的单词
       
        特点:
                A:组成关键字的字母全部小写
                B:常见的代码编辑器,针对关键字有特殊的颜色标记
我们在做运算的时候,一般要求参与运算的数据类型必须一致。
       
        类型转换:
                隐式转换
                强制转换
               
        隐式转换       
                byte,short,char -- int -- long -- float – double
强制转换:
                目标类型 变量名 = (目标类型) (被转换的数据);
                不建议强制转换,因为会有精度的损失。
数据类型:Java是一种强类型语言,针对每一种数据都给出了明确的数据类型
       
        数据类型分类:
                A:基本数据类型
                B:引用数据类型(类,接口,数组)
               
        基本数据类型:4类8种
                A:整数                占用字节数
                        byte        1
                        short        2
                        int                4
                        long        8       
                B:浮点数
                        float        4
                        double        8
                C:字符
                        char        2
                D:布尔
                        boolean        1
                       
        注意:
                A:整数默认是int类型,浮点数默认是double
                B:定义long类型数据的时候,要加L或者l,建议加L
                  定义float类型数据的时候,要加F或者f,建议加F
                C:字符
                        Java中的字符采用的是unicode编码,每一个字符占用两个字节,就可以存储一个汉字
                D:boolean类型适用于逻辑运算,一般用于流程控制
注释:用于解释说明程序的文字
       
        分类:
                单行
                多行
               
        作用:解释说明程序,提高程序的阅读性
运算符:对常量和变量进行操作的符号
  表达式:用运算符连接起来的符合java语法的式子。不同类型的运算符连接起来的式子是不同的表达式。
                举例:定义两个int类型的变量a,b,
                        a + b
  
  运算符分类:
                算术运算符,赋值运算符,关系运算符,逻辑运算符,三元运算符。
  
算术运算符:

                +,-,*,/的基本使用
%:取余运算符。得到的是两个相除数据的余数。
/:除法运算符。得到是两个相除数据的商。

%:判断两个数据是否整除。
整数的加法。
  字符参与加法操作。拿字符在计算机中底层存储对应的数据值来参与运算的。
                  '0'                48
                'a'                97
                'A'                65
字符串参与加法操作。
                这里的+其实不是加法,而是字符串连接符。
++,--运算符:对变量做加1或者减1的操作。
  ++或者--既可以放在变量的后面,也可以放在变量的前面。
单独使用的时候,++或者--无论是放在变量的前面还是后面,结果是一样的。
  参与操作的时候:
                如果++或者--在变量的后面,先拿变量参与操作,后变量做++或者--
                如果++或者--在变量的前面,先变量做++或者--,后拿变量参与操作
赋值运算符:
                  A:基本        =
                B:扩展        +=,-=,*=,...

  +=:
                a+=20;
                  相当于
                  a = (a的数据类型)(a + 20);
关系运算符:
                ==,!=,>,>=,<,<=
                关系运算符的结果是boolean类型。
  
  注意:
                  千万不要把==写成=
逻辑运算符:用于连接关系表达式。
&,|,^,!
&&,||

  与:&        有false则false  
  或:|        有true则true
  异或:^ 相同则false,不同则true。(男女朋友)
  非:!        true则false,false则true
&&和&的结果一样
  ||和|的结果一样
  
  &&和&的区别:
                  &&如果左边是false,右边不执行。
                  &无论左边是true还是false,右边都会执行。

三元运算符:
  
格式:
                (关系表达式)?表达式1:表达式2;
执行流程:
                A:计算关系表达式的值,看是true还是false
                B:如果是true,表达式1就是运算结果
                      如果是false,表达式2就是运算结果
为了提高程序的灵活性,我们就把数据改进为键盘录入。
如何实现键盘录入呢?目前我们只能使用JDK提供的类Scanner。
这个使用的步骤,目前大家记住就可以了。

使用步骤:
                  A:导包
                        import java.util.Scanner;
                        类中的顺序:package > import > class
                B:创建对象
                        Scanner sc = new Scanner(System.in);
                C:接收数据
                        int i = sc.nextInt();
顺序结构:从上往下,依次执行
if语句有三种格式。

if语句格式1:
                if(关系表达式) {
                          语句体;
                }

  执行流程:
                A:首先判断关系表达式看其结果是true还是false
                B:如果是true,就执行语句体
                C:如果是false,就不执行语句体
if语句格式2:
                  if(关系表达式) {
                        语句体1;
                  }else {
                        语句体2;
        }

执行流程:
                A:判断关系表达式的值是true还是false
                B:如果是true,就执行语句体1
                C:如果是false,就执行语句体2
if语句格式3:
                if(关系表达式1) {
                        语句体1;
                }else if(关系表达式2) {
                        语句体2;
                }else if(关系表达式3) {
                        语句体3;
                }
                ...
                else {
                        语句体n+1;
                }
执行流程:
                A:首先判断关系表达式1看其结果是true还是false
                B:如果是true,就执行语句体1
                     如果是false,就继续进行关系表达式2的判断看其结果是true还是false
                C:如果是true,就执行语句体2
                   如果是false,就继续进行关系表达式...的判断看其结果是true还是false
                ...
                D:如果没有一个为true的,就执行语句体n+1

if语句的三种格式:
                  第一种格式适合做一种情况的判断
                  第二种格式适合做二种情况的判断
                第三种格式适合做多种情况的判断
switch语句格式:
switch(表达式) {
                case 值1:
                          语句体1;
                          break;
                case 值2:
                        语句体2;
                          break;
                ...
                default:
                          语句体n+1;
                          break;
}
格式解释:
                表达式:byte,short,int,char
                        JDK5以后可以是枚举
                        JDK7以后可以是字符串
                case:就是要和表达式进行比较的值
                break:表示中断,结束的意思。
                default:表示所有的情况都不匹配的时候,就执行语句体n+1。和if语句的else相似。
执行流程:
                A:计算出表达式的值
                B:拿计算出来的值和case后面的值依次比较,一旦有对应的值,就执行该处的语句,在执行过程中,遇到 break,就结束。
                C:如果所有的case都不匹配,就会执行default控制的语句,然后结束。
for循环语句格式:
                for(初始化语句;判断条件语句;控制条件语句) {
                        循环体语句;
                }

                执行流程:
                        A:执行初始化语句
                          B:执行判断条件语句,看结果是true还是false
                                如果是true,就继续执行
                                  如果是false,就结束循环
                        C:执行循环体语句
                        D:执行控制条件语句
                          E:回到B继续
while循环语句的基本格式:
                  while(判断条件语句) {
                        循环体语句;
                }
扩展格式:
                  初始化语句;
                  while(判断条件语句) {
                          循环体语句;
                        控制条件语句;
                  }
do...while循环的基本格式:
                  do {
                        循环体语句;
                }while(判断条件语句);
扩展格式:
                初始化语句;
                do {
                        循环体语句;
                          控制条件语句;
                }while(判断条件语句);
  执行流程:
                A:执行初始化语句;
                B:执行循环体语句;
                C:执行控制条件语句;
                D:执行判断条件语句,看是true还是false
                        如果是true,回到B继续
                        如果是false,就结束
三种循环的区别:
                  A:do...while至少执行一次循环体
                  B:for,while循环先判断条件是否成立,然后决定是否执行循环体

for和while的小区别:
                for循环的初始化变量,在循环结束后,不可以被访问。而while循环的初始化变量,是可以被继续使用的。
                如果初始化变量,后面还要继续访问,就使用while,否则,推荐使用for。
break:中断的意思
使用场景:
                A:switch语句中
                  B:循环中
注意:
                离开使用场景是没有意义的。
作用:
                  跳出循环,让循环提前结束

continue:继续的意思
使用场景:
                  循环中
注意:
                离开使用场景是没有意义的
作用:
                  结束一次循环,继续下一次的循环
  区别:
                  break:退出循环
                continue:结束一次循环,继续下一次的循环

2 个回复

倒序浏览
数组:存储同一种数据类型的多个元素的容器。
定义格式:
                  A:数据类型[] 数组名;        (推荐的方式)
                B:数据类型 数组名[];

                举例:
                        int[] arr; 定义了一个int类型的数组,数组名是arr
                        int arr[]; 定义了一个int类型的变量,变量名是arr数组
数组初始化:
                A:所谓的初始化,就是为数组开辟内存空间,并为数组中的每个元素赋予初始值
                  B:我们有两种方式可以实现数组的初始化
                        a:动态初始化        只给出长度,由系统给出初始化值
                        b:静态初始化        给出初始化值,由系统决定长度

  动态初始化:
                数据类型[] 数组名 = new 数据类型[数组长度];
静态初始化:
                数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
                举例:
                          int[] arr = new int[]{1,2,3};

                简化格式:
                        数据类型[] 数组名 = {元素1,元素2,元素3,...};
                          int[] arr = {1,2,3};
两个常见小问题:
                ArrayIndexOutOfBoundsException:数组索引越界异常
                        产生的原因:我们访问了不存在的索引
                NullPointerException:空指针异常
                        产生的原因:数组已经不在指向堆内存的数据了,你还使用数组名去访问元素
二维数组:其实就是元素为一维数组的数组。

定义格式:
                A:数据类型[][] 数组名; (推荐的方式)
                B:数据类型 数组名[][];
                C:数据类型[] 数组名[];
  初始化:
                  A:动态初始化
                        数据类型[][] 数组名 = new 数据类型[m][n];
                          m表示的是二维数组中一维数组的个数
                          n表示的是一维数组中的元素个数
                  B:静态初始化
                          数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
                          简化格式:
                          数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};

  二维数组名配合索引可以获取到每一个一维数组。
  每一个一维数组配合索引名可以获取到数组中的元素。
假如我有一个二维数组:arr。
  我要从中获取一维数组:arr[索引]
  我要从中获取二维数组的元素:arr[索引][索引]
Random:用于产生随机数

  使用步骤:
                A:导包
                          import java.util.Random;
                B:创建对象
                        Random r = new Random();
                C:获取随机数
                        int number = r.nextInt(10);
                        获取数据的范围:[0,10) 包括0,不包括10
方法:其实就是完成特定功能的代码块
定义格式:
                修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
                        方法体;
                        return 返回值;
                }
  格式解释:
                A:修饰符        目前记住public static
                  B:返回值类型        用于限定返回值的数据类型
                C:方法名        为了方便我们调用方法的名字
                D:参数类型        用于限定调用方法时传入的数据的类型
                E:参数名        用于接收调用方法时传入的数据的变量
                F:方法体        完成功能的代码
                G:return 结束方法,并且把返回值带给调用者

写一个方法有两个明确:
                A:返回值类型        明确功能结果的数据类型
                  B:参数列表                明确有几个参数,以及参数的数据类型
方法的调用:(有明确返回值的方法调用)
                  A:单独调用,没有意义
                B:输出调用,有意义,但是不够好,因为我可能需要拿结果进行进一步的操作
                C:赋值调用,推荐方式
需求:写一个方法,在控制台输出10次HelloWorld案例

两个明确:
                返回值类型:void
                  参数列表:没有参数
  
  如果一个方法没有明确的返回值类型,也不能把返回值类型的地方空出来,应该写void表示该方法无返回值类型。
  
  方法调用:(void修饰的方法的调用)
                  只能单独调用


  方法重载:在同一个类中,出现了方法名相同的情况。
  方法重载的特点:
                  方法名相同,参数列表不同。与返回值无关。
                  参数列表不同:
                          参数的个数不同
                          参数对应的数据类型不同

方法的参数如果是基本数据类型:形式参数的改变不影响实际参数。
  
  形式参数:用于接收实际参数的变量
  实际参数:实际参与运算的变量
如果参数是引用数据类型:
                  形式参数的改变直接影响实际参数
断点调试:
                A:查看程序的执行流程
                  B:调试程序
  
  断点:
                  其实就是一个标记
在哪里加呢?
                想加哪里就加哪里,一般是加在我们看不懂的地方

  如何加呢?
                  在代码区域的最左边双击即可
  
  如何运行加断点的程序呢?
                  代码区域 -- 右键 -- Debug as -- Java Application
                  会弹出一个页面让我们选择是否进入debug模式,选择yes。
  
  如何让程序往下执行呢?
                  Step Over 执行下一步
                  F6
  
  看那些区域呢?
                  代码区域:看程序的执行步骤
                  Debug区域:看程序的执行步骤
                  Variables:看变量的创建,赋值,销毁等
                  Console:看程序的输入和输出
  
  如何去除断点:
                A:把加断点的动作再来一遍
                  B:在debug视图中,找到Breakpoints,选中断点,点击双x即可
面向对象思想:
                  面向对象是基于面向过程的编程思想。
  
                  面向过程:强调的是每一个功能的步骤
                  面向对象:强调的是对象,然后由对象去调用功能
  
  面向对象的思想特点:
                  A:是一种更符合我们思考习惯的思想
                  B:可以将复杂的事情简单化
                  C:将我们从执行者变成了指挥者
  
举例:
                  买电脑:
                        面向过程:我要买电脑--我要明确买电脑的意义--上网查对应的参数信息--去中关村买电脑--讨价还价--买回电脑
                        面向对象:我要买电脑--班长去给我买电脑--买回电脑
                洗衣服:
                        面向过程:把衣服脱下来--找一个盆--放点洗衣粉--加点水--浸泡10分钟--揉一揉--清洗衣服--拧干--晾起来
                        面向对象:把衣服脱下来--打开全自动洗衣机--扔衣服--按钮--晾起来
成员变量和局部变量的区别:
                A:在类中的位置不同
                        成员变量:类中,方法外
                        局部变量:方法中或者方法声明上(形式参数)
                B:在内存中的位置不同
                        成员变量:堆内存
                        局部变量:栈内存
                C:生命周期不同
                        成员变量:随着对象的创建而存在,随着对象的消失而消失
                        局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
                D:初始化值的问题
                        成员变量:有默认值
                        局部变量:没有默认值。必须先定义,赋值,最后使用
API的使用:
1:打开帮助文档
2:点击显示,找到索引,看到输入框
3:你要学习什么内容,你就在框框里面输入什么内容
        举例:Random
4:看包
        java.lang包下的类在使用的时候是不需要导包的
5:看类的描述
        Random类是用于生成随机数的类
6:看构造方法
        Random():无参构造方法
                Random r = new Random();
7:看成员方法
        public int nextInt(int n):产生的是一个[0,n)范围内的随机数
                调用方法:
                        看返回值类型:人家返回什么类型,你就用什么类型接收
                        看方法名:名字不要写错了
                        看形式参数:人家要几个参数,你就给几个,人家要什么数据类型的,你就给什么数据类型的
                       
                        int number = r.nextInt(100);
集合类的特点:
                长度可变。
ArrayList<E>:
                大小可变数组的实现
                <E>:是一种特殊的数据类型,泛型。
                怎么用呢?
                        在出现E的地方我们使用引用数据类型替换即可
                        举例:ArrayList<String>,ArrayList<Student>

构造方法:
                  ArrayList()
添加元素:
                public boolean add(E e):添加元素
        public void add(int index,E element):在指定的索引处添加一个元素
获取元素
                public E get(int index):返回指定索引处的元素
集合长度
                public int size():返回集合中的元素的个数
删除元素
                public boolean remove(Object o):删除指定的元素,返回删除是否成功
                public E remove(int index):删除指定索引处的元素,返回被删除的元素
修改元素
                public E set(int index,E element):修改指定索引处的元素,返回被修改的元素
ArrayList集合的遍历
                通过size()和get()配合实现的
回复 使用道具 举报
尽量用自己的话去总结一些重点,这样更有助于了你的理解和后续的学习。然后私下养成这种习惯,对于未来都是很有帮助的呢!加油哦!但愿就业班顺利!找工作顺利!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马