JAVAday1-8笔记

最新推荐文章于 2020-03-04 15:51:23 发布

uchiha711

最新推荐文章于 2020-03-04 15:51:23 发布

阅读量228

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/uchiha711/article/details/79702866

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

DOS控制台

打开
win+r – cmd
常见命令
- A:d: 回车盘符切换
- B:dir(directory):列出当前目录下的文件以及文件夹
- C:cd (change directory)改变指定目录(进入指定目录)
- D:cd.. : 退回到上一级目录
- E:cd: 退回到根目录
- F:cls : (clear screen)清屏
- G:exit : 退出dos命令行

JAVA基础

JRE:JVM(Java Virtual Machine)+库类
JDK:JAVA开发工具
HelloWorld:
- A:定义类
- B:写main方法
- C:写输出语句
- D:Java程序开发运行与工作原理
- E:编译和运行程序

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

JAVA书写格式
- A:包
  最好是域名倒过来,要求所有的字母小写
- B:类或者接口
  如果是一个单词首字母大写
  如果是多个单词每个单词首字母大写(驼峰标识)
- C:方法或者变量
  如果是一个单词全部小写
  如果是多个单词,从第二个单词首字母大写
- D:常量
  如果是一个单词,所有字母大写
  如果是多个单词,所有的单词大写,用下划线区分每个单词
常量
- 字符串常量用双引号括起来的内容
- 整数常量所有整数
- 小数常量所有小数
- 字符常量用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
- 布尔常量较为特殊，只有true和false
- 空常量 null(数组部分讲解)
进制
- 二进制
  - 0b开头
- 八进制
  - 0开头
- 十六进制
  - 0x开头
- 进制快速转换
  - 8421码:在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
原码反码补码
- 原码
  - 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
  - 通过一个字节,也就是8个二进制位表示+7和-7
  - 0(符号位) 0000111
  - 1(符号位) 0000111
- 反码
  - 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
- 补码
  - 正数的补码与其原码相同；负数的补码是在其反码的末位加1。
变量
- 定义格式 : 数据类型变量名 = 变量值;
数据类型
- 基本数据类型
  - 整数型
    - byte 占一个字节 -128到127
    - short 占两个字 -2^15~2^15-1
    - int 占四个字节 -2^31~2^31-1
    - long 占八个字节 -2^63~2^63-1
  - 浮点型
    - float 占四个字节 -3.403E38~3.403E38 单精度
    - double 占八个字节-1.798E308~1.798E308 双精度
  - 字符型
    - char 占两个字节 0~65535
  - 布尔型
    - boolean
      boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小
- 引用数据类型
  - 面向对象部分讲解
隐转和强转
- Java中的默认转换规则
  取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
- 强转格式 : b = (byte)(a + b);
字符串运算
- ASCII码表
- +在有字符串参与中被称为字符串连接符

System.out.println("hello"+'a'+1);

运算符
- 算术运算符
  +,-,*,/,%,++,--
  - a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
  - b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
  - c:/获取的是除法操作的商，%获取的是除法操作的余数
  - %运算符
    - 当左边的绝对值小于右边绝对值时,结果是左边
    - 当左边的绝对值等于右边或是右边的倍数时,结果是0
    - 当左边的绝对值大于右边绝对值时,结果是余数
    - %运算符结果的符号只和左边有关系,与右边无关
    - 任何一个正整数%2结果不是0就是1可以用来当作切换条件
  - ++ --运算符的作用
    - 自加（++）自减（--）运算
    - ++:自加。对原有的数据进行+1
    - --:自减。对原有的数据进行-1
  - 例题
    byte b = 10; b++; b = b + 1;
    哪一句会报错?
```
b = b+1;
Error:不兼容的类型: 从int转换到byte可能会有损失
```
- 赋值运算符
  - =,+=,-=,*=,/=,%=
  - short s=1;s = s+1; short s=1;s+=1;
    是否有什么问题?
```
short s=1;s = s+1;
Error: 不兼容的类型: 从int转换到short可能会有损失
```
- 比较(关系或条件)运算符
  - ==,!=,>,>=,<,<=
  - 结果是boolean类型
