java基础

1.安装jdk和IDEA

2.创建自己的第一个项目

3.编写自己的第一段代码

package com.Gu0f3n;

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

注释

单行注释 / /

多行注释/**/

package com.Gu0f3n;
//这是我的第一段代码
public class test01 {
    //main方法是程序的入口
    public static void main(String[] args) {
        //在控制台上进行打印
        System.out.println("hello,world");
        System.out.println("hello,world");
        System.out.println("hello,world");
        System.out.println("hello,world");
        /*
多行注释
随便打一些东西

         */

    }
}

常用快捷键：
main方法快捷键：psvm+回车
控制台原样输出：sout+回车
删除一行：ctrl+y
复制—行：ctrl+d

变量

变量的含义

变量本质上就是代表一个”可操作的存储空间”，空间位置是确定
的，但是里面放置什么值不确定。我们可通过变量名来访问“对应
的存储空间”，从而操纵这个“存储空间”存储的值。Java是一种
强类型语言，每个变量都必须声明其数据类型。变量的数据类型决
定了变量占据存储空间的大小。

变量的学习

步骤1：变量的声明
type varName [=value][,varName[=value]...];
注意：变量不可以重复定义
步骤2：变量的赋值
注意：变量的声明和赋值可以在同一行表示
步骤3：变量的使用

public class TESTvar {
    public static void main(String[] args) {
        //1.变量的声明（定义）
        //定义一个名字的变量
        String name;//定义一个变量为name，类型为string
        // 注意：变量不可重复定义
        int a,b;//同时可以定义多个变量
        name="Gu0f3n";//等号赋值
        //2.变量的赋值
        int age;
        age=18;//等号赋值
        age=32;
        age=40+18;
        //变量的定义和复制可以写在同一行
        int age1=19;
        int c =10;
        int e,f =30;//e没有赋值，f赋值30
        //变量的使用
        System.out.println(age);//使用变量的时候通过名字访问到空间中具体的值
        int g=20;
        System.out.println(age+g);
    }
}
/*
控制台的打印结果
58
78
*/

数据类型

数据类型的分类

Java是一种强类型语言，每个变量都必须声明其数据类型
Java的数据类型可分为两大类：基本数据类型（primitivedata
type）和弓l用数据类型（reference data type）

public class TESTtype {
    public static void main(String[] args) {
        //基本数据类型
        //1.整数类型
        byte a =10;//表述范围-128~127
        short b =22000;//表述范围：正负三万
        int c =30123131;//正负21亿
        long d =401215151513131513L;//表述范围 很大 如果表示的数的范围超过intl类型范围就需要加L
        //2.浮点类型
        float e =3.14f;//如果float表示一个小数，后面必须加上f
        double f =4.56789;
        //3.字符类型
        char g ='a';//单引号引起来的单个字符
        System.out.println("Gu0f3n");//后续的字符串
        //4.布尔类型
        boolean flag =true;//true and false

    }
}

运算符

public class TESTope {
    public static void main(String[] args) {
        //1.算数运算符
        //加号 1.表示正数2.相加 3.字符串拼接
        System.out.println(+10);
        System.out.println(5+6);
        int num =10;
        System.out.println("输出一个数"+num);
        System.out.println("abc"+5+6);
        //只要+左右两侧任意一侧是字符串，那么结果就是字符串
        //++自增
        int a =85;
        a++;
        int b=85;
        ++b;//无论++放在变量前还是后都是+1
        System.out.println(a);
        System.out.println(b);
        a=5;
        int m = a++ + 7;//如果++在变量的后面 先运算后加1，m=a+7 a+1
        System.out.println(a);
        System.out.println(m);
        a=5;
        int n = ++a + 7;//++在变量前，先加1，在运算，a=a+1,n=a+7
        System.out.println(a);
        System.out.println(n);
    }//程序入口
}
/*
10
11
输出一个数10
abc56
86
86
6
12
6
13
*/

public class TESTOPe2 {
    public static void main(String[] args) {
        //赋值运算符 =
        int num1 =10;
        int num2 =20;
        int num3 =10+30;
        //求和
        int sum =0;
        sum+=num1;
        sum+=num2;//sum=sum+num2;
        sum+=num3;//sum=sum+num3;
        System.out.println("和："+sum);
    }
}
#和：70

