狂神说JavaSE笔记(更新)

JavaSE

前奏

学习方法

记录

多写代码,多些笔记,多写文章

交流,思维,技能

分享,提问(怎么了),思考(为什么)

坚持

Blog==有效的记忆

总结与思考

文笔组织能力

学习总结能力

逻辑思维能力

帮助他人,结交朋友

冰冻三尺非一日之寒

博客平台----wordpress、typecho

博客园

预科

  1. io设备

i–>input输入

o–>ouput·输出

  1. dos命令

狂神说JavaSE笔记(更新)_第1张图片

环境安装

配置环境变量

1.添加JAVA_HOME–>变量的值=安装路径(bin的上级目录)

2.配置path–>%JAVA_HOME%\bin

​ %JAVA_HOME%\jre\bin

cmd–>java -version测试是否成功

Hello World

public class Hello{
     
    public static void main(String[] args)
        System.out.print("Hello World!");
}

编译–>javac

运行–>java

文件名与类名保持一致

程序运行机制

IDEA安装

IDE–>集成开发环境

入门

所有的标识符都应该以大小写、$、_开头

命名规则

包名:小写

类名:驼峰 所有单词首字母大写

变量名、方法名:小驼峰 lastNameAge

常量名:大写,中间加_

数据类型

基本数据类型

整数类型

int

byte

short

long–>l

浮点类型

float–>f

double

字符类型

char

String–>不是一个关键字,类

布尔类型

引用数据类型

接口
数组

拓展

//整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x
        int i=10;
        int i2=010;//8
        int i3=0x10;//16  0~9  A~F
        //浮点数拓展
        //float 有限的离散的  舍入误差  约数
        // 避免浮点数进行比较 BigDecimal数学工具类
        //double
        float f=0.1f;
        double d=1.0/10;
        System.out.println(f);
        System.out.println(d);
        System.out.println(f==d);
        //0.1
        //0.1
        //false
        float d1=212114343134431f;
        float d2=d1+1;
        System.out.println(d1==d2);
        //true
        //字符类拓展
        char c1='a';
        char c2='中';
        System.out.println((int)c1);
        System.out.println((int)c2);
        //所有的字符本质都是数字
        //编码Unicode 2字节 65536 2 16
        //U0000 UFFFF
        char c3='\u0061';
        System.out.println(c3);
        //转义字符
        // \n--换行 \t--制表符
        String sa = new String("hello world");
        String sb = new String("hello world");

        System.out.println(sa==sb);
        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);

        //布尔值拓展
        boolean flag = true;
        //if (flag==true)与if (flag)是一样的
        //Less is More! 代码要精简易读

数据类型转换

byte,short,char–>int–>long–>float–>double

运算前不同数据类型先转化为同一类型

强制转换

从低到高 (数据类型)变量命

自动转换

自动转换

变量

局部变量–>在方法里的

实例变量–>方法的外面,类的里面,从属于对象

public class Day02 {
     
    String name;
    int age;
    public static void main(String[] args) {
     
        Day02 day02 = new Day02();
        System.out.println(day02.age);
    }
}
//如果不初始化 数值型 默认值 0 0.0
//布尔默认值是 false
//除了基本类型其余都是 null

类变量 stasic

常量

final 常量名=数值

运算符

++a先运算再赋值

a++先赋值再运算

逻辑运算符

与&&---->两个变量为true,结果为true;

或||---->两个变量有一个为true,结果为true;

非!---->如果为true则变为false,反之;

//短路运算
        int a = 5;
        boolean d = (a<4)&&(a++<4);
        System.out.println(d);
        System.out.println(a);

位运算

//位运算
        /*
                                   A = 0011 1100
                                   B = 0000 1101
        如果2个都为1才为1,否则为0   A&B = 0000 1100
        有一个1就为1               A|B = 0011 1101
        相同则为0,不同则为1        A^B = 0011 0001
        取反                       ~B = 1111 0010
         */

左移<< == *2

右移>> == /2

进制

为了便于理解什么叫2进制,先说说10进制。
我们平时常用的都是10进制,顾名思义,满10进1,
也就是当低位的值够10之后,就在高位上加1,本位变成0。
2进制就是同理,计数时满2进1,
当低位满2之后,就在高位+1,低位变成0。

字符串连接符+

如果+两侧有一侧出现字符串,就会把其他类型都转换成字符串类型连接

注意:运算顺序

	int a = 10;
    int b = 20;
	System.out.println(""+a+b);
	System.out.println(a+b+"");
