20171209Java基础学习-CSDN博客

本文链接：https://blog.csdn.net/li_jie_hua/article/details/78908030

第一天 Java的代码示例

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("hello world");
    }
}

class HelloWorld 表示这个类的名字是HelloWorld
public 表示这是一个可以公开访问的类
class 表示这个一个类
HelloWorld 表示类的名字，每个单词的首字母大写
public static void main(String[] args) 这是主方法,args 表示运行参数
println 表示打印数据到控制台，并且换行
java 是面向对象的编程语言,这里的对象即为类。
.java 文件是java的源文件，但是不能直接运行，必须先被编译成为.class文件才能够执行，java所有的代码都是运行在类里面的

第二天 Java中各部分框架的含义

public class Hero {
    String name; //姓名
    float hp; //血量
    float armor; //护甲
    int moveSpeed; //移动速度
}

以上是定义了一个类。
称Hero为一个类，它代表一种事物的集合，而一个类具有几个共同特征/状态[类就像水果这个名称一样，状态就像水果的特征：有水，碳水化合物，能生吃。]，这些状态就叫做一个类的属性。
能做什么在类里面就叫做方法。如下代码：

public class Hero {
    String name; //姓名
    float hp; //血量
    float armor; //护甲
    int moveSpeed; //移动速度

    void keng(){//坑队友
        System.out.println("坑队友！");
    }

    float getArmor(){//获取护甲值
        return armor;
    }

    void addSpeed(int speed){//增加移动速度
        moveSpeed = moveSpeed + speed;//在原来的基础上增加移动速度
    }
}

函数keng()、getArmor()、addSpeed(int speed)就是方法。
1）方法的返回类型：
有的方法是有返回类型的，如：

float getArmor(){
    return armor;
}

这个方法返回类型是float。
有些方法不需要返回值，这个时候就把返回类型设置为void,表示该方法不返回任何值，如下：

void keng(){
    System.out.println("坑队友！");
}

}以及

void addSpeed(int speed)

3）方法的参数：
举例：

void addSpeed(int speed){
        moveSpeed = moveSpeed + speed;//在原来的基础上增加移动速度
}

int speed 叫做方法的参数
具体代码应用如下：

public class Hero {
    String name; //姓名
    float hp; //血量
    float armor; //护甲
    int moveSpeed; //移动速度

    void keng(){//坑队友
        System.out.println("坑队友！");

    float getArmor(){//获取护甲值
        return armor;
    }

    void addSpeed(int speed){//增加移动速度
            moveSpeed = moveSpeed + speed;//在原来的基础上增加移动速度

    public static void main(String[] args) {
        Hero garen = new Hero();
        garen.name = "盖伦";
        garen.moveSpeed = 350;
        garen.addSpeed(100);
    }

}

类就像一个模板，根据这样一个模板，可以创建一个个的具体的英雄；一个个具体的英雄，就叫一个个的对象。
【顿悟：和属性的类型进行对比[属性实际上就是全局变量]，那么是否可以说：对象的类型就是类的名称，对象实际上也是一种变量。即上述代码中的Hero garen：代表变量/对象garen的类型是Hero?】
【answer:实际上，Hero garen = new Hero();这句话并没有这么简单，它可以分解为四个部分：其一，等号左边的是在栈中开辟了一个空间给Hero类的引用变量，简称Hero类引用；其二，等号右边的new Hero是在堆中开辟了一个空间给Hero类的对象，但这个对象没有名字；其三，Hero()表示在创建完Hero类的对象后即刻调用Hero类的构造函数；其四，等号的含义是将Hero类引用变量指向该对象[即，把对象在堆内存中的地址给引用变量garen]，实现对Hero类对象的操作，故这一个语句才可以分解为两个语句：Hero garen；garen = new Hero();】
Java唯一的参数传递方式——按值传递
来自上例中的代码->

public static void main(String[] args) {
    Hero garen = new Hero();//这行代码可以等效于Hero garen; 
    garen = new Hero();
    garen.name = "盖伦";
    garen.hp = 616.28f;
    garen.armor = 27.536f;
    garen.moveSpeed = 350;

    Hero teemo = new Hero();
    teemo.name = "提莫";
    teemo.hp = 383f;
    teemo.armor = 14f;
    teemo.moveSpeed = 330;
}

上例中，new Hero() 就是java中创建一个英雄对象的意思，new 是一个创建对象的方法。
[疑问：这个对象是不是叫garen?]

好的编程习惯会让代码看上去更清爽，易读，容易维护
* 比如类的第一个字母大写：Hero；
* 属性名称一般来说，都是小写，比如name；如果有多个单词组成，后面的单词的第一个字母大写比如 moveSpeed，属性也是变量【属性的类型可以是基本类型，比如Int整数，float浮点数；也可以是类类型，比如String字符串】，所以需要满足变量的命名规则。
*至于方法的命名：方法是一个类的动作行为，所以一般都是以动词开头的，比如keng … 如果有多个单词，后面的每个单词的第一个字母使用大写，比如addSpeed、getArmor。

第三天 Java变量的基本类型

下面将涉猎的是Java的变量的八种基本类型和一种类类型【String类型】，都是Java语言预先定义好的，并且八种基本类型是关键字。
Ⅰ.这八种基本类型包括：
1)整型（四种）：byte(-2^7～2^7-1),short(-2^15～2^15-1),int(-2^31～2^31-1),long(-2^63～2^63-1),
2)浮点型（两种）：float,double.float长度为32位,double 长度为64位.

