速成java学习笔记

本学期答主还没上过java课，然后又有一些web前端开发的任务，所以索性加速学习了java，因答主有还可以的C/C++的基础，对面向过程和对象的语言都掌握尚可，所以很快结束了java学习，以下是一些学习过程中自己不熟悉的知识点的整理，持续更新ing 更新ing**
本次笔记内容大纲见如下目录，本次Java学习主要设计这些内容，后期有更多干货哦，每天不断更新，争取一周内结束Java的笔记汇总，希望大家多多支持，后续也会很多学习过程中的笔记，
你的三连就是我创作的动力，希望多多支持

java学习笔记

了解java
- 入门了解
- java特点
- 工作方式
- java技术平台
- 程序编译及运行
- 一些说明
- main()方法与命令行参数
- java基本语法
面向对象的“对象”
- 类和对象
对象的属性——成员变量详述
- 数据类型简介
- 成员变量
对象的行为——成员方法
- 封装与Getters、Setters方法
生命周期及作用域
- 生命周期
- 访问权限
- 包
Java常用类
- 基本数据类型类（静态成员）
- Math类（静态成员）
- Random类
- JOptionPane类（对话框）
- - **确认对话框**
  - 提示输入文本对话框
  - 显示信息对话框
  - OptionDialog对话框
- Vector类
- String类（重点）
面向对象中的继承
- 继承
- 所有类的父类(Object类)
- 子类与父类的进一步说明
- - this关键词
  - super关键词
  - 父类和子类的转换
面向对象中的多态
使用异常处理
基于Swing的图形界面编程
可视化程序的事件处理
Java多线程机制
综合实例（计算器的课程设计）
附录

了解java 入门了解

先附一下经典入门程序。

//文件名必须和public class 类名一致，保存Hello.java
public class Hello{
	//java main函数,不要漏了，形参内容表示命令行输入
	public static void main(String[] args){
	//输出打印符号，可以称为方法
		System.out.println("Hello World!");
	}
}

java特点

java特点：简单易学（确实很快，前提是最好掌握过其他语言）；面向对象编程思想；与平台无关；多线程（同时完成多个任务）；安全；动态。可以在java.sun.com查看相关信息

工作方式

用java编写首先写好代码（这肯定的嘛），保存为java文件，编译没有问题则会生产字节码文件，产生的字节码文件后缀为.class。

java技术平台

J2SE :java标准版，适用于开发桌面应用程序
J2ME：java微型版，嵌入式产品
J2EE：构建企业级服务应用
本次学习的是J2SE，安装java JDK1.6(开发环境，后附环境与常见的IDE)

程序编译及运行

刚写好的最全安装教程
https://blog.csdn.net/QAZJOU/article/details/120985406
常见工具为IDEA，此款专门为java开发准备，当然也可以用Eclipse(开源),需要JDK。IDE方法就不用介绍了，这里运用DOS环境编译运行。
以Windows 10为例，按win+r，输入cmd，进入MS-DOS窗口。输入保存java文件的位置
有时间出个cmd教程，这里就直接输出好了（找了半天资料才知道是classpath）没设置对，实在不行可以按照我写的直接进入。这里先用cd进入相应的文件夹，然后javac进行编译，然后java 文件名就可以输出了。

一些说明

class 很重要，定义类的关键词
class 前面是访问修饰符，有时可以写public，一个程序只能有一个公共类（public）

main()方法与命令行参数

main是java程序执行的入口，写在公共类中，严格按照格式来写。main方法形参String [] args，命令行参数，这是字符串数组，可以接收程序的同时给用户一些初始数据。下面以这个代码进行演示。

public class Main{
    public static void main(String[] args){
        System.out.println("Onput:"+args[0]);
    }
}

java Main 后面记得输入字符串

java基本语法

这里就不细讲了，和C/C++类似，需要注意的点如下

//打印输出
System.out.println("Hello");
//从屏幕输入，先导入包util,然后创建Scanner类
impot java.util.Scanner
Scanner reader=new Scanner();
int x=reader.nextInt();//输入int型
String s=reader.next();//输入String型
//数组2种定义方法
int[] a;
int a[];
//方法函数建立，一般按照这样的格式
public static int sum(int x)
//if,switch,while同C语言，这里不赘述了

面向对象的“对象” 类和对象

这里以学生对象创建，并进行讲解，可以发现的是和C++很类似。

class Student{
    String name;
    int score;
    void setItem(String s,int m){
        name=s;
        score=m;
    }
    void showInfo(){
        System.out.println("Name:"+name+"nScore:"+score);
    }
}

