java基础知识整理

最新推荐文章于 2024-03-04 23:23:49 发布

Sandra feng

最新推荐文章于 2024-03-04 23:23:49 发布

阅读量270

点赞数

分类专栏：技能学习

本文链接：https://blog.csdn.net/Sandra_feng/article/details/111055048

版权

技能学习专栏收录该内容

14 篇文章 0 订阅

订阅专栏

java

一、java基础

1，跨平台原理

平台：一般指windows 系统，linux系统，mac系统

针对不同的操作系统安装不同的java虚拟机（JVM）。JVM在几个系统中相当于翻译的作用。

2，JDK,JRE,JVM

JDK是开发工具包，包括编译工具和运行工具，JRE是java程序运行环境，JVM是可以保证java程序的跨平台。

3，常见的DOS命令

windows+R打开窗口cmd打开命令提示符窗口

操作	说明
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd目录	进入单级目录。cd itheima
cd …	回退到上一级目录。
cd目录1目录2…	进入多级目录。cd itheimalavaSE
cd l	回退到盘符目录。
cls	清屏。
exit	退出命令提示符窗口。

4、基础语法

关键字：字母全部是小写比如public 、class 、static……

常量：“字符串常量”，‘字符常量’，布尔常量，整数，小数，空（NULL）

*5、数据类型

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫位( bit )”，我们又称之为"比特位”，通常用小写的字母"b"表示。而计算机中最基本的存储单元叫"字节 ( byte )"通常用大写字母”"B"表示，字节是由连续的8个位组成。

在这里插入图片描述

*6、标识符

数字、字母、下划线和美元符$组成

不以数字开头，不是关键字、区分大小写

小驼峰命名法：方法、变量

大驼峰命名法：类

7、类型转换

自动类型转换：数据类型范围小的数据或变量赋值给数据类型范围大的变量

double b=10; //double>int

在这里插入图片描述

强制类型转换

格式：目标数据类型变量名=（目标数据类型）变量名或者数值

double b=1.23;
int a=(int)b;

char类型转换成int结果是ASCII码表里面的对应数字，a对应97

整数默认是int类型，byte.short和char类型数据参与运算均会自动转换为int类型。

8、运算符

字符串的"+"是字符串连接符：“asdfg”+9999的结果是asdfg9999

三元运算符：关系表达式？表达式1：表达式2;

9、数据输入

1、导包：Scanner类在util包下所以，先导入util包

import java.util.Scanner;

创建Scanner对象

Scanner scan=new Scanner(system.in);

接收数据

int i=scan.nextInt();

10、IDEA

第一步：创建一个project

第二步：创建一个新模块（Module)，在模块下创建一个包

第三步：在包里创建一个类

第四步：在这个类中编写代码，然后执行程序

IDE快捷键：

注释：单行注释——ctrl+/再按一次就是取消。多行注释——ctrl+shift+/再按一次就是取消

格式化：ctrl+alt+L

内容辅助键：ctrl+alt+空格键（根据内容提示，补全代码）

11、数组

int[] arr;//推荐使用
int arr[];

//数组初始化

//动态初始化
int[] arr=new int[3];

//静态初始化
int[] arr=new int[]{1,2,3};
int[] arr={1,2,3};

java内存：栈内存存储局部变量，堆内存存储new出来的东西

数组操作：索引越界，空指针异常

数组遍历：通过arr.length来替代数组长度

12、方法

先方法定义再方法调用

//无参方法定义
public static void method(){
    //方法体
}

//方法调用
method();

//有参方法定义
public static void method(int num1,int num2){
    //方法体
}
//方法调用
method(5,6);

形参：方法定义中的参数

实参：方法调用中的参数

//带返回值方法的调用：
public static int getMax(int a,int b){
    ……
    return max;
}

方法重载

同一个类中，方法名相同，参数列表不同，JVM会通过所传参数的不同判断用的方法

13、面向对象

**类的定义：**现实生活中一类具有共同属性和行为的事物抽象，确定对象会有属性和行为

**类的组成：**属性和行为