默认的小数值是double类型的.所以 float f = 54.321会出现编译错误，因为54.321的默认类型是double，其类型长度为64，超过了float的长度32。在数字后面加一个字母f，直接把该数字声明成float类型即float f2 = 54.321f, 这样就不会出错了
3）字符型（一种）：char[char类型用于存放一个字符，值用单引号’表示 (双引号表示字符串),其长度和short一样，也是16位的]
4）布尔型（一种）：boolean。布尔型用于表示真假,其长度为1。其值只可取false,true分别代表真假。boolean缺省值为false

Ⅱ.类类型
关于字符串：在Java中，字符串是一个类，所以我们见到的字符串都是对象。
1）不可变性：字符串是immutable的：immutable 是指不可改变的，比如创建了一个字符串对象
String garen =”盖伦”;

不可改变的具体含义是指：
不能增加长度
不能减少长度
不能插入字符
不能删除字符
不能修改字符

一旦创建好这个字符串，里面的内容永远不能改变

String 的表现就像是一个常量
2)字符串的创建
常见创建字符串手段：
1. 每当有一个字面值【给基本类型的变量赋值的方式叫做字面值】出现的时候，虚拟机就会创建一个字符串
2. 调用String的构造方法创建一个字符串对象
3. 通过+加号进行字符串拼接也会创建新的字符串对象
如下代码：

public class TestString {
    public static void main(String[] args) {
        String garen ="盖伦"; //字面值,虚拟机碰到字面值就会创建一个字符串对象
        String teemo = new String("提莫"); //创建了一个字符串对象
        char[] cs = new char[]{'崔','斯','特'};//创建了一个字符串对象
        String hero = new String(cs);// 通过字符数组创建一个字符串对象
        String hero3 = garen + teemo;// 通过+加号进行字符串拼接
    }
}

3）字符串的拼接
如果不使用字符串格式化，就需要进行字符串连接，如果变量比较多，拼接就会显得繁琐
使用字符串格式化，就可以简洁明了
可参考下面的代码：

public class TestString {
    public static void main(String[] args) {
        String name ="盖伦";
        int kill = 8;
        String title="超神";

        //直接使用+进行字符串连接，编码感觉会比较繁琐，并且维护性差,易读性差
        String sentence = name+ " 在进行了连续 " + kill + " 次击杀后，获得了 " + title +" 的称号";
        System.out.println(sentence);

        //格式化字符串
        //%s表示字符串，%d表示数字,%n表示换行 
        String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
        String sentence2 = String.format(sentenceFormat, name,kill,title);
        System.out.println(sentence2);
    }
}

或者最后两行代码可以更改为：

System.out.printf(sentenceFormat,name,kill,title);//使用printf格式化输出

或者：

System.out.format(sentenceFormat,name,kill,title);//使用format格式化输出

通过eclipse查看java源代码可以看到，在printf中直接调用了format，故printf和format能够达到一模一样的效果。

4）字符串长度
length方法返回当前字符串的长度 ,可以有长度为0的字符串,既空字符串.例如：