public class TESTope3 {
    public static void main(String[] args) {
        //关系运算符==，最终结果是布尔值，不是true就是false
        System.out.println(5==6);
        System.out.println(5==5);
        //逻辑运算符：逻辑运算符左右连接的是布尔值
        System.out.println(false&&true);
        System.out.println(true&&true);
        //&&逻辑 都是ture 则为true 有一个false都为false
        System.out.println(false&&false);
        System.out.println(true&&false);
        //||逻辑 如果都为false 结果都为false
        System.out.println(false||true);
        System.out.println(true||true);
        System.out.println(false||false);
        System.out.println(true||false);

    }
}
控制台结果：
false
true
false
true
false
false
true
true
false
true

流程控制

作用：流程控制语句是用来控制程序中各语句执行顺序的语
句，可以把语句组合成能完成一定功能的小逻辑模块

分类

分支结构

if单分支

package com.Gu0f3n.test02;

public class TESTif01 {
    public static void main(String[] args) {
        //需求 判断一个数是否大于0
        //给定一个数
        int num =13;
        //判定
        if(num >10){//if 后面是一个表达式，true or false ,只有为true才会返回{}
            System.out.println("这个数字大于10");
        }
    }
}

if双分支

package com.Gu0f3n.test02;

public class TESTif02 {
    public static void main(String[] args) {
        //需求是否大于10
        int num =8;
        if(num >10)
        {
            System.out.println("这个数字大于10");
        }else{
            System.out.println("这个数小于等于10");
        }
    }
}

if多分支

package com.Gu0f3n.test02;

public class TESTif03 {
    public static void main(String[] args) {
        //判断学生成绩的等级
        int score =84;//给定学生一个等级
//        if(score>90){
//            System.out.println("该学生的等级为A");
//        }
//        if(score>80 && score<90){
//            System.out.println("该学生的等级为B");
//        }if(score>70 && score<80){
//            System.out.println("该学生的等级为C");
//        }
        //多分枝结构解决问题
        if (score >= 90) {
            System.out.println("该学生的等级为A");
        }else if (score >= 80) {
            System.out.println("该学生的等级为B");
        }else if (score >= 70) {
            System.out.println("该学生的等级为C");
        }else if (score >= 60) {
            System.out.println("该学生的等级为D");
        }else{//兜底
            System.out.println("该学生的等级为E");
        }
    }
}

循环结构

while循环

int num =1;//条件初始化
int sum =0;
        while (num<=5) {//如果表达式结果为true，那么就变成死循环//判断
            sum = sum + num;//循环体
            num++;//迭代
        }

num<=5->true,sum:1，num:2->第一次循环结束
num<=5->true,sum：3，num：3->第二次循环结束
num<=5->true,sum：6，num：4->第三次循环结束
num<=5->true,sum:10,num：5->第四次循环结束
num<=5->true,sum:15;num:6->第五次循环结束
m<=5->false->循环停止

for循环

int sum =0;
for(int num=1;num<=5;num++) {//1.条件初始，条件判断，迭代
    sum = sum + num;//循环体
}
System.out.println("和为"+sum
);

方法和方法重载

方法

就是一段用来完成特定功能的代码片段

例如psvm，sout

方法声明格式
修饰符1修饰符2]返回值类型方法名（形式对象名.方法名（实参列表）
方法调用方式
方法名（实参列表）（参数列表）

package test04;

public class TESTmethod {
    //提取一个方法， 将两个数求和
        public static int addNum(int num1 ,int num2){
            //求和

             int sum=num1+num2;
             return sum;
        }

    public static void main(String[] args) {
        //10，20
         int a=addNum(10,20);
        System.out.println(a);
        //30，20
        int b = addNum(30,20);
        System.out.println(b);
        //40，8186
         addNum(40,8186);
        System.out.println(addNum(40,8186));
        //1.方法 提高代码的复用性，写一次 直接调用即可
    }   //public static  方法的修饰符
        // int 方法的返回值类型   方法返回值对应的数据类型
    // addNum 见名知意
    // num1 num2 形式参数列表 形参
    //10 20  实参
    //return sum; 方法的最后有方法的返回值（可有）如果没有返回值 方法申明出 加上void
}
打印结果：
30
50
8226