属性：在类中通过成员变量来体现（类方法外的变量）

行为：在类通过成员变量来体现（即去掉static关键字）

public class 类名{
    //成员变量
    String phone;
    int price;
    //成员方法
    public void call(){
        System.out.println("打电话");
    }
}

**对象的使用：**格式——类名对象名 = new 类名（）；

Phone p=new Phone();//对象创建
p.phone//使用对象的成员变量
p.call();//使用对象成员方法

public class Student {
    String name;
    int age;
    public void study(){
        System.out.println(name+" "+age+"好好学习！");
    }
}

public class StuDemo {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.name="孔祥源";
        stu.age=21;
        stu.study();
    }
}

14、private

保护成员不被别的类使用，被private修饰的成员变量只能在本类中访问。

如果想要被其他类访问提供相应的方法获取或者设置成员变量的值。

public class Student {
    String name;
    private int age;      //private防止年龄数据输入出错，提高数据安全性
    public void setAge(int a){
        if(a<0||a>150)
        {
            System.out.println("你给我的信息有误！");
        }
        else{
            age=a;
        }
    }
    public int getAge(){
        return age;
    }
    public void study(){
        System.out.println(name+" "+age+"好好学习！");
    }
}

public class StuDemo {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.name="孔祥源";
        stu.setAge(21);
        stu.study();
    }
}

15、this

区别成员变量和局部变量，可把上面的代码用this修改一下

public class Student {
    String name;
    private int age;      //private防止年龄数据输入出错，提高数据安全性
    public void setAge(int age){
        if(age<0||age>150)
        {
            System.out.println("你给我的信息有误！");
        }
        else{
            this.age=age;
        }
    }
    public int getAge(){
        return age;
    }
    public void study(){
        System.out.println(name+" "+age+"好好学习！");
    }
}

16、封装

面对对象的三大特征之一；

封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
封装好处
通过方法来控制成员变量的操作，提高了代码的安全性把代码用方法进行封装，提高了代码的复用性

17、构造方法

/*
类
构造方法：
作用：创建对象，功能：完成功能初始化
格式：
修饰符 类名 （参数）{

}
修饰符一般用public
*/
public class Student{
    private String name;
    private int age;
    
    //无参构造方法（当new一个对象后自动调用
    public Student(){
        System.out.println("调用了无参构造方法");
    }
    public void show(){
        System.out.println(name+","+age);
    }
}

//有参构造方法
public class Student{
    private String name;
    private int age;
    
    
    public Student(String name){//在外面new的时候要传参数;Student stu=new Student(孔祥源);
        this.name=name;
    }
    public void show(){
        System.out.println(name+","+age);
    }
}

package test1;

public class Student {
    private String name;
    private int age;
    public Student(){//无参构造方法

    }

    public Student(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 study(){
        System.out.println(name+","+age);
    }

}

public class StudentDemo {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("赵丽颖");
        s1.setAge(31);
        s1.study();

        Student s2=new Student("冯绍峰",41);
        s2.study();
    }
}
/*运行结果：
赵丽颖,31
冯绍峰,41*/

18、API

Application Programming Interface:应用程序接口

Math:软件包java.lang 包括数字基本运算的方法

Math.abs(-88);//绝对值
Math.ceil(12.34);//向上取整得13.0
Math.floor(12.34);//向下取整12.0
Math.max(66,88);
Math.pow(2.0,3.0);//参数是double型
Math.randow();//double型，【0.0，1.0）
((int)Math.randow()*100)//[0.0，100）整型

System:软件包java.lang

System.exit(0)//0表示正常退出，非0是异常
System.currentTimeMillis()//返回时间以毫秒为单位,可用于计算运行时间

19、继承

格式：
public class 子类名 extends 父类名(){

}

super：this是访问本类的成员变量/方法，super是访问父类成员变量/方法，这两个还可以访问构造方法和成员方法。

子类中所有构造方法默认都会访问父类的无参构造方法

父类中没有无参构造方法只有有参构造方法时，子类构造方法中访问前加super(参数)从而访问父类的有参构造方法。