public class TestString {
    public static void main(String[] args) {
        String name ="盖伦";
        System.out.println(name.length());
        String unknowHero = "";
        System.out.println(unknowHero.length());//可以有长度为0的字符串,既空字符串
    }
}

变量命名规则：
变量命名只能使用字母数字 $_ 变量第一个字符只能使用字母$ _
变量第一个字符不能使用数字
P.S.
1）在命名的时候，尽量使用完整的单词进行命名，比如name,moveSpeed，而不是使用缩写 n,m。
2）不要用Java关键词来进行命名，但可以包含关键词，如int class5 = 5。
Java关键词列表：
访问控制：
private 私有的
protected 受保护的
public 公共的

类、方法和变量修饰符：
abstract 声明抽象
class 类
extends 扩允,继承
final 终极,不可改变的
implements 实现
interface 接口
native 本地
new 创建
static 静态
strictfp 严格,精准
synchronized 线程,同步
transient 短暂
volatile 易失

程序控制语句：
break 跳出循环
continue 继续
return 返回
do 运行
while 循环
if 如果
else 反之
for 循环
instanceof 实例
switch 开关
case 返回开关里的结果
default 默认

错误处理：
try 捕获异常
catch 处理异常
finally 有没有异常都执行
throw 抛出一个异常对象
throws 声明一个异常可能被抛出
assert 断言

包相关：
import 引入
package 包

基本类型：
boolean 布尔型
byte 字节型
char 字符型
double 双精度,
float 浮点
int 整型
long 长整型
short 短整型

null 空

true 真
false 假

enum 枚举

变量引用：
super 父类,超类
this 本类
void 无返回值

2017-12-08 第四天变量的作用域

变量处于不同的位置，有不同的名称.分别是：数据成员/字段/属性，参数，局部变量。不同名称的变量，其作用域是不一样的。
1）字段/属性/Field
当一个变量被声明在类下面,变量就叫做字段或者属性、成员变量、Field。这个变量的作用域从其声明的位置开始的整个类。
代码示例如下：

public class HelloWorld {
    int i = 1;
    int j = i; //其他的属性可以访问i
    public void method1(){
        System.out.println(i); //方法1里可以访问i
    }
    public void method2(){
        System.out.println(i); //方法2里可以访问i
    }
}

2）参数
如果一个变量，是声明在一个方法上【不是方法内的】的，就叫做参数。参数的作用域即为该方法内的所有代码
其他方法不能访问该参数。类里面也不能访问该参数。代码如下：

public class HelloWorld {
    public void method1(int i){ //参数i的作用域即方法method1
        System.out.println(i);
    }
    public void method2(){ 
        System.out.println(i); //method2 不能访问参数i
    }
    int j = i; //类里面也不能访问参数i
}

3）局部变量
声明在方法内的变量，叫做局部变量。其作用域在声明开始的位置，到其所处于的块结束位置。代码如下：

public class HelloWorld {
    public void method1() {
        int i = 5; //其作用范围是从声明的第4行，到其所处于的块结束12行位置
        System.out.println(i);

        { //子块
            System.out.println(i); //可以访问i
            int j = 6;
            System.out.println(j); //可以访问j
        }
        System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
    }
}

2017-12-09 第五天 java关键词final修饰变量和引用
当一个变量被final修饰的时候，该变量只有一次机会进行赋值，当且仅当是第一次赋值。final除了修饰变量，还可以修饰类，修饰方法，修饰引用。
1)final修饰类：
当Hero被修饰成final的时候，表示Hero不能够被继承,其子类会出现编译错误
2）final修饰引用
h引用被修饰成final，表示该引用只有1次指向对象的机会
但是，依然通过h引用修改对象的属性值hp，因为hp并没有被final修饰。
代码如下：

public class Hero extends Object {
    String name; //姓名
    float hp; //血量
    float armor; //护甲
    int moveSpeed; //移动速度

    public static void main(String[] args) {
        final Hero h;//称对象h在这里为引用h
        h =new Hero();
        h =new Hero();//所以这行会出现编译错误
        h.hp = 5；//依然可以通过/h引用/修改对象的属性值hp，因为hp并没有被final修饰
    }
}

P.S.
Java语言明确说明取消了指针，因为指针往往是在带来方便的同时也是导致代码不安全的根源，同时也会使程序的变得非常复杂难以理解

第六天表达式的定义、块的定义

