Java学习笔记

最新推荐文章于 2023-05-16 16:14:59 发布

cj1064789374

最新推荐文章于 2023-05-16 16:14:59 发布

阅读量769

点赞数

分类专栏： 2021年研究生学习笔记文章标签： java

本文链接：https://blog.csdn.net/cj1064789374/article/details/119982371

版权

安装

在这里插入图片描述

上面装完了javajdk(与jre)，下面装IDEA并运行（将来有自己的网站把jdk上传上去）

语法

在这里插入图片描述

//变量类型

package cj;

public final class test01 {
   //final表示这个类不能被继承
    public static void main(String[] args) {
   
        //primitive type基本类型x8
        int num1=10;//4B
        byte num2=20;//1B
        short num3=30;//2B
        long num4=30L;//8B
        float num5=50.0F;//4B
        double num6=60.0;//8B
        char char1='中';//2B，java采用unicode
        boolean bool1=true;//false,1B

        //reference type引用类型x3
        String string1="cj";//String是类
        //接口
        //数组

        //进制
        int num7=0xFF;//十六进制
        int num8=077;//八进制
        int num9=0b11;//二进制

        //精度
        System.out.println((int)23.7);//23（向零取整）
        System.out.println((int)-45.89f);//45（向零取整）
        float float1=23131313131313131313f;
        float float2=float1+1;
        System.out.println(float1==float2);//true
        float float3=0.1f;
        double float4=0.1;
        System.out.println(float3==float4);//false
        //不要完全使用浮点数比较，除非用BigDecimal类

        String sa=new String("hello world");
        String sb=new String("hello world");
        System.out.println(sa==sb);//false，引用对象不同
        System.out.println(sa.equals(sb));//true，对象的值相同

        String sc="hello world";
        String sd="hello world";
        String se="hello ";se+="world";
        System.out.println(sc==sd);//true，都指向同一个常量
        System.out.println(sc==se);//false，引用对象不同

        //可以下划线
        int money=10_0000_0000;
        System.out.println(money);

    }
}
/*
        # 记事本中的编码方式

        ANSI：
        - 默认编码方式，对于英文是ASCII编码，对于中文是GB2312编码（两字节一个汉字）
        - 严存储为两个字节D1 CF，即严的 GB2312 编码（采用大端方式存储）

        Unicode：
        - 广义上讲是一个符号集，用两个或以上的字节来表示一个符号，如汉字严的Unicode是0x4E25
        - notepad中是狭义的Unicode，指用两个字节，小端方式存储，小端方式用FF FE表示
        - 汉字严用记事本Unicode存储为FF FE 25 4E，共四个字了，前两个字节用于表示大小端模式

        Unicode big endian：
        - 汉字严用记事本Unicode big endian存储为FE FF 4E 25

        utf-8：
        - 由Unicode转换而来
        Unicode符号范围     |        UTF-8编码方式
        (十六进制)        |              （二进制）
        ----------------------+---------------------------------------------
        0000 0000-0000 007F | 0xxxxxxx
        0000 0080-0000 07FF | 110xxxxx 10xxxxxx
        0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
        0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
        - 严的 Unicode 是4E25（100111000100101）在第三行范围内（0000 0800 - 0000 FFFF）
        - 严的 UTF-8 编码需要三个字节，即格式是1110xxxx 10xxxxxx 10xxxxxx
        - 从严的最后一个二进制位开始，依次从后向前填入格式中的x，多出的位补0
        - 得到严的 UTF-8 编码是11100100 10111000 10100101，转换成十六进制就是E4B8A5
 */

//运算符

package cj;                 //表示当前的类所属的包
import www.Hi;              //导入www包下的Hi类
/**
 * @cj
 * @version 1.0
 *
 * @since 1.8
 */
//命令行执行javadoc -encoding UTF-8 -charset UTF-8 test02.java可以生成说明文档
public class test02 {
   