public class Main{
    public static void main(String[] args){
        Student a;
        a=new Student();//类似申请内存空间的意思，这样对象才真正被创建，而C++在创建类的时候就已经完成了这一步
        a.setItem("Jack", 98);
        a.showInfo();
    }
}

定义类的格式
[修饰符] class 类名 [extends 父类名]{接口列表}

对象的属性——成员变量详述数据类型简介

Java语言变量只声明不赋初值，会自动附默认值【区别于C语言】
注意描述float型要在数字后面加F或f；Java字符采用UNICODE编码，一个字符2个字节【C++只要1个字节】；都可以进行强制转换。
数组使用先声明，构造，赋初值【这里可以联系C语言指针转换数组类型】,一维数组[]必须为空，进行new运算时必须指明[]内大小

int siz=20;
int[] array=new int[size];
int[] a={1,2,3,4,5};

数组的length属性，获取数组长度，注意不需要加括号。
以一个简单题入手，定义一个字符型数组，初始化赋值。提示用户输入一个整数，按位置查找改字符并输出。

import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        Scanner reader;
        reader=new Scanner(System.in);
        char c[]={'c','b','a','g','m'};
        int m;
        m=reader.nextInt();
        if(m>=1&&m<=c.length){
            System.out.println(c[m-1]);
        }
    }
}

下面再以一个学生信息输入输出为例（引用部分上端代码）。

import java.util.Scanner;
class Student{
    String name;
    int score;
    void setItem(String s,int m){
        name=s;
        score=m;
    }
    void showInfo(){
        System.out.println("Name:"+name+"nScore:"+score);
    }
}

public class Main{
    public static void main(String[] args){
        Scanner reader=new Scanner(System.in);
        String s=reader.next();
        int m=reader.nextInt();
        Student a;
        a=new Student();//类似申请内存空间的意思，这样对象才真正被创建，而C++在创建类的时候就已经完成了这一步
        a.setItem(s,m);
        a.showInfo();
    }
}

这里稍微介绍一下类的对象数组创建，以Student类为例