1）表达式的定义：由变量、操作符以及方法/函数调用，以「;」结尾所构成的的一段代码。
e.g.1：

int i = 5; 
System.out.println(5);//以上每一句话都是一个表达式

e.g.2 「;」也是一个完整的表达式。：

public class HelloWorld {
    public static void main(String[] args) {
        ;//一个空;也是一个表达式
        ;
        ; 
        ;
    }
}

2）块的定义：从「{」开始到对应的「}」结束，即是一个块。
e.g.：

public class HelloWorld { //类对应的块
    public static void main(String[] args) { //主方法对应的块
        System.out.println("abc");
    }
}

2017-12-10 第七天 Java操作符/运算符

以下将讲解6种运算符。
1）算术操作符
单目～：+（取正）、-（取负）、++（自增）、–（自减）
双目～：+、-、*、/、%（取余）
三目～：关系运算？表达式1/值/对象：表达式2/值/对象
e.g.：

a>b?true:false

说明：当a大于b的时候，为true（也就是冒号之前的值），否则为false；这整个运算符包括一个关系运算符（可以是“>””<”“!=”等等），一个“？”，一个“：”，冒号前后需要有两个表达式或者是值或者是对象。
·算术运算符的求和
1）任意运算单元的长度超过int：如果任何运算单元的长度都不超过int,那么运算结果就按照int来计算。例如：byte a = 1; byte b= 2; a+b系统默认为int类型。
代码示例如下：

public class HelloWorld {
    public static void main(String[] args) {
        byte a = 1;
        byte b= 2;
        byte c = (byte) (a+b); //虽然a b都是byte类型，但是运算结果是int类型，需要进行强制转换
        int d = a+b;
    }
}

·%取模：%称为取余数，又叫取模。例如5除以2，余1。即，5%2的值为1。代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        int j = 2;
        System.out.println(i%j); //输出为1
    }
}

·自增自减：如j=i++表示先将i值赋给j，再将i的值加1；++i则表示先将i值加1，再赋给j。
代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        i++;
        System.out.println(i);//输出为6
    }
}

即，
i++; 先取值，再运算；
++i; 先运算，再取值。

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i++); //输出5
        System.out.println(i); //输出6
        int j = 5;
        System.out.println(++j); //输出6
        System.out.println(j); //输出6
    }
}

2）关系操作符
关系操作符，顾名思义，即比较两个变量之间的关系，包括：>、<、>=、<=、==、！=。
代码示例：

public class HelloWorld {
    public static void main(String[] args) {
        int a = 5;
        int b = 6;
        int c = 5;
        System.out.println(a>b); //返回 false
        System.out.println(a>=c); //返回 true
        System.out.println(a==b); //返回false
        System.out.println(a!=b);//返回true
    }
}

3）逻辑操作符
包括以下关键字：&[长路与]、&&[短路与]、|[长路或]、||[短路或]、![取反]、以及^[异或^]。
·长路与&、短路与&&的区别：相同点：无论长路与还是短路与，两边的运算单元都是布尔值。都为真时，才为真；任意为假，就为假。不同点：长路与的两侧，都会被运算；而短路与只要第一个是false，第二个就不进行运算了。
e.g.：运算单元1+&/&&+运算单元2。代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        //长路与 无论第一个表达式的值是true或者false,第二个的值，都会被运算
        int i = 2;
        System.out.println( i== 1 & i++ ==2 ); //无论如何i++都会被执行，所以i的值变成了3
        System.out.println(i);

        //短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了
        int j = 2;
        System.out.println( j== 1 && j++ ==2 ); //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2
        System.out.println(j); 
    }
}

·长路或|、短路或||
无论长路或还是短路或，两边的运算单元都是布尔值。都为假时，才为假；任意为真，就为真。e.g.：运算单元1+|/||+运算单元2。长路或与短路或的区别是：长路或的两边都会被运算，短路或只要有一般是true的，第二个就不进行运算了。
代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        //长路或 无论第一个表达式的值是true或者false,第二个的值，都会被运算
        int i = 2;
        System.out.println( i== 1 | i++ ==2 ); //无论如何i++都会被执行，所以i的值变成了3
        System.out.println(i);

        //短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了
        int j = 2;
        System.out.println( j== 2 || j++ ==2 ); //因为j==2返回true,所以右边的j++就没有执行了，所以j的值，还是2
        System.out.println(j); 
    }
}