    static int a=123;       //类变量
    String b="hello world"; //实例变量
    public void method(){
   
        int i=234;          //局部变量
        System.out.println(i);
    }
    public static void main(String[] args) {
   
        //外部类
        Hi hello = new Hi();
        hello.func();
        //变量
        test02 p=new test02();
        System.out.println(a);
        System.out.println(p.b);
        p.method();
        //比较
        System.out.println(24>5);
        System.out.println(24>=5);
        System.out.println(24==5);
        System.out.println(24!=5);
        System.out.println(24<5);
        System.out.println(24<=5);
        //运算
        System.out.println(24+5);
        System.out.println(24-5);
        System.out.println(24*5);
        System.out.println(24/5);
        System.out.println(24%5);
        int x=5;
        x++;
        System.out.println(x);
        x--;
        System.out.println(x);
        x+=4;
        System.out.println(x);
        x-=9;
        System.out.println(x);
        x*=2;
        System.out.println(x);
        x/=3;
        System.out.println(x);
        byte y=14,z=12;
        //位操作
        System.out.println(y&z);
        System.out.println(y|z);
        System.out.println(y^z);
        System.out.println(~z);
        System.out.println(y>>1);
        System.out.println(y<<1);
        System.out.println(y>>>1);//无符号右移，忽略符号位，空位都以0补齐
        System.out.println(""+y+z);
        System.out.println(y+z+"");
        String ss=4>3?"真":"假";
        System.out.println(ss);
        //逻辑符
        System.out.println(y>4&&z>3);
        System.out.println(y>4||z>3);
        System.out.println(!(y>4||z>3));
    }
}

/*
命令规范：
类名：首字母大写与驼峰
变量：首字母小写与驼峰
常量：全部大写与下划线
 */

//重载

package cj;

import java.util.Scanner;

public class test03 {
   
    //javac编译后生成class字节码文件，然后扔到JRE里解释运行
    //idea可以反编译class文件
    public static void main(String[] args) {
   
        for (int i = 0; i < args.length; i++) {
   
            System.out.println(args[i]);
        }//终端指令 F:\Desktop\idea_test\out\production\idea_test>java cj.test03 this is CJ
    }
    public static void getInt1(){
   
        Scanner scan=new Scanner(System.in);
        String r=scan.next();//开头的空白忽略，有效字符开始输入，至空白结束
        String s=scan.nextLine();//所有字符，直到遇换行
        String t=scan.next();//不能得到有空格的字符串
        System.out.println(r);
        System.out.println(s);
        System.out.println(t);
        scan.close();
        /*
        in:
         aa bb cc
         dd ee ff
        out:
        aa
         bb cc
        dd
         */
    }
    public static void getInt2(){
   
        Scanner scan=new Scanner(System.in);
        if(scan.hasNextInt()){
   
            int i=scan.nextInt();
            System.out.println("i:"+i);
        }else{
   
            System.out.println("Input an integer please.");
        }
        scan.close();
    }
    public static void getSum() {
   
        Scanner scan=new Scanner(System.in);
        double sum=0;
        int m=0;
        while(scan.hasNextDouble()){
   
            sum+=scan.nextDouble();
            m+=1;
        }
        System.out.println(sum/m);
        scan.close();
    }
    public static void testFor(){
   
        int[] numbers={
   10,20,30,40,50};
        for(int x:numbers){
   
            System.out.println(x);
        }
    }
    public static int myFunc(int x){
   
        return x+1;
    }
    public static double myFunc(double x){
   
        return x-1;
    }
    public static void myFunc(int... x){
   
        for (int i = 0; i < x.length; i++) {
   
            System.out.println(x[i]);
        }
        //myFunc(12,3,43,545,6,7);//相当于传一个数组，但是每个元素作为一个变量来传递
    }
}

//数组

package cj;

public class test04 {
   
    public static void main(String[] args) {
   
        System.out.println("一维");
        int[] x=new int[10];
        int[] y={
   1,2,3,4};
        for (int i = 0; i <y.length ; i++) {
   
            System.out.println(y[i]);
        }
        for(int z:y){
   
            System.out.println(z);
        }
        System.out.println("二维");
        int[][] a=new int[2][3];
        int[][] b={
   {
   1,2},{
   3,4}};
        reverse(b);
        for (int[] i:b) {
   
            for (int j:i) {
   
                System.out.println(j);
            }
        }
        //==========================
        //如果文件头有import static java.lang.Math.random;则下面直接用random即可
        System.out.println(Math.random());
        System.out.println(Math.PI);
    }
    private static void reverse(int[][] b) {
   
        for (int i = 0; i < b.length/2; i++) {
   
            int[] tmp=b[i];
            b[i]=b[b.length-i-1];
            b[b.length-i-1]=tmp;
        }
    }
}

//封装，Student与Person

package cj;

public class test05 {
   
    public static void main(String[] args) {
   
        Person p1=new Person("gjl");
        p1.name="cj";
        p1.love();
        p1.setAge(100);
        System.out.println(p1.getAge());

        Student c1=new Student();
        c1.print2name();
    }
}

package cj;

public class Person {
   