int N=5;//假设为5个
Student a[];
a=new Student[N];//创建数组
for(int i=0;i 
数组引用赋值（值传值） 
成员变量 
记住：不允许通过对象直接操作成员变量，要在类的内部定义相应的方法对数据进行存储和访问。（这和C++是不是很类似的呢？） 
对象的行为——成员方法 
方法定义：返回值类型 方法名称(参数列表){
 语句；
 }
 调用直接方法名（实参）
 和C++类似，不细讲了。
 注意：成员方法相互直接访问(调用);static修饰过的静态成员可相互访问，其他成员不能访问static成员。
 构造方法。 
//重载
class Box{
	double width;
	double heigh;
	Box(){
	//无参构造方法
	}
	Box(double w,double h){
		width=w;
		heigh=h;
		//和前言讲的set方法类似
	}
	
}
 
定义类时候没有写过构造方法，创建对象也能够顺利完成，因为Java规定：如果在一个类里面找不到构造方法，Java就为这个类添加一个默认方法。 
封装与Getters、Setters方法 
getters访问器方法：直接返回要访问的变量。
 setters访问器方法：修改成员变量。 
生命周期及作用域 
生命周期 
对象的生命周期指的是对象从产生到消亡这一过程。Java三个阶段：创建、使用、清除。
 当对象不再被使用，“生存期”结束。Java会自动回收不再引用的对象，即自动清除对象。
 作用域在花括号内。 
访问权限 
可见性 说明
public 所以类可以访问
protected 子类和同一个包的其他类可以访问
默认 同一个包中的类能够访问
private 只有定义该变量的类可以用，其余类无法访问
从高到低：publicprotected默认private
 公有成员操作方便但同时把数据暴露了。在OOP思想中，封装类要避免让外界直接接触到内部的成员变量。
 访问私有成员要用接口访问，对其进行间接访问。
 比较字符串不用==，使用boolean equals(String s)方法，例如String str1=“hello”,str2=“hi”;str1.equals(str2)返回false。
 关键字static修饰的叫静态成员，静态变量和所有对象都关联，可直接操作。 
class Person{
	String name;//普通成员变量
	static int count;
	//初始化直接new 类（实参）
	Person(String s){
		name=s;
		count++;
	}
}

public class Main{
	public static void main(String[] args){
		Person a=new Person("Jack");
		System.out.println(a.count);
 
类的静态成员方法只能调用其他静态方法 
包 
包是类的容器，是Java语言管理的一个机制，可以理解是文件夹。
 每个类都有一个特定的包，例如System类，String类等就在java.lang包里面（由编译器自动引入）。除了java提供包以外，用户可以自定义声明管理包 
package pkg;
//A在pkg包里面，必须作为第一语句
public class A{}
 
包里面可以再有包
 package pkg.com
 使用包，需要加关键词import，包与包之间用.连接。 
Java常用类 
基本数据类型类（静态成员） 
Integer.MAX_VALUE=（返回最大整数）
 Integer(int value)
 to_String(Integer)，转换字符串
 pareInt(String s) 
Math类（静态成员） 
Math.E(自然底数) Math.PI(圆周率)
 常用方法abs(),pow(),sqrt(),random(),log()
 注意Math.random()返回的是[0,1)的数，所以输入[5,50]的数，方法是Math.random()*46+5。 
Random类 
rand.nextInt(46)+5,输入【5，50】的数，对比上式。
 rand.nextInt() 随机产生一个数
 rand.nextInt(int n) 产生0-n（不含n）的随机整数。 
JOptionPane类（对话框） 
写了那么的C/C++，终于看到了可以自定义对话框，并进行弹出了，看起来java有很多功能的，不过到这里关键字就特别长，可以使用Eclipse或者Vscode或IDEA进行智能化输入，不过其实都是英文罢了，顺便练练英语也是可以的 哈。
 第一步当然是引入包了 
确认对话框 
格式说明
 int res=JOptionPane.showConfirmDialog(parentComponent, message, title, optionType) 
import javax.swing.JOptionPane;
public class Main{
    public static void main(String[] args){
        int res=JOptionPane.show/confirm/iDialog(null,"/confirm/i","Title",JOptionPane.YES_NO_CANCEL_OPTION);
        if(res==JOptionPane.YES_OPTION)
            System.out.println("YES");
    }
}
 

 这里对一些参数做说明。
 第一个参数null表示默认的父窗口，在屏幕中间显示，第二个参数是对话框显示的文字，第三个参数是对话框标题栏的字符串，第四个是显示的按钮选项。 
提示输入文本对话框 
InputDialog 
import javax.swing.JOptionPane;
public class Main{
    public static void main(String[] args){
        String s=JOptionPane.showInputDialog("Input:");
        System.out.println(s);
    }
}

 
 
import javax.swing.JOptionPane;
public class Main{
    public static void main(String[] args){
        Object[]op={"OK","NO","HELP"};
        Object res=JOptionPane.showInputDialog(null, "mess","TITLE",JOptionPane.INFORMATION_MESSAGE, null, op, op[0]);
        
    }
}

 
 
显示信息对话框 
JOptionPane.showMessageDialog(null,
							"信息对话框"
							"对话框标题"
							JOptionPane.ERROR_MESSAGE);
 
OptionDialog对话框 
import javax.swing.JOptionPane;
public class Main{
    public static void main(String[] args){
        String[]op={"OK","NO","HELP"};
        int res=JOptionPane.showOptionDialog(null, "mess","TITLE",JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, op, op[0]);
        if(res==0) System.out.println("OK");
        else if(res==1) System.out.println("NO");
        else if(res==2) System.out.println("HELP");

    }
}

 

 可以发现的是，4种标准框使用的静态方法showXXXDialog()进行显示，有时候可少写部分参数而使用参数。 
Vector类 
引入包 import java.util.Vector
 允许不同类型的元素共存，长度可变的数组(动态申请)，方法和C++有些不太一样。
 构造方法 
public Vector()//自动分配10个空间
public Vector(int cap)//cap为容量
public Vector(int cap,int inc)//inc扩充的幅度
 
常用的方法 
void addElement(Object O)//元素插入到末尾
int capacity()//容量
boolean contains(Object O)//是否有元素
String toString()
void setSize(int size)
void removeAllelements()//删除所有元素
void insertElementAt(Object O,int index)
 
String类（重点） 
字符串被定义类，在java.lang中，可直接使用。
 String类对象是对字符串常量的引用。
 构造方法 
public String()//创建一个空字符
public String(String value)
public String(char value[])
public String(char value[],int off,int count)
 
常用方法 
int length()
String concat(String str)
boolean equals(Object O)

 
StringBuffer类描述可变字符串 
面向对象中的继承 
继承 
继承是面向对象编程思想最重要的组成部分之一，是Java程序设计的一项核心技术。继承使众多类有了层次关系，下层的类能够具备上层类的非私有属性和方法。
 继承关系，上层的类即被继承的类叫父类或超类，下层的类叫子类，子类自动继承父类的所有非私有成员变量和成员方法。
 [修饰符] class 子类名 extends 父类名{
 //定义成员变量
 }
 继承要先准备好父类，有了父类定义子类，则子类继承父类特征。 
public class Main{
    public static void main(String[] args){
        Student a=new Student();
        a.setItem("Make",'N', 101, 87.5);
        a.show();
    }
}

class  Person{
    String name;
    char sex;

    void show(){
        System.out.println("Name:n"+name+"nSex:n"+sex);
    }
}

class Student extends Person{
    int num;
    double score;

    void setItem(String na,char s,int n,double sco){
        name=na;
        sex=s;
        num=n;
        score=sco;
    }
    void showStud(){
        System.out.println("Name:"+name+"Score:"+score);
    }
}
 
Java 可以实现多重继承，即类的继承关系是层层传递下去。
 继承避免了重复的代码程序。 
所有类的父类(Object类) 
Object类存在于java.lang，所有类都是从Object类层层继承而来。
 子类可以重写继承过来的父类方法的方法中，这叫做方法的覆盖。子类方法覆盖了父类中的方法，即子类中的成员方法隐藏父类中原有的同名方法，对其进行重定义。
 方法覆盖：子类对父类的非静态方法可以实现方法的覆盖，静态方法不能实现方法重载。 
子类与父类的进一步说明 
Java总先调用父类的构造方法，然后才调用子类自己的构造方法。系统自动调用：子类无主动调用，java自动先调用父类无参的构造方法，调用子类的构造方法。 
public class Main{
    public static void main(String[] args){
        SubClass a=new SubClass(20,10);
        a.printInfo();
    }
}

class SuperClass{
    int a;
    SuperClass(){
        System.out.println("NONE");
    }
    void printInfo(){
        System.out.println("a="+a);
    }
}

class SubClass extends SuperClass{
    int b;
    SubClass(int x,int y){
        a=x;
        b=y;
        System.out.println("被调用");
    }
    void printInfo(){
        System.out.println("a="+a+" b="+b);
    }
}


 
this关键词 
this对当前对象的一个引用，代表当前对象自身。在一个对象的内部，如果想得到对象的引用，要使用this。（这不就是C++吗，显式引用哦） 
class Rect{
	double width;
	double length;
	//参数名称和成员变量名称一样，setItem会被覆盖，使用this可以避免
	void setItem(double width,double length){
		this.width=width;//将参数width存至成员变量width
		whis.length=length;
	}
}
 
class Person{
	String name;
	int age;
	Person(String n){
		name=n;
	}
	Person(String n,int a){
		this(n);//调用一个参数的构造方法
		age=a;
	}
}
 
super关键词 
super是对父类的一个引用，在一个对象的内部，如果想到对父类的引用，要使用super。
 子类引用父类的成员格式
 super.变量名, super.方法名（实参） 
class SuperClass{
	int value;
	SuperClass(int x){
		value=x;
		System.out.println("调用"）;
	}
	void printInfo(){
		System.out.println(value);
	}
}

class SubClass extends SuperClass{
	int value;//同名成员变量，并不冲突也不覆盖
	SubClass(int x,int y){
		super(x);//主动调用父类构造方法
		value=y;//变量赋值
	}
	//如果要输出父类value,需要super.value指明g6
	void printfInfo(){
		System.out.println(value);
	}
}

public class Main{
	public void static main(String[] args){
		SubClass subC=new SubClass(10,20);//创建子类对象
		subC.printInfo();
	}
}
 
父类和子类的转换 
public class Main{
    public static void main(String[] args){
        Animal pet;//声明对象
        pet =new Dog();//父类对象pet指向子类Dog的一个实体
        pet.sleep();
        pet.cry();
        pet=new Cat();
        //pet.play();不可以直接调用
        Cat d=(Cat) pet;
        d.play();
    }
}

class Animal{
    void sleep(){
        System.out.println("Sleep");
    }
    void cry(){
        System.out.println("Cry");
    }
}

class Dog extends Animal{
    void eat(){
        System.out.println("eat");
    }
    void cry(){
        System.out.println("汪汪");
    }
}

class Cat extends Animal{
    void play(){
        System.out.println("Play");
    }
}


 
面向对象中的多态 
使用异常处理 
基于Swing的图形界面编程 
可视化程序的事件处理 
Java多线程机制 
综合实例（计算器的课程设计） 
附录

可见性	说明
public	所以类可以访问
protected	子类和同一个包的其他类可以访问
默认	同一个包中的类能够访问
private	只有定义该变量的类可以用，其余类无法访问

速成java学习笔记

Java相关栏目本月热门文章