- 逻辑运算符
  - &,|,^,! &&,||
  - 用于连接boolean类型的表达式或值
  - &逻辑与:有false则false。
  - |逻辑或:有true则true。
  - ^逻辑异或:相同为false，不同为true。
  - !逻辑非:非false则true，非true则false。
  - &&和&的区别?
    - a:最终结果一样。
    - b:&&具有短路效果。左边是false，右边不执行。
      &是无论左边是false还是true,右边都会执行
  - ||和|同上
- 位运算符
  - &,|,^,~ ,>>,>>>,<<
  - &:有0则0
  - |:有1则1
  - ^:相同则0，不同则1
    - ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
  - ~:按位取反
  - <<:左移左边最高位丢弃，右边补齐0
  - >>:右移最高位是0，左边补齐0;最高为是1，左边补齐1
  - >>>:无符号右移无论最高位是0还是1，左边补齐0
- 三目(元)运算符
  - 格式 : (关系表达式) ? 表达式1 : 表达式2;
键盘录入
- 导包 : import java.util.Scanner;
- 创建 : Scanner sc = new Scanner(System.in);
- 录入 : int x = sc.nextInt();
流程控制结构
- 顺序结构
- 选择结构
  - if语句
    - if语句和三元运算符的区别
      三元运算符实现的，都可以采用if语句实现。反之不成立。
    - 格式
      if(比较表达式1) { 语句体1; }else if(比较表达式2) { 语句体2; }else if(比较表达式3) { 语句体3; } ... else { 语句体n+1; }
  - switch语句
    - 格式
      switch(表达式) { case 值1：语句体1; break; case 值2：语句体2; break; … default：语句体n+1; break; }
    - 注意
      1. switch表达式中能接受的基本数据类型为 byte，short，char，int（能自动提升为int的数据类型）
      2. 引用数据类型中可以接受枚举（JDK1.5）和String(JDK1.7）
      3. case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
      4. break省略可能回出现穿透现象
循环结构
- for
  - 格式
    for(初始化表达式;条件表达式;循环后的操作表达式) { 循环体; }
- while
  - 格式
    while(判断条件语句) { 循环体语句; 控制条件语句; }
- do…while
  - 格式
    do { 循环体语句; 控制条件语句; }while(判断条件语句);
- 三种循环格式的区别
  - do…while循环至少执行一次循环体。
  - 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
控制跳转语句
- break；
  跳出循环
- continue；
  终止本次循环继续下次循环
- return；
  跳出方法
- 自定义标记
方法
- 完成特定功能的代码块，提高代码的复用性
- 格式
  修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2...) { 方法体语句; return 返回值; }
- 写一个方法要知道
  1. 明确返回值类型
  2. 明确参数列表
- 方法调用图解
数组
- 格式
  数据类型[] 数组名 = new 数据类型[数组的长度];
- 数组的初始化
  - 静态初始化
    给定初始化值，由系统决定长度数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…}; 数据类型[] 数组名 = {元素1,元素2,…};
  - 动态初始化
    数据类型[] 数组名 = new 数据类型[数组长度]; EX : int[] arr = new int[5];
  - 数组中常见的错误
    - ArrayIndexOutOfBoundsException:数组索引越界异常
      - 原因：你访问了不存在的索引。
    - NullPointerException:空指针异常
      - 原因：数组名指向的堆内存不存在。
数组的基本操作
1. 数组的遍历
- arr.length 数组的长度
- 数组的最大索引:arr.length - 1;

public static void print(int[] arr) {
                for (int i = 0;i < arr.length ;i++ ) {
                    System.out.print(arr[i] + " ");
                }
            }

  2. 数组的反转

public static void reverseArray(int[] arr) {
                for (int i = 0;i < arr.length / 2 ; i++) {
                    //arr[0]和arr[arr.length-1-0]交换
                    //arr[1]和arr[arr.length-1-1]交换
                    //arr[2]和arr[arr.lentth-1-2]
                    //...

                    int temp = arr[i];
                    arr[i] = arr[arr.length-1-i];
                    arr[arr.length-1-i] = temp;
                }
            }

二维数组
- 格式
  1. 数据类型数组名[][] = new 数据类型[m][n];
  2. 数据类型[] 数组名[] = new 数据类型[m][n];
  3. int[][] arr = new int[3][2];
  4. int[][] arr = new int[3][];
  5. int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