    //private本类对象可访问
    //protected本类及子类对象可访问
    //public全世界可访问
    String name;
    String lover;
    // 默认的无参构造就是空的函数
    // 如果有人为定义构造函数，则默认的无参构造就会失效
    public Person(){
   
        this.name="Person name";
    }
    public Person(String lover){
   
        this.lover=lover;
    }
    public void love(){
   
        System.out.println(this.name+" 爱 "+this.lover);
    }
    // alt+insert再选中要初始化的属性
    // 按确定可以一键生成constructor
    private int age;
    public int getAge() {
   
        return this.age;
    }
    public void setAge(int age) {
   
        if(age>120||age<3)this.age = 3;
        else this.age = age;
    }



}

package cj;

public class Student extends Person {
   
    String name;
    public Student(){
   
        super();
        //如果不手动写父类构造
        // 默认是调用父类的无参构造
    }
    public void print2name(){
   
        System.out.println(this.name);
        System.out.println(super.name);
        //如果Studento类没有定义name
        //则this.name指向super.name
    }

}

//多态：A与B

package cj;

public class test06 {
   
    public static void main(String[] args) {
   
        A a1=new A();
        //B b1=new A();//不可行
        A a2=new B();//父类引用指向子类对象
        B b2=new B();
        a1.test();//A_test
        a2.test();//B_test，非静态方法属于实例
        b2.test();//B_test
        a1.static_test();//A_static_test
        a2.static_test();//A_static_test，静态方法属于类
        b2.static_test();//B_static_test
        // 父类引用指向子类对象的结论：静态方法用父类，非静态方法用子类
        // 规范写法，静态方法该用类名调用，所以我们记住方法调用时由实际new出来的类型决定就行（其实调用时会父类引用会先转化成子类）
        // 只有方法有多态，属性没有

        Object obj=new Student();
        System.out.println(obj instanceof Student);//T
        System.out.println(obj instanceof Person);//T
        System.out.println(obj instanceof Object);//T
        System.out.println(obj instanceof String);//F

    }
}

package cj;

public class A {
   
    public static void static_test(){
   
        System.out.println("A_static_test");
    }
    public void test(){
   
        System.out.println("A_test");
    }
}

package cj;

public class B extends A{
   
    public static void static_test(){
   
        System.out.println("B_static_test");
    }
    public void test(){
   
        System.out.println("B_test");
    }
}

//块

package cj;

public class test07 {
   
    static{
   
        System.out.println("静态代码块，加载类时执行");
    }
    {
   
        System.out.println("匿名代码块，创建实例时先于构造方法执行");
    }
    public test07(){
   
        System.out.println("构造方法，在匿名代码块后执行");
    }
    public static void main(String[] args) {
   
        test07 t1=new test07();
        System.out.println("---");
        test07 t2=new test07();
    }
}

//抽象类

package cj;

public abstract class test08 {
   
    //抽象类不能创建实例
    public abstract void doSomeThing();
    //抽象方法必须在抽象类中
    //子类必须实现抽象方法，除非子类也是抽象类
}

package cj;

//public abstract class test08_son extends test08{则不用重写抽象方法
public class test08_son extends test08{
   
    //按alt+insert生成要重写的方法
    @Override
    public void doSomeThing() {
   
        System.out.println("实现了父类的抽象方法");
    }
}

//接口（比抽象类更抽象，可以多继承）

package cj;

public class test09 implements test09_interface1,test09_interface2 {
   
    //alt+insert选override的method
    @Override
    public void run() {
   

    }

    @Override
    public void walk() {
   

    }
    //接口可以继续接口
    //接口没有构造方法，抽象类有
}

//接口（比抽象类更抽象）

package cj;

public interface test09_interface1 {
   
    void run();//都是public abstract的
}

//接口（比抽象类更抽象）

package cj;

public interface test09_interface2 {
   
    void walk();//都是public abstract的
}

//内部类

package cj;

public class test10 {
   
    public static void main(String[] args) {
   
        new test10_outer().test01();//匿名内部类（常配合接口使用）
        test10_outer obj=new test10_outer();
        obj.test02();//标准外部类
        obj.test03();//成员内部类
        obj.test04();//静态内部类
        test10_outer.Inner inner=obj.new Inner();
        inner.in();//成员内部类
    }
    //补充：同一package下多个类有main方法时，看java指令后面的那个类名，但javac是要全部编译的
    // （这就是为什么java指令后面的类不加.class后缀，因为同个.java文件可以有多个类）
}

package cj;

public class test10_outer {
   
    public void test01(){
   
        System.out.println("匿名内部类");
    }
    public void test02(){
   
        System.out.println("标准外部类");
    }
    public void test03(){
   
        class Inner{
   
            public void test03_1(){
   
                System.out.println("局部内部类");
            }
        }
        Inner tmp=new Inner();
        tmp.test03_1();
    }
    //静态类部类
    public void test04(){
   
        C c=new C();
        c.walk();
    }
    //成员内部类（类中建类）
    public class Inner{
   
