JAVA知识点（期末备考）
JDK=JRE+JAVA开发工具 JRE Java Runtime Environment 的简称，指Java运行环境
JRE=JVM+核心类库 JVM Java Virtual Machine 的简称，指Java虚拟机
###环境变量作用：为了在DOS任意目录下使用java和javac命令
程序开发步骤
1.编写源文件源文件后缀必须是.java,源文件名称必须与public类相同，源文件中只能有一个public类，如果没有publi类则源文件名称与任意一个类名称相同即可。
2.使用 javac 源文件.java 编译源程序得到字节码文件
3.java 源文件名 执行Java文件
标识符
由字母、数字、下划线、美元符号组成，不能由数字开头；不能有空格；区分大小写。
命名规则
包名：全部小写，多级包用.隔开。
举例：com.jourwon
类、接口：一个单词首字母大写，多个单词每个单词的首字母大写。
举例：Student,Car,HelloWorld
方法和变量：一个单词首字母小写，多个单词从第二个单词开始每个单词的首字母大写。
举例：age,maxAge,show(),getAge()
常量：如果是一个单词,所有字母大写，如果是多个单词,所有的单词大写,用下划线区分每个单词。
举例：DATE,MAX_AGE
项目名：全部用小写字母，多个单词之间用横杆-分割。
举例：demo，spring-boot
java关键字
private，protected，public；访问修饰符
char int byte short long float double boolean 变量类型
float类型变量后面必须跟f或者F后缀，double类型可以省略后缀d
类如
float x=22.76f；
import 引入
package包
关键字都是小写，遇到大写不是关键字
boolean类型输出"true"和"flase"；
byte 范围-2^7 2^7-1
char 范围 '\u0000’0----2^16-1
short范围 0----2^15
String 字符串
字符读入
通过import.java.util.Scanner;引入
通过 Scanner读入字符串有两种方式：
Scanner in = new Scanner(System.in);
String s1=in.nextLine();//方式1 输入 ab cd ef
String s2=in.next();//方式2 输入 ab cd ef
System.out.print(s1);//输出 ab cd ef
System.out.print(s2);//输出 ab
next():一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。
nextLine():结束符只是Enter键，即nextLine()方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。
输出数据
System.out.println(m+"个数的和为"+sum);//输出后换行
System.out.print(":"+123+"大于"+122);//不换行
System.out.printf("格式控制符 %c %d %f %s",表达式);
声明数组
float boy[];
char [] cat;
float a[][];
char [][] b;
分配空间
boy =new float[4];
float boy []=new float[4];
对于一维“数组数组名.length"的值就是数组中元素个数
运算符与表达式
&& 与 || 或，短路运算符&&运算符当前边结果为flase时不计算后面的表达式，||运算符当前边表达式的结果为true时，不在计算后面表达式的值（op1&&op2）(op1||op2)
& 按位与
| 按位或
^ 按位异或（相同数据位相同取0，不同取1）
continue与break
在这里插入图片描述
continue退出本次循环，break退出整个循环。
for循环的扩充
for（声明循环变量：数组名字）{
}
for（int i：a）{
System.out.println(i);//循环变量依次取数组a的每个元素值
}
类与对象
面向对象语言三大特征：封装、继承、多态。
类是java语言中最重要的数据类型
类体有两部分组成：一部分是变量的声明，用来刻画属性；一部分是方法的定义，用来刻画行为功能。
成员变量其有效性与出现位置无关，对成员变量的操作职能放在方法中。
成员变量有默认值，局部变量没有默认值
class A{
int a=12;//正确，声明a并赋初值
int b;//声明变量b其默认值为0
b=12;//错误，只能在方法中操作变量
}
构造方法与对象创建
构造方法必须与类的名字完全相同，而且没有类型，一个类中可以有多个构造方法，但是参数类型必须不同，作用是用来初始化成员变量，如果类中显示给出了构造方法，则java不提供默认构造方法。
对象创建格式：类名 对象名字=new 构造方法（）；当一个对象被创建时，类中成员变量被分配内存空间，这些内存空间称作该对象的实体，对象中存放着引用值。
用static修饰的变量成为类变量，否则成为实例变量，被static修饰的方法称为类方法
类方法与实例方法区别
类方法可以操作类变量不能操作实例变量，实例方法可以操作两者，类方法可以直接通过类名调用，不能调用实例方法。
重载与多态
java中存在两种多态：重载和重写.
重载：一个类中可以有多个有相同名字的方法，但是参数必须是不同的，参数的个数或是参数的类型
方法重载：
1、在同一个类中
2、方法名相同
3、方法的形式参数不同
类型、个数、顺序不同
4、与返回值和访问权限无关
包
通过关键字package声明包
package作为java源文件的第一条语句，为该源文件中声明的类指定包。
程序如果使用了 package tom.jiafei，那么存储目录中必须含有如下结构。。。、\tom\jiafei字节码文件必须放在这里
运行时必须到tom\jiafei的上级目录运行主类 c\1000\java tom.jiafei.主类名
通过 import引入包
访问权限
访问限制修饰符 private protected public
private，对于使用private修饰的方法或者成员变量，只有在本类创建该类的对象时才能访问自己的私有成员变量和类中方法
public 共有
友好变量和友好方法：当在另一个类中用类tom创建一个对象后，只有两个类在一个包中才能访问该对象的友好变量和有哈奥方法，在任何一个与ton在同一个包中的类中，可以通过tom类的类名访问tom类的友好变量
注意点：
1、protected和private不能修饰类
2、访问权限由高到低：public->protected->友好型->private
子类与继承
java不允许多重继承（一个子类只能有一个父类）
class A(子类) extends B（父类）{
}
java的类按继承关系形成树型结构，根节点时Object类，Object是所有类的祖先类，除了Object每个类有且仅有一个父类
如果子类与父类在同一个包中，那么子类继承了其父类中不是private的成员变量和成员方法。继承的成员和方法，访问权限不变
子类在创建对象是不仅给自己的成员变量分配了内存空间，也为其父类所有的成员变量分配了内存空间，但是子类只能操作继承来的那部分成员变量。
使用super关键字向父类的构造函数传参，必须出现在第一句
instanceof运算符左边是对象右边是类，如果左面的对象是右面的类或子类创建的对象返回false
子类继承了父类的方法则可以重写父类方法，但是访问权限只能那个不变或者提高不能降低
可用通过super.父类成员方法来调用被隐藏的父类方法
final关键字修饰类、成员变量和方法，被final修饰的类不能被继承，即不能有子类。如果修饰父类的一个方法则该方法不能被重写。final修饰变量，则该变量是常量
对象的上转型对象
用子类创建一个对象，并把这个对象的引用放到父类对象中，用子类初始化父类
//A是B的父类
A a；
a=new B（）;
或
A a；
B b=new B（）；
a=b；
上装型对象不能操作子类新增的成员变量，不能调用子类新增的方法；
上转型对象可以访问子类继承或隐藏的成员变量也可以调用子类继承的方法或者子类重写的示例方法。
抽象类和抽象方法
abstract class A{
}
abstract int min(int x,int y);
abstract类可以有abstract方法，也可以没有。
abstract方法，只允许声明不允许实现和使用final修饰abstract方法。
不能使用new创建该类对象，只能产生其子类，由子类创建对象。
如果一个非abstract类是abstract的子类，他必须实现父类的所有abstract方法
如果一个abstract是abstract类的子类，它可以重写父类的abstract方法，也可以继承父类的abstract方法
抽象类可以实现接口
接口与实现
接口定义使用interface关键字
interface Printable{
}
接口中的常量都是public、static、final
接口中方法默认为public、abstract；接口也产生class文件
接口中方法不能被final、static修饰，因为类要重写接口中的方法
接口中没有构造函数
内部类和异常类
在一个类中声明另一个类，包含在内部的类成为内部类。
内部类不可以声明类方法和类变量；
外嵌类成员变量在内部类中仍然有效，内部类方法可以调用外嵌类中的方法；
外嵌类和内部类在编译时生成两个class文件
异常类
try-catch语句
try{
//可能发生异常的语句
}
catch（ExceptionSubClass1 e）{
//发生异常后的处理
}
常用实用类
String类
String类在java.lang包中，默认引入，因此程序可以直接使用String类，String被定义为final，因此String类不能被扩展，即String类不能有子类
String s=new String（"Hello World!"）;//s中存放着引用，表明实体的位置
String you="Hello";
String hi="World！";
String Test=you+hi;
String类方法
public int length（）;//获取字符串长度
public boolean startsWith（String s）;//判断当前字符序列前缀是否是参数指定String序列s的字符序列
public boolean endsWith（String s）;
String str1="hello";//存储在常量池中
String str2="he"+ new String("llo");//存储在堆中
System.out.println(str1==str2);//"=="是判断地址是否相同
//运行结果是flase
String str3="hello";//常量池
String str4=new("hello");//堆
String str5="hel"+"lo";//常量池
System.out.println(str1==str3);//输出true
System.out.println(str1==str4);//输出flase
System.out.println(str1==str5);//输出true
组件及事假处理
JAVA中把Component类的子类或者间接子类创建的对象称为一个组件，把Container的子类或间接子类创建的对象称为一个容器，可以向容器添加组件，Container提供了一个public方法：add（），一个容器可以调用这个方法将组件添加到该容器中。
容器调用removeAll（）方法移除容器中全部组件，remove（Component c）方法移除掉容器中参数c指定的组件。
JFame类的实例是一个底层容器，即通常所称的窗口。其他的组件必须添加到底层容器中。窗口容器被默认的添加到显示器上。
JFame();
JFame(String s);//创建标题为s的窗口
public void setBounds(int a,int b,int width,int height);//设置窗口的初始位置（a，b）；以及窗口的大小（width，height）
public void setSize（int width，int height）;//设置窗口大小
public void setLocation（int x，int y）;//设置窗口位置
public void setVisible（boolean b）;//设置窗口是否可见
public void dispose（）;//撤销当前窗口，并释放当前出当前所有资源
public void setLayout（）;//设置管理器布局
菜单条
JMenubar负责创建菜单条，
将菜单条放置到窗口：setJMenuBar（JMenuBar bar）；
菜单
JMenu负责创建菜单
public void add（JMenuItem iteam）；向菜单添加指定的菜单项
菜单项
JMenuItem 负责创建菜单项
文本框
JTextField TEXT =new JTextField（）；创建文本框
//常用方法
public String GetText（）；//得到文本框内容
public void setText（String s）；//设置文本框内容
文本区
JTextArea Area =new JTextArea（）；
//常用方法
public String getText（）；
pubilc void setText（String s）；
按钮
JButton button=new JButton（）；JButton（String s）；
容器
面板
JPanel（）；
JPanel p=new JPanel();
public void add();
布局
容器中使用方法setLayout（布局对象）；
//JPanel默认布局
FlowLayout flow =new FlowLayout();
//容器con使用
con.setLayout(flow);
//BorderLayout
con.add(b,BorderLayout.CENTER);
//CardLayout
事件处理模式
监视器 addActionListener（监视器）
ActionEvent事件源：文本框，按钮，菜单项，密码框，单选按钮都可以触发ActionEvent事件，都可以称为ActionEvent的事件源
注册监视器：
ActionListener接口：ActionListener接口在java.awt.event包中只有以一个方法
public void actionPerformed(ActionEvent e)
//事件源出发ActionEvent后，监视器将发现出发的事件ACtionEvent事件，然后调用接口中的这个方法对发生事件作出处理
//ActionEvent累世家按实现创建的对象就会传递给该方法的参数e
输入、输出流
File类
File(String filename)；
File(String directoryPath,String filename);//directoryPath 是文件存放路径
File(File f,String filename);
//常用方法
public String getName（）;//获取文件名字
public boolean canRead（）;//判断文件是否可读
public boolean canWrit（）;//判断文件是否可以写入
public long length();//获取文件长度单位是字节
目录
public boolean mkdir();//创建目录
public String []list();//用字符串形式返回目录下全部文件
public File []listFile();//用File对象返回目录下全部文件
输入流
FileInputStream(String name);
FileInputStream(File file);
//字节流可以调用从父类继承的read方法读取文件，只要不关闭文件，每次调用read方法就顺序读取文件其余内容，知道末尾或者被关闭
int read();//读取单个字节，返回字节型数值（0-255），没有读出返回-1
int read（byte b[]）;//读取b.length个字节返回到数组b中，末尾返回-1
int read（byte b[],int off .int len）;//读取len个字符，off指定开始存放位置
输出流
FileOutputStream(String name);
FileOutputStream(File file);
void write(int n);//写入单个字符
void write(byte b[]);//写入一个字节数组
关闭流通过调用close（）方法
多线程
进程是程序的一次动态执行过程，线程是比进程更小的执行单位；JAVA内置对多线程的支持。
JVM（Java Virtual Machine 虚拟机）加载代码，发现main方法后，就会启动一个线程“主线程”；当所有线程都结束后才结束Java的应用程序。
Theard类或其子类的对象声明被创建时，新线程对象处于新建状态；
线程必须调用start（）方法通知JVM，当轮到他想用CPU资源时，此线曾脱离主线程开始自己生命周期
中断：
1、CPU资源切换到其他线程
2、执行sleep（int time）；方法
3、执行wait（）；方法
4、进入阻塞状态
普通方法的调用和通过线程start调用启动的区别
//普通方法的调用
public class Example extends Thread{
@Override
public void run(){
try {
Thread.sleep(1000);
} catch (InterruptedException e){
e.printStackTrace();
}
System. out .print( "run" );
}
public static void main(String[] args){
Example example= new Example();
example.run();//输出run main
example.start();//输出main run
System. out .print( "main" );
}
}
example.run()是普通调用，没有创建新线程，只是让线程休眠了1000ms，最后输出 run main；
example.start();创建了新线程，运行到Thread.sleep(1000);该线程休眠了1000ms，main线程先打印main，休眠结束后，打印run。
Thread的子类
Thread类和其子类都可以创建线程，子类必须重写run（）方法来规定线程具体操作，否则线程什么也不做
图形
Component类有一个方法 public void paint(Graphics g),程序可以重写这个方法，当程序运行时java环境会调用Graphicd2D（Graphics的一个子类）将参数g实例化，对象可以在重写paint方法的组件上绘制图形、图像。
Graphics2D的“画笔”分别使用draw和fill方法来绘制和填充一个图像。
Java简单数学函数使用
import java.math.*;//引入数学函数包
public class Test{
public static void main(String[] args){
double x=4;
double y=Math.sqrt(x);//调用开根号函数
double z=Math.pow(x);//调用平方函数
}
}
1368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