方法的重载：
在同一个类中，方法名相同，形参列表不同的多个方法，构成了方法的重载。

方法名重复 但形参列表不一样//方法 的重载只和形参列表有关

数组

数组是相同类型数据的有序集合。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

特点

1.长度是确定的数组一旦被创建它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型
3.数组类型可以是任何数据类型，，包括基本类型和引用类型。
4.数组有索引的：索索引l从0开始，到数组.length-1结束

package test03;

public class TESTArray {
    public static void main(String[] args) {
        //数组声明
        int[] ary;//定义一个数组
        ary = new int[10];//给定一个数组的长度10
        //int ary =new int[10];一句话，默认长度的每个元素有默认的值
        //数组的赋值；
        ary[0] = 1;
        ary[1] = 2;
        ary[2] = 31;
        ary[3] = 365;
        ary[4] = 456;
        //数组的使用
        System.out.println(ary[3]);
        System.out.println(ary[1]+30);
        //数组的遍历（查看数组的每一个元素）
        for(int i =0;i <=3;i++){//i代表元素的索引
            System.out.println("第"+ i +"个元素"+ary[i]);
            System.out.println("增强的for循环");
for(int num:ary){
    System.out.println(num);
}
        }
    }
}

面向对象 —类和对象

类：对对象向上抽取出像的部分、公共的部分以此形成类，类就相当于一个模版。
对象：模版下具体的产物可以理解为具体对象，对象就是一个一个具体的实例，就
相当于这个模版下具体的产品。
Java中先定义类，再创建对象。

类的编写
1.给类起一个见名知意的名字，首字母大写，驼峰命名原则。
2.类的特性编写，特性即类的属性部分。
3.类的行为编写，行为即类的方法部分。
对象的创建和使用
创建格式：类名对象名=new类名();
给对象的属性赋值：对象名.属性名=值；
调用对象的方法：[返回值类型名字=]对象名.方法名(参数列表);

对象的创建

package test05;
//人类
public class person {
    //特性编写 属性（指定义与业务逻辑相关的代码）
    String name;
    int age;
    double height;
    
    
    
    //行为 方法
    //定义一个学习的方法
    public void study(){
        System.out.println("伞兵一号卢本伟准备就绪");
    }
}

使用

package test05;

public class test {
    public static void main(String[] args) {
        //程序入口
        //对我们的person类进行创建
        person p1 = new person();//实例化一个对象
        p1.name = "Gu0f3n";
        p1.age = 20;
        p1.height=181.99;
        System.out.println(p1.age);
        System.out.println(p1.height);
    }
}

构造器

作用

对于一个类来说，一般有三种常见的成员：属性、方法、构造器。
这三种成员都可以定义零个或多个。
构造方法也叫构造器，是一个创建对象时被自动调用的特殊方法，用于对象的初始化。
Java通过new关键字来调用构造器，从而返回该类的实例。

构造器声明类型

声明格式：

[修饰符]类名（形参列表）
//n条语句

若无参数列表，称之为无参构造器（空构造器）
若有参数列表，称之为有参构造器

封装

我们程序设计追求“高内聚，低耦合”。

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系
统的可扩展性、可维护性，提高程序的安全性。通俗的说，把该隐藏的隐藏起
来，该暴露的暴露出来。这就是封装性的设计思想。

继承

类是对对象的抽象

继承是对类的抽象

随便写点代码练习一下

父类person

package Gu0f3n.java.test02;

public class person {
    int age;
    double height;
    String name;

    public double getHeight() {
        return height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //吃饭
    public void eat(){
        System.out.println("eat");

    }
    //睡觉
    public void sleep(){
        System.out.println("sleep");

    }
    //打豆豆
    public void dadoudou(){
        System.out.println("打豆豆哦");
    }
}

package Gu0f3n.java.test02;

public class students extends person{//子类继承自父类
    //定义子类自己的属性和方法
    private int sno;

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }
    public void study(){
        System.out.println("study");
    }
}

package Gu0f3n.java.test02;

