想学的来速成java学习笔记

本学期答主还没上过java课，然后又有一些web前端开发的任务，所以索性加速学习了java，因答主有还可以的C/C++的基础，对面向过程和对象的语言都掌握尚可，所以很快结束了java学习，以下是一些学习过程中自己不熟悉的知识点的整理，持续更新ing 更新ing**
本次笔记内容大纲见如下目录，本次Java学习主要设计这些内容，后期有更多干货哦，每天不断更新，争取一周内结束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<N;i++){
	a[i]=new Student();//为每个数组元素创建对象
}

数组引用赋值（值传值）

成员变量

记住：不允许通过对象直接操作成员变量，要在类的内部定义相应的方法对数据进行存储和访问。（这和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	只有定义该变量的类可以用，其余类无法访问

从高到低：public\protected\默认\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.showConfirmDialog(null,"Confirm","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");
    }
}

子类通过extends继承父类，继承非私有，具有传递性，可以被子类覆盖掉，但成员变量不能被覆盖。

面向对象中的多态

运行时多态：在父类中定义一个方法，而在子类中重载或覆盖这些方法，运行时由系统被引用对象的类型或调用时的实际参数决定实际调用。

方法重载和方法覆盖

方法重载和方法覆盖（父类）是实现多态的机制。
重载条件：
方法名相同；方法参数表不相同；放回类型可以不同；修饰符可以不同；可以在一个类内部进行，也可以在子类对父类的方法重载。
覆盖条件：
方法名称和参数列表与覆盖方法相同；返回类型相同；不能抛出比覆盖方法更多的异常

final关键词

fina关键词可以修饰类、方法和局部变量，修饰过的类叫最终类，修饰过的相当于常量。

//继承关系中必须处于最末端，不能被继承，不能有子类（String,Math类）
final  class A{

}

public class A{
	public final void fun(){
	//子类不能覆盖父类的方法。
	//防止了子类对父类的一些方法的篡改，保证了程序安全。
	}
}

final double P=3.14//常量

抽象类和抽象方法

abstract 修饰类和方法。

abstract class A{}//抽象类，意味不能创建对象，专门让子类继承的

abstract void fun()//抽象方法，没有方法体，一定要被子类进行方法覆盖才能使用。如果有抽象方法则必须是抽象类。

public class Main{
    public static void main(String[] args){
        Rectangle rect=new Rectangle("RED",10,20);
        Circle cir=new Circle("white",5);
        System.out.println(rect.toString());
        System.out.println(cir.toString());
    }
}

abstract class Shape{
    protected String color;
    Shape(){};
    Shape(String col){
        color=col;
    }

    abstract public double getArea();
    public String toString(){
        return "Color"+color;
    }
}

class Circle extends Shape{
    double radius;
    public Circle(String c,double r){
        color=c;
        radius=r;
    }
    public double getArea(){
        return Math.PI*radius*radius;
    }
    public String toString(){
        return "Clo:"+color;
    }
}

class Rectangle extends Shape{
    protected double wid,len;
    public Rectangle(String c,double w,double l){
        super(c);
        wid=w;
        len=l;
    }
    public double getArea(){
        return wid*len;
    }
    public String toString(){
        return "RE"+getArea()+super.toString();
    }
}

抽象类是用来生成子类的，只有实现了抽象类中的所有抽象方法的子类才是一个可以用来创建对象的类。

接口

接口的定义和类的定义很类似。
【修饰符】interface 接口名{
//定义成员变量；
//定义成员方法
}
接口变量一律公共的、静态的、最终的，方法是公共的、抽象的。
使用implements实现接口，相当于将接口内容继承到当前类中。覆盖接口中的抽象方法，这个类就可以使用。

interface IS{
	double r=1;//成员变量为最终的，常量
	double getS();
}

class Peo implements IS{
	
}

接口不能直接创建对象，存在的意义就是让其他类来使用。实现就是该类必须把接口的所有方法都补充上方法体，实现方法必须加上public，因为接口就是默认public。
接口使用非常灵活：一个类可以继承其他类的同时实现接口，父类只有一个，接口可以有很多。
class B extends A implements IB,IC,{}
如果一个类在实现接口时没有实现其中的全部抽象方法，那么这个类就是一个抽象类，必须用abstract关键字声明。

多态的应用

看似一个内容，却表现多种状态。
Java实现多态的基础是动态方法调度，重载（类家族）和覆盖(子类和父类）则是不同表现。

使用异常处理

基于Swing的图形界面编程

可视化程序的事件处理

Java多线程机制

综合实例（计算器的课程设计）

附录