·取反！：即真变为假，假变为真。代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        boolean b = true;
        System.out.println(b); //输出true
        System.out.println(!b);//输出false
    }
}

·异或^：形式为：布尔值1^布尔值2。^两边的布尔值不同，返回真；布尔值相同，返回假。代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println(a^b); //不同返回真
        System.out.println(a^!b); //相同返回假
    }
}

4）位操作符（不是常用的）
通过Integer.toBinaryString() 方法[这个方法翻译是：整数.to二进制字符串]，将一个十进制整数转换为一个二进制字符串。代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        int i = 5;
        String b = (Integer.toBinaryString(i)); // 5的二进制的表达101
        System.out.println(i+" 的二进制表达是: "+b);
    }
}

[p.s.无符号右移运算符「>>>]
5）赋值操作符：包括关键字：=、+=[即自加，后面的操作运算符均类似于此]、-=、*=、/=、%=、&=、|=、^=、<<=、>>=、>>>=。
·赋值操作的操作顺序是从右到左
*重点[曾经做错的题]：int i = 1;i+ = ++i;System.out.println(i);//∵i+=++i⇔i=i+(++i),∴i=1+2=3。❖个人想法：∵i+=++i⇔i=++i + i，∴i=4
6）三元操作符/三目运算：形式为：表达式？值1：值2。代码如下：

int i = 5;
int j = 6;
int k = i < j ? 99 : 88;

// 上式相当于
if (i < j) {
    k = 99;
}
 else {
    k = 88;
}

代码示例2：通过Scanner输入一个1-7之间的整数，使用三元操作符判断时工作日还是周末？

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        System.out.print("今天是周几？");
        Scanner s = new Scanner(System.in);
        int a = s.nextInt(); 
        System.out.println(((a <= 7 && a >= 1) ? (a <6 ? "今天是工作日" : "今天是周末"):"输入错误！"));
    }
}

P.S.
介绍Scanner类：使用Scanner类，需要在最前面加上代码：

import java.util.Scanner;

表示导入这个类，才能够正常使用。
e.g.1：使用Scanner读取整数：

import java.util.Scanner;//声明Scanner类
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);//创建一个对象s，对象名为s，对象的类型为Scanner类型。换而言之，就是创建了一个Scanner对象s，通过控制台的输入，将值赋给对象s。这个语句的作用就是获取控制台的输入！！
        int a = s.nextInt();//将输入的值赋给对象s的方法nextInt()【该方法只阅读输入的东西为整数值的情况】，然后将输入的整数值赋值给int类型a
        System.out.println("第一个整数："+a);
        int b = s.nextInt();
        System.out.println("第二个整数："+b);
    }
}

p.s.：nextInt()是什么？
nextInt(): it only reads the int value, nextInt() places the cursor in the same line after reading the input.换而言之，它只阅读输入到的整数值，如果没有就一直等待，直到遇到。这个nextInt()叫做方法。在上面的代码中它是对象s的方法。
【疑惑】：System.in是什么？
百度answer：
System.in是一个很原始、很简陋的输入流对象，通常不直接使用它来读取用户的输入。
一般会在外面封装过滤流：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
然后调用br.readLine()方法进行读取。
追问：字符和数字都能输入吗？
追答：都可以，br.readLine()每次读一行。换句话说，用户输入一行内容，然后回车，这些内容一次性读取进来。
这种情况下，不论用户输入的是什么东西，通通按照字符串来.读入，读入后根据业务进行拆分和处理。
追问：br.readline()返回的是什么数据类型？
追答：String
e.g.2：使用Scanner读取浮点数

import java.util.Scanner;
    public class HelloWorld {
        public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        float a = s.nextFloat();
        System.out.println("读取的浮点数的值是："+a);
    }
}

e.g.3：使用Scanner读取字符串

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String a = s.nextLine();
        System.out.println("读取的字符串是："+a);
    }
}

e.g.4：使用Scanner读取了整数后，接着读取字符串
需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:”\r\n”,因为nextInt仅仅读取数字信息，而不会读走回车换行”\r\n”.
所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行:”\r\n”，第二次才是读取真正的字符串.
代码如下：

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        System.out.println("读取的整数是"+ i);
        String rn = s.nextLine();//将回车换行符取走。
        String a = s.nextLine();
        System.out.println("读取的字符串是："+a);
    }
}