1020
30

条件运算符

? : ----> x ? y : z

如果x为true,则结果为y,否则为z


优先级问题()

import导包

com.baidu.www

流程控制

Scanner

Scanner1

狂神说JavaSE笔记(更新)_第2张图片

if选择结构

  1. if
  2. if……else
  3. if……else if……else

选择其中的一个执行,然后跳出程序。但是Java的基础结构为顺序结构

if嵌套结构

switch多选择结构

switch(expression)

	case value:……

		breakcase value:……

		breakcase value:……

		breakdefault:……

循环结构

  1. while

    狂神说JavaSE笔记(更新)_第3张图片

  2. do…while

    do…while循环和while相似,不同的是,do…while循环至少循环一次(先执行再循环,while相反,先判断再循环)

  3. 增强型for循环

    int[] numbers = {
           12,55,53,34,88,22};
    for (int n:numbers){
           
        System.out.println(n);
    }
    //将numbers的值赋给n
    
  4. for

实例1:

//for循环输出1-1000之间能被5整除的数,每行显示3个
        for (int i = 1  ; i <= 1000; i++) {
     
            if (i % 5 == 0) {
     
                System.out.print(i+"   ");
            }
            if (i%(5*3)==0) {
     
                System.out.println();
            }
        }

实例2:

//打印九九乘法表
for (int i = 1; i <= 9; i++) {
     
            for (int j = 1; j <= i; j++) {
     
                System.out.print(i+"*"+j+"="+(i*j) + "\t");
            }
            System.out.println();
        }

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