public class Test {
    public static void main(String[] args) {
        students s = new students();
        s.setSno(24710245);
        s.age=18;
        s.height=181.6;
        s.name="xiaobia";
        s.eat();
        s.study();
        s.dadoudou();

    }
}
//发现具体的类我可以随意调用
#eat
#study
#打豆豆哦

好处：

1.提高 代码的复用性

2.便于代码的扩展

3.为了多态的使用

方法的重写

发生在子类和父类，当子类对父类的提供的方法不满意的时候，要对父类方法进行重写

格式要求

子类的方法名字和父类必须一直，参数列表（个数，类型，顺序）

与重载的区别

重载：在同一个类中，当方法名相同，形参列表不同的时候，多个方法构成重载

重写：不同类中，子类对父类的提供方法不满意，可对父类进行重写

多态

概念

多种状态，具体一点基于是去完成某个行为，当不同对象去完成时会产生出不同的状态。同意行为，不同的子类呈现的状态不同
ps:多态与属性无关，多态指的方法的多态，而不是属性

多态的三要素：继承，重写，父类引用指向子类对象

多态的好处：提高代码的扩展性

异常的处理

异常就是在程序中的运行过程中所发生的不正常的时间，他会中断正在运行的程序

所需文件找不到
网络连接不通或中断
算术运算错 (被零除..)
数组下标越界
装载一个不存在的类或者对null对象操作
类型转换异常

Java提供异常处理机制。它将异常处理代码和和业务代码分离，使程序更优雅，更好的
容错性，高键壮性。
Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws

try-catch执行情况
情况1：try块中代码没有出现异常
不执行catch块代码，执行catch块后边的代码
情况2：try块中代码出现异常，catch中异常类型匹配（相同或者父类）
Java会生成相应的异常对象，Java系统寻找匹配的catch块，执行catch块代码，执行
catch块后边的代码。try块中尚未执行的语句不会执行。
情况3：try块中代码出现异常，catch中异常类型不匹配
不执行catch块代码，不执行catch块后边的代码，程序会中断运行
catch块中如何处理异常
其中一种方式：自定义内容输出

package Gu0f3n.java.test06;

public class Test01 {
    public static void main(String[] args) {
        //两个数求商
        try{
            int num1=12;
            int num2=0;
            System.out.println("两个数的商"+num1/num2);
        }catch(Exception e){
            System.out.println("对不起，程序有问题");
        }
    }
}
#对不起，程序有问题

throw和throws的区别：
（1）位置不同：
throw：方法内部
throws：方法的签名处，方法的声明处
（2）内容不同：
throw+异常对象D
throws+异常的类型
（3）作用不同：
throw：异常出现的源头，制造异常。
throws：在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异
常。然后调用者对这个异常进行处理：要么自己处理要么再继续向外抛出异常。

集合

数组的缺点 –.> 集合的优点

（1）数组一旦指定了长度，那么长度就被确定了，不可以更改。
（2）删除，增加元素效率低。

（3）数组中实际元素的数量是没有办法获取的，没有提供对应的方法或者属性来获取

（4）对于无序的，不可重复的场合数组不能满足要求。

集合体系非常庞大

ArrayList()

package Gu0f3n.java.test07;

import jdk.management.resource.internal.inst.SocketOutputStreamRMHooks;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList  list = new ArrayList();
         list.add("A");
         list.add("B");
         list.add("C");
        System.out.println(list);
        list.set(0, "D");
        System.out.println(list);
        list.get(2);
        System.out.println(list.get(2));
        list.remove(2);
        System.out.println(list);
    }
}
//[A, B, C]
//[D, B, C]
//C
//[D, B]

简单写个小项目

写个小菜单

package Gu0f3n.java.test08;

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Scanner;

//【选择你的心仪对象】
  // 展示女嘉宾
  // 上场女嘉宾
  // 下场女嘉宾
  // 退出