- 遍历
  嵌套循环

int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

            for (int i = 0;i < arr.length ;i++ ) {      
                for (int j = 0;j < arr[i].length ;j++ ) {   
                    System.out.print(arr[i][j] + " ");
                }

                System.out.println();
            }

JAVA中的内存分配以及栈和堆的区别（掌握图解）
- A:栈
  - 存储局部变量
- B:堆
  - 存储new出来的数组或对象
- C:方法区
  - 面向对象部分讲解
- D:本地方法区
  - 和系统相关
- E:寄存器
  - 给CPU使用

面向对象

开发
- 不断的创建对象，使用对象，指挥对象做事情。
特征
- 封装(encapsulation)
- 继承(inheritance)
- 多态(polymorphism)
CLASS
- JAVA中最基本的单位
  - 成员变量
    - 在类中，方法外
  - 成员方法
- 类和对象
  - 类：是一组相关的属性和行为的集合
  - 对象：是该类事物的具体体现
- 举例：
  - 学生：
    - 属性: 姓名,年龄,性别
    - 行为: 学习,睡觉
- 创建格式：
  类名对象名 = new 类名();
- 使用：
  对象名.变量名对象名.方法名()
- 如果一个方法的形式参数是一个类类型(引用类型)，其实需要的是该类的对象。
成员变量和局部变量的区别
- A:在类中的位置不同
  - 成员变量：在类中方法外
  - 局部变量：在方法定义中或者方法声明上
- B:在内存中的位置不同
  - 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
  - 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
- C:生命周期不同
  - 成员变量：随着对象的创建而存在，随着对象的消失而消失
  - 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
- D:初始化值不同
  - 成员变量：有默认初始化值
  - 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
- 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
匿名对象的概述和应用
- 什么是匿名对象
  - 没有名字的对象
- 匿名对象应用场景
  - 调用方法，仅仅只调用一次的时候。
    - 好处
      - 节省代码
    - 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
  - 匿名对象可以作为实际参数传递
封装
- 隐藏对象的属性和实现细节，仅对外提供公共访问方式。
- 封装好处
  - 隐藏实现细节，提供公共的访问方式
  - 提高了代码的复用性
  - 提高安全性
- 封装原则
  - 将不需要对外提供的内容都隐藏起来
  - 把属性隐藏，提供公共方法对其访问
- Private
  - private关键字特点
    - 是一个权限修饰符
    - 可以修饰成员变量和成员方法
    - 被其修饰的成员只能在本类中被访问
  - 把成员变量用private修饰
  - 提供对应的getXxx()和setXxx()方法
  - private仅仅是封装的一种体现形式,不能说封装就是私有
- This
  - 代表当前对象的引用
  - this的应用场景
  - 用来区分成员变量和局部变量重名

public class example_Phone {
    public static void main(String[] args){
        Phone p = new Phone();
        p.setBrand("小米");
        p.setPrice(2000);
        p.call();
    }
}
class Phone{
    private int price;
    private String brand;

    public void setPrice(int price){
        this.price = price;
    }

    public int getPrice(){
        return price;
    }

    public void setBrand(String brand){
        this.brand = brand;
    }

    public String getBrand(){
        return brand;
    }

    public void call(){
        System.out.println("打电话");
    }

}

构造方法Constructor概述和格式
- 作用
  - 给对象的数据(属性)进行初始化
- 特点
  - 方法名与类名相同(大小也要与类名一致)
  - 没有返回值类型，连void都没有
  - 没有具体的返回值return;
- 重载
  - 方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
- 注意
  - 如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
  - 如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
给成员赋值的两种方法

class Demo3_Person {
    public static void main(String[] args) {
        Person p1 = new Person("张三",23);
        //p1 = new Person("张天一",23);    //这种方式看运行结果貌似是改名了,其实是将原对象变成垃圾
        System.out.println(p1.getName() + "..." + p1.getAge());

        System.out.println("--------------------");
        Person p2 = new Person();       //空参构造创建对象
        p2.setName("李四");
        p2.setAge(24);

        p2.setName("李鬼");
        System.out.println(p2.getName() + "..." + p2.getAge());
    }
}
/*
构造方法
    给属性进行初始化
setXxx方法
    修改属性值
    这两种方式,在开发中用setXxx更多一些,因为比较灵活
*/
class Person {
    private String name;                //姓名
    private int age;                    //年龄