//自己的错误示范   
for (int i = 1; i <= 1; i++) {
     
            int y = 1;
            int sum = y * i;
            System.out.println(i+"*"+y+"="+sum);
        }

        for (int i = 1; i <= 2; i++) {
     
            int e = 2;
            int sum = e * i;
            System.out.print(i+"*"+e+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 3; i++) {
     
            int s = 3;
            int sum = s * i;
            System.out.print(i+"*"+s+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 4; i++) {
     
            int si = 4;
            int sum = si * i;
            System.out.print(i+"*"+si+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 5; i++) {
     
            int wu = 5;
            int sum = wu * i;
            System.out.print(i+"*"+wu+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 6; i++) {
     
            int l = 6;
            int sum = l * i;
            System.out.print(i+"*"+l+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 7; i++) {
     
            int q = 7;
            int sum = q * i;
            System.out.print(i+"*"+q+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 8; i++) {
     
            int b = 8;
            int sum = b * i;
            System.out.print(i+"*"+b+"="+sum+"    ");
        }
        System.out.println();

        for (int i = 1; i <= 9; i++) {
     
            int j = 9;
            int sum = j * i;
            System.out.print(i+"*"+j+"="+sum+"    ");
        }
        System.out.println();
  1. break/continue

    break强制退出循环体

    continue退出当前循环并且执行下一次循环

练习:

//打印三角形
for (int i = 1; i <= 5; i++) {
     
    for (int j = 5; j >= i; j--) {
     
        System.out.print(" ");
    }
    for (int j = 1; j <= i; j++) {
     
        System.out.print("*");
    }
    for (int j = 1; j < i; j++) {
     
        System.out.print("*");
    }
    System.out.println();

}

方法

retun可以结束方法

重载

狂神说JavaSE笔记(更新)_第4张图片

可变参数

只能有一个,必须放在最后

练习:

//自己写的计算器
public class Demo04 {
     
    public double add(double a,double b){
     
        double sum = a + b;
        return sum;

    }
    public double sub(double a,double b){
     
        double sum = a - b;
        return sum;
    }
    public double mul(double a,double b){
     
        double sum = a * b;
        return sum;
    }
    public double div(double a,double b){
     
        double sum = a / b;
        return sum;

    }

    public static void main(String[] args) {
     
        Demo04 mythod = new Demo04();

        Scanner scanner = new Scanner(System.in);

        for (int i = 1;; i++){
     
        System.out.println("请输入要计算的数字");
        double a = scanner.nextDouble();
        double b = scanner.nextDouble();

        System.out.println("输入计算方法");
        String method = scanner.next();

            switch (method) {
     
                case "+":
                    System.out.println(mythod.add(a, b));
                    break;
                case "-":
                    System.out.println(mythod.sub(a, b));
                    break;
                case "*":
                    System.out.println(mythod.mul(a, b));
                    break;
                case "/":
                    System.out.println(mythod.div(a, b));
                    break;
            }
    }
    }
}

数组

//声明数组
int[]  num01;
//创建数组
array = new int[10]
    
//声明并且创建数组
int[]  array = new int[长度];

//赋值
	int[] num = {
     0,1,2,3,4,5,6,7,8,9};
	num[1] = 1;

数组原则

ArrayIndexOutOfBoundsException数组下标越界异常

长度是确定的

数组中类型必须相同

数组中元素可以是任何类型

数组变量属于引用类型,数组可以看作为对象,数组中每个元素相当于对象的成员变量

数组本身就是对象,Java中对象是在堆中的,因此无论保存原始类型还是其他对象类型,数组对象本身是在堆中的

数组的使用

public class Demo03 {
     
    public static void main(String[] args) {
     
        int[] array = {
     1,2,3,4,5,6};
        //printArry(array);
        int [] reverse = reverse(array);
        printArry(reverse);


//        for (int i : array) {
     
//            System.out.println(i);
//        }
    }
    //打印数组元素
    public static void printArry(int[] arrays){
     
        for (int i = 0; i < arrays.length; i++) {
     
            System.out.println(arrays[i]);

        }
    }
⭐⭐//反转数组  数组作为返回值
    public static int[] reverse(int[] arrays){
     
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
     
            result[j] = arrays[i];

        }

        return result;
    }
}

多维数组

//循环嵌套输出二维数组
int[][] array = {
     {
     1,2},{
     2,3},{
     3,4},{
     4,5}};
for (int i = 0; i < array.length; i++) {
     
    for (int j = 0; j < array[i].length; j++) {
     
        System.out.print(array[i][j]+"  ");
    }
}

//用增强型for循环输出二维数组
int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        
        System.out.println("输出原始棋盘数组");
        for (int[] ints : array1) {
     
            for (int anInt : ints) {
     
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

Array类

冒泡排序

八大排序之一

//冒泡排序
    public static int[] sort(int[] array) {
     
        int temp = 0;
        //外层循环判断程序跑多少次
        for (int i = 0; i < array.length-1; i++) {
     
            //内层循环,比较两个数的大小
            for (int j = 0; j < array.length-1; j++) {
     
                if (array[j+1]<array[j]){
     
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    return array;
}

稀疏数组

public class Demo08 {
     
    public static void main(String[] args) {
     
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        System.out.println("输出原始棋盘数组");
        for (int[] ints : array1) {
     
            for (int anInt : ints) {
     
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=================================");
//转换为稀疏数组保存

        //获取有效值的个数 便利二维数组
        int sum = 0;
        for (int i = 0; i < 11; i++) {
     
            for (int j = 0; j < 11; j++) {
     
                if (array1[i][j]!=0){
     
                    sum++;
                }
            }
        }
        System.out.println("一共"+sum+"个有效值");
//创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组,把值赋给稀疏数组
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
     
            for (int j = 0; j < array1[i].length; j++) {
     
               if (array1[i][j]!=0){
     
                   count++;
                   array2[count][0] = i;
                   array2[count][1] = j;
                   array2[count][2] = array1[i][j];
               }
            }
        }
//输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
     
            System.out.println(array2[i][0]+"\t"
                            +array2[i][1]+"\t"
                            +array2[i][2]+"\t");
        }
//还原稀疏数组
        //读取稀疏数组
        int[][] array3 =new int[array2[0][0]][array2[0][1]];
        //还原值
        for (int i = 1; i < array2.length; i++) {
     
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        System.out.println("==================================");
        for (int[] ints : array3) {
     
            for (int anInt : ints) {
     
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

内存

  1. 堆:

    存放new的对象和数组

    可以被所有的线程共享,不会存放别的对象引用

  2. 存放基本的变量类型(包含基本类型的具体数值)

    引用对象的变量(存放这个引用在堆里面的具体地址)

  3. 方法区

    可以被所有线程共享

    包含了所有的class和static的变量

面向对象编程OOP

特性

本质:以类的方式组织代码,以对象的形式封装数据

抽象 = 共同点

注意:类里面只有属性和方法

从代码运行的角度来说,先有类再有对象 类是对象的模板

对象,具体的事物。类,抽象的,对对象的抽象。

※ 特性:

**1、**封装 private ”高内聚 低耦合“---->类的内部数据操作细节自己完成,仅暴露少量的方法给外部使用

属性私有 get/set

**2、**继承 extends本质是对某一批楼的抽象,从而实现对世界更好的建模(再次抽象)

​ 继承是类与类之间的一种关系(除此之外还有依赖、组合、聚合等),Java中只有单继承没有多继承(一个子类只能有一个父类)

​ public下,子类继承了父类之后就会有父类的全部方法(也可以用private,需设置公共的方法get/set)

​ CTRL + H 查看继承树

object类---->Java中所有的类都之间或间接继承object类

super

super注意点:
	1.super调用父类的构造,必须在构造方法的第一个
	2.super 必须只能出现在子类的方法或者构造方法中
	3.super和this不能同时调用构造方法
VS this:
		this:本身调用者这个对象
		super:代表父类对象的引用
	前提
		this没有继承也能用
	构造方法:
		this();本类的构造
		super():父类的构造
	

方法重写,和属性无关

B b = new A();//子类重写了父类的方法,只跟非静态有关

​ 总结:前提需要有继承关系,而且是子类重写父类的方法

方法名,参数列表必须相同。方法体不同

​ #修饰符 范围可以扩大,不能缩小public>protected>default>private

​ #抛出的异常:范围可以被缩小,不能被放大

​ 有些方法不能被重写

​ static 方法属于类不属于实例

​ final 常量

​ private方法

**3、**多态

解释:同一个方法可以根据发送对象的不同而采取多种不同的行为方式

多态是方法的多态,属性没有多态。

类型转换异常---->ClassCastException!

多态存在的条件:有继承关系,方法需要重写父类的引用指向的是子类(Father f1 = new Son();)

一个对象的实际类型是确定的,但是指向的引用类型不确定---->父类的引用指向子类

两个类型都有就执行子类,具体看下方代码。

public static void main(String[] args) {
     
    //一个对象的实际类型是确定的
    //new Student();
    //new Person();

    //可以指向的引用类型就不确定了

    Student s1 = new Student();//子类可以调用自己的和父类的方法

    //父类引用指向子类的类型
    Person s2 =  new Student();//虽然可以指向子类,但是不能调用子类独有的方法
    s2.run();//子类重写了父类的方法就执行子类
    s1.run();
    //((Student) s2).eat();
    s1.eat();
    //子类父类都有,只要子类没有重写调用父类
    //对象能执行那些方法看左边类型,右边关系不大

}

构造器

  1. 一个类即使什么都不写,它也会存在一个方法==构造器
  2. 必须和类的名字相同
  3. 必须没有返回值,也不能写void,一旦定义了有参构造就必须显示定义无参构造
  4. 用来初始化值
  5. new对象的时候会进入构造方法

instanceof

判断两个类型是否存在父子关系

自动转换

低---->高 自动转换 子类转换成父类可能会丢失自己的方法

高---->低 强制转换()

条件:父类引用指向子类对象

static

如果有static,就用类名访问

如果没有static,就用对象

非静态方法可以访问静态方法

public class Person {
     
    {
           //可以赋值初始值,因为和对象同时产生对象
        System.out.println("匿名代码块");
    }
    static {
     
        //静态代码块,只执行一次,其他的,在对象创建时候就会执行。
        System.out.println("静态代码块");
    }

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

    public static void main(String[] args) {
     
        Person person1 = new Person();
        System.out.println("==========");
        Person person2 = new Person();
    }
}

//被final修饰的量没有子类

抽象类

用abstract修饰或者方法

//抽象方法,没有方法的实现
//抽象类的所有方法必须要有子类实现
//继承抽象类的子类必须要实现它的方法 重写
//除非子类也是抽象方法

不能new抽象类,只能靠子类实现

抽象类中可以用普通方法

抽象方法必须在抽象类中

接口

接口就是规范

###设计模式=面向对象的精髓

接口中方法默认public abstract
###接口中变量默认public static final
//类可以实现接口
//实现了接口的类必须要重写接口的方法,一个类可以实现多个接口(侧面实现多继承)
//接口同过implements实现
//接口不能被实例化,接口没有构造方法

架构师==抽象的思维


内部类

内部类访问外部类的私有变量

  1. 静态内部类 无法访问非静态的属性

  2. 匿名类 一个Java文件中可以有多个class类,但是只能有一个main

  3. 局部内部类

  4. 匿名内部类

    new.Apple().eat();
    

异常机制介绍

检查性异常

运行时异常

错误Error

try

catch捕获

​ catch(想要捕获的异常类型) 最高的Throwable

finally

throw 在方法里主动抛出异常

throws 在方法上抛出异常

异常要从小到大

快捷键CTRL+ALT+T

你可能感兴趣的:(Java,笔记,java,javase,面向对象编程,抽象类,多态)