        public void in(){
   
            System.out.println("成员内部类");
        }
    }
}
//静态类部类（类同级建类，不能再用public）
class C{
   
    public void walk() {
   
        System.out.println("静态类部类");
    }
}

//异常

package cj;

public class test11 {
   
    public static void main(String[] args) {
   
//        int a=1;
//        int b=0;
//        //先输入System.out.println(a/b);并选中再按ctrl+alt+T，再选第8个即可
//        try{
   
//            System.out.println(a/b);
//        }catch(ArithmeticException e){
   
//            System.out.println("分母不能为0");
//            e.printStackTrace();//打印错误信息
//        }catch(Exception e){
   
//            System.out.println("Exception");
//        }catch(Throwable e){//有Exception与Error两个子类
//            System.out.println("Throwable");
//        }finally{
   
//            System.out.println("finally");
//            System.exit(1);//退出程序
//        }
        //------------------------
        try{
   
            new test11().test(1,0);
        }catch(ArithmeticException e){
   
            e.printStackTrace();
        }
    }
    public void test(int a,int b) throws ArithmeticException{
   
        //throws是方法可能抛出异常的声明，可以省略
        if(b==0) {
   
            throw new ArithmeticException();//抛出一个异常，常用在方法中
        }
    }
}

GUI

//frame
import java.awt.*;
import java.awt.event.*;

public class java_test {
   
    public static void main(String[] args) {
   
        Frame frame=new Frame();
        frame.setSize(400,400);
        frame.setVisible(true);
        frame.addWindowListener(new WindowAdapter(){
   
            public void windowClosing(WindowEvent e){
   
                System.out.println("closing...");
                System.exit(0);
            }
        });
    }
}
//$1.class是匿名内部类的编译文件，内部类的会带上类的名称，例如：UserCtr$Box.class
/*
1.构造方法
Frame()：创建一个无标题的窗口，该窗口的默认布局为BorderLayout
Frame(String s)：创建一个标题为s的窗口，该窗口的默认布局为BorderLayout
2.常用方法
public void setSize(int width,int height)：设置窗口的宽width和高height
public void setBounds(int a,int b,int width,int height)：设置窗口出现在屏幕上的位置
public void setVisible(boolean b)：设置窗口在运行时是否可见；默认是不可见的
public void setResizable(boolean b)：设置窗口在运行时是否可调整大小；默认是可调整大小的
public void setTitle(String s)：设置窗口的标题为s
public void setMenuBar(MenuBar bar)：将窗体的菜单栏设置为指定的菜单栏bar
public void validate()：重整窗口的组件，使当调整窗口大小时，组件的位置也跟着变化
public void pack()：与validate()同意
public void dispose()：该方法是Frame类继承的方法，表示撤销当前窗口，并释放当前窗口所使用的资源
System.exit(0)：撤销所有的窗口
*/

MySQL

// 安装好mysql8.0
// 管理员身份打开命令行
// net start MySQL80
// net stop MySQL80
// 浏览器打开https://mvnrepository.com/artifact/mysql/mysql-connector-java
// 我的mysql是8.0.16，找到8.0.16点进去下载jar包
// 把jar包复制到工程目录下的lib文件夹里，在idea中右击lib，add as library，OK
package test01;
import java.sql.*;
public class mysql01 {
   
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
   
        //一、加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //二、连接数据库
        //String url = "jdbc:mysql://localhost:3306/shop?serverTimezone=Asia/Shanghai";
        String url = "jdbc:mysql://localhost:3306/shop?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=true";
        Connection connection = DriverManager.getConnection(url,"root","abccba");
        Statement statement = connection.createStatement();
        //三、查增改删
        ResultSet resultSet = statement.executeQuery("select * from account;");
        resultSet.afterLast();//移动到最后
        resultSet.previous();//移动到前一行
        resultSet.absolute(1);//移动到第一行（没有第零行）
        System.out.println("id="+resultSet.getObject("id"));
        resultSet.beforeFirst();//移动到最前
        while(resultSet.next()){
   
            System.out.println("id="+resultSet.getObject("id"));
            System.out.println("name="+resultSet.getObject("name"));
            System.out.println("money="+resultSet.getObject("money"));
        }
        int add_rows1 = statement.executeUpdate("insert into account values(3,'C',1000);");
        if(add_rows1>0) System.out.println("add succeed");
        int upd_rows2 = statement.executeUpdate("update account set money=2345 where name='C';");
        if(upd_rows2>0) System.out.println("upd succeed");
        int sub_rows3 = statement.executeUpdate("delete from account where name='C';");
        if(sub_rows3>0) System.out.println("sub succeed");
        //四、断开连接
        resultSet.close();
        statement.close();
        connection.close();
    }
    /*
    sql注入举例：
    select * from users where username='cj' and password='abc';
    上面的cj与abc是用户输入的字符串
    假如用户输入的是' or '1=1 及' or '1=1'，则上面的式子会变成
    select * from users where username='' or '1=1' and password='' or '1=1';
    这样就获得了所有的用户信息
    防止SQL注入：使用preparedStatement
    原理：把传过来的参数做字符，如有转义字符如‘会被直接转义
    */
}