    public Person() {                   //空参构造
    }

    public Person(String name,int age) {//有参构造
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {  //设置姓名
        this.name = name;
    }

    public String getName() {           //获取姓名
        return name;
    }

    public void setAge(int age) {       //设置年龄
        this.age = age;
    }

    public int getAge() {               //获取年龄
        return age;
    }
}

创建一个对象

class Demo1_Student {
    public static void main(String[] args) {
        Student s = new Student();  
        s.show();
    }
}

class Student {
    private String name = "张三";
    private int age = 23;

    public Student() {
        name = "李四";
        age = 24;                   
    }

    public void show() {
        System.out.println(name + "..." + age);
    }
}![步骤演示](https://img-blog.csdn.net/20180327101255713?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VjaGloYTcxMQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

static关键字
- 随着类的加载而加载
- 优先于对象存在
- 被类的所有对象共享
  - 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
- 可以通过类名调用
  - 其实它本身也可以通过对象名调用。
  - 推荐使用类名调用。
  - 静态修饰的内容一般我们称其为：与类相关的，类成员
- 在静态方法中是没有this关键字的
  * 静态是随着类的加载而加载，this是随着对象的创建而存在。
  * 静态比对象先存在。
- 静态方法只能访问静态的成员变量和静态的成员方法
  - 静态方法：
    - 成员变量：只能访问静态变量
    - 成员方法：只能访问静态成员方法
  - 非静态方法：
    - 成员变量：可以是静态的，也可以是非静态的
    - 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
main方法
- public static void main(String[] args) {}
- public 被jvm调用，访问权限足够大。
- static 被jvm调用，不用创建对象，直接类名访问
- void被jvm调用，不需要给jvm返回值
- main 一个通用的名称，虽然不是关键字，但是被jvm识别
- String[] args 以前用于接收键盘录入的（习惯）
制作一个工具类以及说明书

/**
这是一个数组工具类,里面封装了查找数组最大值,打印数组,数组反转的方法
@author fengjia
@version v1.0
*/
public class ArrayTool {
    //如果一个类中所有的方法都是静态的,需要再多做一步,私有构造方法,目的是不让其他类创建本类对象
    //直接用类名.调用即可
    /**
    私有构造方法
    */
    private ArrayTool(){}

    //1,获取最大值

    /**
    这是获取数组中最大值的方法
    @param arr 接收一个int类型数组
    @return 返回数组中最大值
    */
    public static int getMax(int[] arr) {
        int max = arr[0];                       //记录第一个元素
        for (int i = 1;i < arr.length ;i++ ) {  //从第二个元素开始遍历
            if (max < arr[i]) {                 //max与数组中其他的元素比较
                max = arr[i];                   //记录住较大的
            }
        }

        return max;                             //将最大值返回
    }
    //2,数组的遍历
    /**
    这是遍历数组的方法
    @param arr 接收一个int类型数组
    */
    public static void print(int[] arr) {
        for (int i = 0;i < arr.length ;i++ ) {  //遍历数组
            System.out.print(arr[i] + " ");
        }
    }
    //3,数组的反转
    /**
    这是数组反转的方法
    @param arr 接收一个int类型数组
    */
    public static void revArray(int[] arr) {
        for (int i = 0;i < arr.length / 2 ;i++ ) {  //循环次数是元素个数的一半
            /*
            arr[0]与arr[arr.length-1-0]  交换
            arr[1]与arr[arr.length-1-1]  交换
            arr[2]与arr[arr.length-1-2] 交换
            */
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}

代码块
- 代码块概述
  - 在Java中，使用{}括起来的代码被称为代码块。
- 代码块分类
  - 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
- 常见代码块的应用
  - 局部代码块
    - 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
  - 构造代码块 (初始化块)
    - 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
  - 静态代码块
    - 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
    - 一般用于加载驱动

class Student {
            static {
                System.out.println("Student 静态代码块");
            }

            {
                System.out.println("Student 构造代码块");
            }

            public Student() {
                System.out.println("Student 构造方法");
            }
        }

        class Demo2_Student {
            static {
                System.out.println("Demo2_Student静态代码块");
            }

            public static void main(String[] args) {
                System.out.println("我是main方法");

                Student s1 = new Student();
                Student s2 = new Student();
            }
        }

输出：
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

继承
- 让类与类之间产生关系,子父类关系
- 继承的好处
  - 提高了代码的复用性
  - 提高了代码的维护性
  - 让类与类之间产生了关系，是多态的前提
- 继承的弊端
  - 类的耦合性增强了。
  - 开发的原则：高内聚，低耦合。
  - 耦合：类与类的关系
  - 内聚：就是自己完成某件事情的能力
类的继承特点
- Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
  - 有些语言是支持多继承，格式：extends 类1,类2,…
- Java支持多层继承(继承体系)
- 如果想用这个体系的所有功能用最底层的类创建对象
- 如果想看这个体系的共性功能,看最顶层的类
- 注意
  - 子类只能继承父类所有非私有的成员(成员方法和成员变量)
  - 子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
  - 不要为了部分功能而去继承
this和super都代表什么
- this:代表当前对象的引用,谁来调用我,我就代表谁
- super:代表当前对象父类的引用
- this和super的使用区别
  - 调用成员变量
    - this.成员变量调用本类的成员变量,也可以调用父类的成员变量
    - super.成员变量调用父类的成员变量
  - 调用构造方法
    - this(…) 调用本类的构造方法
    - super(…) 调用父类的构造方法
  - 调用成员方法
    - this.成员方法调用本类的成员方法,也可以调用父类的方法
    - super.成员方法调用父类的成员方法
- 子类中所有的构造方法默认都会访问父类中空参数的构造方法
- 父类没有无参构造方法,子类怎么办?
  - super解决
  - this解决
- 注意事项
  - super（)或者this（)必须出现在构造方法的第一条语句上
重写
- 子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
- 父类中私有方法不能被重写
  - 因为父类私有方法子类根本就无法继承
- 子类重写父类方法时，访问权限不能更低
  - 最好就一致
- 父类静态方法，子类也必须通过静态方法进行重写
  - 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
overload和override
- 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
- 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。

class Test4_Person {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(23);
        System.out.println(s1.getName() + "..." + s1.getAge());
        s1.eat();
        s1.study();

        System.out.println("------------------");
        Student s2 = new Student("李四",24);
        System.out.println(s2.getName() + "..." + s2.getAge());
        s2.eat();
        s2.study();
    }
}
/*
* 使用继承后的学生和老师案例
*/

class Person {
    private String name;                    //姓名
    private int age;                        //年龄