方法重写：子类中有和父类一样的方法声明

public class Phone{
    public void call(String name){
        System.out.println(name+"打电话");
    }
}
@Override//注解，检查重写方法的正确性
public class NewPhone{
    public void call(String name){
        System.out.println("视频");
        super.call(name);//调用父类的call方法功能
    }
}

父类中的私有内容子类不可重写。子类方法访问权限不能比父类更低

一个类不能同时继承多个类。可以多层继承。

20、多态

同一个对象，在不同时刻表现出来的不同形态。

前提：有继承/实现关系，有方法重写，有父类引向子类对象

public class Animal{
    public void eat(){
        System.out.println("动物吃东西");
    }
}
public class Cat extends Animal{
     public void eat(){
        System.out.println("猫吃鱼");
    }
}

public calss AnimalDemo{//测试类
    public static void main(String[] args){
        Animal a=new Cat();//父类引用指向子类（多态）虽然对象是猫但是我们用的是Animal所以能用Animal成员不能用cat的
        
    }
}

多态转型

向上转型：从子到父，Animal a=new Cat();//向上转型，编译看左边，运行看右边

向下转型：从父到子，Cat c= (Cat)a;//

21、抽象类

一个没有方法体的方法被定义为抽象方法，如果类中有抽象方法，那么就叫做抽象类。抽象类不能 new方法实例化的类。对象是类的实例化，里面没有方法体的方法被称为抽象方法，抽象方法一定会被子类重写。

抽象方法和抽象类必须用 abstract 修饰

public abstract calss 类名{}
pubic abstract void eat();

22、接口

接口被关键字interface修饰

public interface 接口名{}

类实现接口时用implements表示

public class 类名 implements 接口名{}

接口不能实例化

接口的子类，要么重写接口中的所有抽象方法，要么子类也是抽象类

*接口的成员特点成员变量只能是常量默认修饰符：public static final 没有构造方法，成员方法只能是抽象方法

比如猫学会跳高的例子

public abstract class Animal {//抽象类
    private String name;
    private int age;
    public Animal(){

    }
    public Animal(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 abstract void eat();//抽象方法
}

public interface Jumping {//接口类
    public abstract void jump();
}

public class Cat extends Animal implements Jumping {//猫类
    public Cat(){

    }
    public Cat(String name,int age){

    }

    @Override
    public void eat() {
        System.out.println("cat eat fish");
    }