/*
建表语句见关系型数据库学习笔记
sql语句事先测试好（如下）：

mysql> select * from account;
+----+------+----------+
| id | name | money    |
+----+------+----------+
|  1 | A    |  1500.00 |
|  2 | B    | 10500.00 |
+----+------+----------+
2 rows in set (0.00 sec)

mysql> insert into account values(3,'C',1000);
Query OK, 1 row affected (0.13 sec)

mysql> select * from account;
+----+------+----------+
| id | name | money    |
+----+------+----------+
|  1 | A    |  1500.00 |
|  2 | B    | 10500.00 |
|  3 | C    |  1000.00 |
+----+------+----------+
3 rows in set (0.00 sec)

mysql> update account set money=2345 where name='C';
Query OK, 1 row affected (0.36 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from account;
+----+------+----------+
| id | name | money    |
+----+------+----------+
|  1 | A    |  1500.00 |
|  2 | B    | 10500.00 |
|  3 | C    |  2345.00 |
+----+------+----------+
3 rows in set (0.00 sec)

mysql> delete from account where name='C';
Query OK, 1 row affected (0.38 sec)

mysql> select * from account;
+----+------+----------+
| id | name | money    |
+----+------+----------+
|  1 | A    |  1500.00 |
|  2 | B    | 10500.00 |
+----+------+----------+
2 rows in set (0.00 sec)
 */

/*
idea连接mysql
打开mysql命令行执行set global time_zone = '+8:00';
按右边的database，+，mysql，填用户名与密码，下载驱动，连接
最后选择要显示的数据库，可以看表格进行操作，或打开SQL控制台
*/

//连接池：DBCP,C3P0,Druid阿里巴巴

Tomcat

打开https://tomcat.apache.org/
点击Tomcat 9.0.45 Released处的Download链接
进入https://tomcat.apache.org/download-90.cgi下载相应版本
解压到D:\Tomcat目录下
进入bin目录执行cmd
终端运行startup
浏览器访问http://localhost:8080/成功
终端运行shutdown
浏览器访问http://localhost:8080/失败
备份主目录下conf/server.xml文件
改server.xml中的8080端口为8081
改server.xml中的域名Host name="localhost"为Host name=“www.cj2gjl.com”
备份C:\Windows\System32\drivers\etc\hosts文件
在hosts新增127.0.0.1 www.cj2gjl.com
在主目录webapps下创建hello_world文件夹，在夹内创建index.html，内容是hi
浏览器访问http://www.cj2gjl.com:8081/hello_world/

网络

package test01;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class test01 {
   
    public static void main(String[] args) {
   
        try{
   
            InetAddress inetAddress1=InetAddress.getByName("localhost");
            InetAddress inetAddress2=InetAddress.getByName("www.baidu.com");
            InetAddress inetAddress3=InetAddress.getLocalHost();
            System.out.println(inetAddress1);
            System.out.println(inetAddress2);
            System.out.println(inetAddress3);
            System.out.println(inetAddress2.getCanonicalHostName());
            System.out.println(inetAddress2.getHostAddress());
            System.out.println(inetAddress2.getHostName());
        }catch(UnknownHostException e){
   
            e.printStackTrace();
        }
    }
}
//netstat -ano

//TCP
package test02;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class test02_server {
   
    public static void main(String[] args) throws IOException {
   
        ServerSocket serverSocket=new ServerSocket(9999);       //打开端口
        Socket socket=serverSocket.accept();                         //开始侦听
        InputStream is=socket.getInputStream();                      //输入流
        ByteArrayOutputStream baos=new ByteArrayOutputStream();      
        byte[] buffer=new byte[1024];
        int len;
        while((len=is.read(buffer))!=-1){
   
            baos.write(buffer,0,len);
        }
        System.out.println(baos.toString());
        baos.close();
        is.close();
        socket.