//女嘉宾编号 女嘉宾名字 女嘉宾年龄
//  1           wws        18
public class Test {
    public static void main(String[] args) {
        //打印菜单
        ArrayList list=new ArrayList();//空集合 注意作用范围，

        while(true){
            System.out.println("请选择你要的操作");
            System.out.println("-----1.展示女嘉宾-----");
            System.out.println("-----2.上场女嘉宾-----");
            System.out.println("-----3.下场女嘉宾-----");
            System.out.println("-----4.退出本项目-----");
            //借助Scanner 类
            Scanner sc = new Scanner(System.in);
            //利用键盘录入序号：
            System.out.println("请输入要执行功能的序号:");
            sc.nextInt();
            int choice = sc.nextInt();
            //根据choice 录入功能序号进行后续判断
            if(choice == 1) {
                System.out.println("1.展示女嘉宾");
                for(int i=0;i<=list.size()-1;i++){
                    Girl g=(Girl)(list.get(i));
                    System.out.println(g.getGnum()+"---"+g.getGname()+"---"+g.getGage());
                }
            }

            if (choice == 2) {
                System.out.println("2.上场女嘉宾");
                //从键盘录入女嘉宾编号
                System.out.println("请为女嘉宾输入编号");
                int gnum;
                gnum = sc.nextInt();
                System.out.println("请输入女嘉宾的名字");
                 String gname=sc.next();
                System.out.println("请输入女嘉宾的年龄");
                int gage=sc.nextInt();
                Girl g=new Girl(gnum,gname,gage);
                g.setGnum(gnum);
                g.setGname(gname);
                g.setGage(gage);
                //创建一个集合，用于存放一个相同个体

                list.add(g);//添加女嘉宾


                //
            }

            if (choice == 3) {
                System.out.println("3.下场女嘉宾");
                int delNo = sc.nextInt();//下场对应的女嘉宾
                for(int i=0;i<=list.size()-1;i++){
                    Girl g=(Girl)list.get(i);
                    if(g.getGnum()==delNo){
                        list.remove(g);
                        System.out.println("可惜不是你，陪我到最后~~~");
                        break;//成功 停止遍历
                    }
                }
            }

            if (choice == 4) {
                System.out.println("4.退出");
                break;
            }
        }
    }
}

package Gu0f3n.java.test08;

import Gu0f3n.java.test05.Gire;

public class Girl {//女嘉宾
    //属性
    //女嘉宾编号
    //名字
    //年龄
    private int gnum;
    private String gname;
    private int gage;

    public String getGname() {
        return gname;
    }

    public void setGname(String gname) {
        this.gname = gname;
    }

    public int getGnum() {
        return gnum;

    }

    public void setGnum(int gnum) {
        this.gnum = gnum;
    }

    public int getGage() {
        return gage;
    }

    public void setGage(int gage) {
        this.gage = gage;
    }
    //构造器
    public Girl(int gnum, String gname, int gage) {
        this.gnum = gnum;
        this.gname = gname;
        this.gage = gage;

    }
}

这上面基本上覆盖了之前学过的所有内容

I/O流

File 类作用

File类对象可封装要操作的文件，可通过File类的对象对文件进行操作，如查看文
件的大小、判断文件是否隐藏、判断文件是否可读等。
局限：File类的相关操作，并不涉及文件内容相关的操作，这是单独依靠File类对
象无法实现的操作，此时需要借助I/O流完成。

I/O input/output

分类

将I/O流理解为“管子”，那么生活中“管子"怎么分类的呢？分类方式如下所示。
方式1：按照方向划分。
输入流、输出流。
方式2：按照处理单元划分。
字节流、字符流。
方式3：按照功能划分。
节点流、处理流

i/o流体系

练习

package Gu0f3n.java.test09;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Test01 {
    public static void main(String[] args) throws IOException {
        //对文件进行操作，将文件封装为file 对象
        File f= new File("D:\\CTF\\Audacity\\java project\\java study\\src\\Gu0f3n\\java\\test.txt");
        //输入字符流
        FileReader fr = new FileReader(f);
        //开始
//        int n1 = fr.read();
//        System.out.println(n1);
//        int n2 = fr.read();
//        System.out.println(n2);
//        int n3 = fr.read();
//        System.out.println(n3);
//        int n4 = fr.read();
//        System.out.println(n4);
//        int n5 = fr.read();
//        System.out.println(n5);
//        int n6 = fr.read();
//        System.out.println(n6);
//        int n7 = fr.read();
//        System.out.println(n7);
//        int n8 = fr.read();
//        System.out.println(n8);
        int n=fr.read();
        while(n!=-1){
            System.out.println(n);
            n=fr.read();
        }
        fr.close();//流关闭


    }
}