    @Override
    public void jump() {
        System.out.println("cat can jump");
    }
}

public class Demo {//测试类
    public static void main(String[] args) {
        Cat c= new Cat("加菲",5);//第一种方法
        c.eat();
        c.jump();
        Animal a=new Cat("加菲",5);
        a.eat();
        Jumping b=new Cat();
        b.jump();
    }
}

*类和接口的关系：

类与类的关系：继承关系

类与接口关系：实现关系，可以在继承一个类的同时实现多个接口

接口与接口的关系：继承关系，可以单继承，也可以多继承

*抽象类和接口的区别

成员区别:抽象类有变量、常量、抽象方法也有非抽象方法。接口有常量和抽象方法

关系区别，设计理念区别（抽象类是对类抽象，包括属性和行为，接口是对行为抽象，主要是行为）

//参数传递
public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

public class CatOperator {
    public void useCat(Cat c){
        c.eat();
    }
    public Cat getCat(){
        Cat c=new Cat();
        return c;
    }
}
public class CatDemo {
    public static void main(String[] args) {
        CatOperator co=new CatOperator();
        Cat c=new Cat();
        co.useCat(c);
        Cat c2=co.getCat();//代替new Cat
        c2.eat();
    }
}

21、内部类

在类里面定义一个类（成员内部类、局部内部类）

public class Outer{//外部类
    public class Inter{//内部类
        
    }
}

内部类可以访问内部类成员，包括私有，外部类访问内部类要创建对象。

成员内部类，外界创建对象和使用

Outer.Inter a=new Outer().new.Inter();//不针对私有

public class Outer{//外部类
    public class Inter{//内部类
        public static void show(){
            
        }
    }
   public static void method(){
       Inter i= new Inter();
       i.show();
   }
}
//在外部间接调用
Outer o= new Outer();
o.method();

局部内部类，定义在方法内部。需在方法内部创建对象并使用，可以直接访问外部类的成员，也可以访问方法中的局部变量。

public class Outer {
    private int s = 100;
    public void f(final int k){
       final int s = 200;
       class Inner{ //定义在方法内部
       int s = 300;//可以定义与外部类同名的变量
        //static int m = 20;//不可以定义静态变
}

匿名内部类

存在一个类或者接口、抽象类,局部内部类的一种格式

格式

new 类名/接口(){
   重写方法；
};
new Inter() {
    public void show(){
    
    }
};

public class Outer {
    public void method(){
       /* new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };这一部分相当于定义了一个对象*/
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();//对象调方法
    }

}
public interface Inter {
    void show();
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }

}

例子：

public interface Jumping {
   public void jump();
}
public class JumppingDemo {
    public static void main(String[] args) {
        JumppingOpeate io=new JumppingOpeate();
        io.method(new Jumping() {
            @Override
            public void jump() {
                System.out.println("猫会跳高");
            }
        });
    }
}
public class JumppingOpeate {
    public void method(Jumping j){
        j.jump();
    }
}

22、多线程

进程是程序的一次执行，是系统资源分配和调度的基本单位。

线程是进程的单个顺序控制流，是一条执行路径。

实现线程方式一：继承Thread类

●实现步骤
。定义一个类MyThread继承Thread类
。在MyThread类中重写run(方法
。创建MyThread类的对象
。启动线程

public class MyThread extends Thread {
eoverride
public void run(){
for(int 1=0; 1<100; 1++) {
system. out. pr int1n(i);
}
}
public class MyThreadDemo {
pub1ic static void main(string[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
//my1. run();
//my2. run();
//void startO导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start();
my2.start();
}
}

线程调度：分时调度模型，抢占式调度模型

实现线程方式二：实现Runnable接口

●实现步骤
。定义一个类MyRunnable实现Runnable接口
。在MyRunnable类中重写run(方法
。创建MyRunnable类的对象
。创建Thread类的对象，把MyRunnable对象作为构造方法的参数
。启动线程

public class MyRunnab1e imp1ements Runnable {
@Override
pub1ic void run() {
for(int 1=0; 1<100; 1++) {
system. out. pr int1n(Thread. currentThread(). getName()+":"+1);
}
}
public class MyRunnab1eDemo {
pub1ic static void main(String[] args) {
//创建1yRunnab1e类的对象
MyRunnab1e my = new MyRunnab1e() ;
//创建Thread类的对象，把yRunnab1e对象作为构造方法的参数
//Thread(Runnable target)
//Thread t1 = new Thread(my);
//Thread t2 = new Thread(my);
//Thread(Runnable target, String name)
Thread t1 = new Thread(my,"高铁");
Thread t2 = new Thread(my,""飞6机");
//启动线程
t1. start();
t2. start();
}

23、网络编程

●IP地址
要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
●端口
网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序,那么在网络通信时，如何区分这些应用程序呢?如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识
●协议
通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车-定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统-规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议。

//InetAddrees:网络协议地址
//Inetaddress address = Inetaddr ess. getByName("itheimal" ) ;
InetAddress address = Inetaddress. getByName(" 192.168.1.66");//主机名称可以是机器名称，也可以是IP地址

UDP通信程序

UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频。视频和普通数据的传输

●发送数据的步骤
。创建发送端的Socket对象(DatagramSocket)

。创建数据，并把数据打包

。调用DatagramSocket对象的方法发送数据

。关闭发送端

public class SendDemo {
pub1ic static void main(string[] args) throws IOException {
//创建发送端的socket对象(Datagr amsocket)
// Datagr amSocketO构造数据报套接字并将其绑定到本地主机上的任何可用端口
Datagramsocket ds = new Datagr amsocketO();
//创建数据，并把数据打包
//DatagramPacket(byte[] buf, int length， InetAddress address, int port)
//构造一个数据包， 发送长度为1ength的数据包到指定主机上的指定端口号。
byte[] bys = "he1lo,udp ,我来了" . getBytes();
DatagramPacket dp = new
Datagr ampacket(bys，bys.length, InetAddress . getByName("192.168.1.66") ,10086);
//调用batagramsocket对象的方法发送数据
//void send(Datagrampacket p)从此套接字发送数据报包
ds. send(dp);
//关闭发送端
//void closeO关闭此数据报套接字
ds. close();
}

TCP通信程序

。传输控制协议(Transmission Control Protocol)
。TCP协议是面向连接的通信协议,即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”
。三次握手: TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
第一次握手,客户端向服务器端发出连接请求，等待服务器确认
第二次握手，.服务器端向客户端回送一个响应，通知客户端收到了连接请求
第三次握手，客户端再次向服务器端发送确认信息，确认连接
。完成三次握手,连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，
TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

发送端（客户端）

pub1ic class ClientDemo {
pub1ic static void main(string[] args) throws IOException {
//创建客户端的Socket对象(Socket)
//Socket(string host, int port)创建流套接字并将其连接到指定主机上的指定端口号
Socket s = new Socket("192. 168.1.66" ,10000) ;
//获取输出流，写数据
//0utputstream getoutputstreamO 返回此套接字的输出流
outputstream 05 = s. getoutputstream();
os. write("he11o, tcp ,我来了". getBytes());
//释放资源
s.close();

接收端（服务端）

pub1ic Class ServerDemo {
pub1ic static void main(string[] args) throws I0Exception {
//创建服务器端的Socket对象(Serversocket)
//Serversocket(int port)创建绑定到指定端口的服务器套接字
ServerSocket ss = new ServerSocket(10000);
//Socket accept()侦听要连接到此套接字并接受它
Socket s = ss. accept();
//获取输入流，读数据，并把数据显示在控制台
Inputstream is = s. getInputstream() ;
byte[] bys = new byte[1024];
int 1en = is. read(bys);
String data = new String(bys,o,1en);
System. out. print1n("数据是:”+ data);
//释放资源
s.close();
ss.close();
}
}

lass ClientDemo {
pub1ic static void main(string[] args) throws IOException {
//创建客户端的Socket对象(Socket)
//Socket(string host, int port)创建流套接字并将其连接到指定主机上的指定端口号
Socket s = new Socket(“192. 168.1.66” ,10000) ;
//获取输出流，写数据
//0utputstream getoutputstreamO 返回此套接字的输出流
outputstream 05 = s. getoutputstream();
os. write(“he11o, tcp ,我来了”. getBytes());
//释放资源
s.close();


接收端（服务端）

```java
pub1ic Class ServerDemo {
pub1ic static void main(string[] args) throws I0Exception {
//创建服务器端的Socket对象(Serversocket)
//Serversocket(int port)创建绑定到指定端口的服务器套接字
ServerSocket ss = new ServerSocket(10000);
//Socket accept()侦听要连接到此套接字并接受它
Socket s = ss. accept();
//获取输入流，读数据，并把数据显示在控制台
Inputstream is = s. getInputstream() ;
byte[] bys = new byte[1024];
int 1en = is. read(bys);
String data = new String(bys,o,1en);
System. out. print1n("数据是:”+ data);
//释放资源
s.close();
ss.close();
}
}

Sandra feng

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
java基础知识整理

java一、java基础1，跨平台原理平台：一般指windows 系统，linux系统，mac系统针对不同的操作系统安装不同的java虚拟机（JVM）。JVM在几个系统中相当于翻译的作用。2，JDK,JRE,JVMJDK是开发工具包，包括编译工具和运行工具，JRE是java程序运行环境，JVM是可以保证java程序的跨平台。3，常见的DOS命令windows+R打开窗口cmd打开命令提示符窗口操作说明盘符名称:盘符切换。E:回车，表示切换到E盘。dir查看当前
复制链接

扫一扫