    public Person() {}                      //空参构造

    public Person(String name,int age) {    //有参构造
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {      //设置姓名
        this.name = name;
    }

    public String getName() {               //获取姓名
        return name;
    }

    public void setAge(int age) {           //设置年龄
        this.age = age;
    }

    public int getAge() {                   //获取年龄
        return age;
    }

    public void eat() {                     //吃饭
        System.out.println(name  + "吃饭");
    }
}

class Student extends Person {
    public Student() {}                     //空参构造

    public Student(String name,int age) {
        super(name,age);
    }

    public void study() {
        System.out.println(this.getName() + "学习");
    }
}

class Teacher extends Person {
    public Teacher() {}                     //空参构造

    public Teacher(String name,int age) {
        super(name,age);
    }

    public void teach() {
        System.out.println(this.getName() + "讲课");
    }
}

final
- 特点
  - 修饰类，类不能被继承
  - 修饰变量，变量就变成了常量，只能被赋值一次
  - 修饰方法，方法不能被重写
- final关键字修饰局部变量
  - 基本类型，是值不能被改变
  - 引用类型，是地址值不能被改变,对象中的属性可以改变
- final修饰变量的初始化时机
  - 显示初始化
  - 在对象构造完毕前即可

uchiha711

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVAday1-8笔记

DOS控制台打开 win+r – cmd常见命令 A:d: 回车盘符切换B:dir(directory):列出当前目录下的文件以及文件夹C:cd (change directory)改变指定目录(进入指定目录)D:cd.. : 退回到上一级目录E:cd: 退回到根目录F:cls : (clear screen)清屏G:exit : 退出dos命令行JAVA基础...
复制链接

扫一扫