标签：action ide java io vax layout dac package 性能 public
精度从高到低 double float long int short(char) byte
(1)自动类型转换 将一个低精度---?高精度
(2)强制类型转换 将一个高精度---?低精度(精度会下降)
概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，只看参数列表(参数类型以及参数个数)。
好处：方便于阅读，优化了程序设计。
类：对现实世界中某类事物的描述,是抽象的，概念上的定义。
对象：事物具体存在的个体。
(1)作用域
成员变量：针对整个类有效。
局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)
(2)存储位置
成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。
局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。
当方法调用完，或者语句结束后，就自动释放。
指隐藏对象的属性和实现细节，仅对外提供公共访问方式
(1)特点：
方法名与类名相同
没有返回类型
没有返回值
(2)作用：构造函数是用于创建对象，并对其进行初始化赋值，对象一建立就自动调用相对应的构造函数
(1)作用：给对象进行初始化，对象一建立就执行，而且优先于构造函数执行
(2)构造代码块和构造函数的区别：
构造代码块是给所有不同对象的共性进行统一初始化
构造函数是给对应的对象进行初始化
作用（1）表示类中的属性
（2）可以使用this调用本类的构造方法
（3）this表示当前对象
(1)静态的意思，用来修饰成员变量和成员函数
(2)静态的特点:
随着类的加载而加载
优先于对象存在
对所有对象共享
可以被类名直接调用
注意：静态方法中不能使用this,super关键字
(1)把很多类的相同特征和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系。
这样的话，多个类就可以省略很多代码。这个关系就是继承。java中用extends关键字表示。
（2）继承的特点:
java中只能单继承，没有多继承。
java可以有多重(层)继承。
（3）继承的好处：
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。
重载：在同一类中。方法名相同，参数列表不同。重载可以改变返回类型。
重写：在不同类中(子父类中)。
this:代表本类对象的引用。
super:代表父类的存储空间。
(1)最终的意思，可以用于修饰类，方法，变量。
(2)final修饰的类不能被继承。
final修饰的方法不能被重写。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量。
A:抽象类和抽象方法都要用abstract进行修饰
B:抽象类不能被实例化
C:抽象类中不一定有抽象方法，但是，有抽象方法的类一定是抽象类。
(1)关系
A:类与类的关系
是继承关系。类与类只能单继承，可以多重继承。
B:类和接口的关系
是实现关系。类可以多实现接口。
类在继承一个类的同时，可以实现多个接口。
C:接口和接口的关系
是继承关系。接口可以多继承接口。
(2)接口的特点
A:是对外暴露的规则
B:是功能的扩展
C:接口的出现降低耦合性。
耦合(类与类之间的关系)
内聚(类完成功能的能力)
编程规范：低耦合，高内聚。
抽象类只能被单继承
接口可以多实现,接口的出现避免了多继承的局限性。
(1)是所有类的根类，超类。
java中提供的类以及我们自定义的类都直接或者间接的继承自Object类。
(2)Object类中的方法
A:void finalize()
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
B:Class getClass()
获取对象的字节码文件的描述类，后面再讲反射的时候还会在说这个类。
String name = s.getClass().getName();
而这些异常对象存在着共性的内容，所以，可以不断的进行抽取。最终形成了异常的体系结构。
异常体系的根类是:Throwable
Error:重大的问题，我们处理不了。也不需要编写代码处理。比如说内存溢出。
Exception:一般性的错误，是需要我们编写代码进行处理的。
RuntimeException:运行时异常，这个我们也不需要处理。
异常的分类
异常有两种：
编译时被检测异常：
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
异常体系中的所有类及其子类对象都具备可抛性。也就是说可以被throw和throws关键字所操作。
A:在main里面编写代码进行处理
B:交给jvm自己进行处理。采用的是jvm的默认处理方式。
其实就是相当于调用了异常对象的printStackTrace()方法。
getMessage():获取异常信息，返回字符串。
toString():获取异常类名和异常信息，返回字符串。
printStackTrace():获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
try...catch...finally
try
{
可能出现异常的代码
}
catch(异常对象)
{
异常处理代码
}
finally
{
释放资源
}A：有throws的时候可以没有throw。
有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
B：throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类，之间用逗号隔开
throw用于方法体中，其后跟的是一个异常对象名
进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：进程内部的一条执行路径或者一个控制单元。
两者的区别：
一个进程至少有一个线程
进程在执行过程中拥有独立的内存单元，而多个线程共享内存；
解决了多部分同时运行的问题，提高效率
线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。
一个进程中有多个线程，称为多线程。
实现多线程可以通过继承Thread类和实现Runnable接口。
(1)继承Thread
定义一个类继承Thread类
复写Thread类中的public void run()方法，将线程的任务代码封装到run方法中
直接创建Thread的子类对象，创建线程
调用start()方法，开启线程(调用线程的任务run方法)
//另外可以通过Thread的getName()获取线程的名称。
(2)实现Runnable接口；
定义一个类，实现Runnable接口；
覆盖接口的public void run()的方法，将线程的任务代码封装到run方法中；
创建Runnable接口的子类对象
将Runnabl接口的子类对象作为参数传递给Thread类的构造函数，创建Thread类对象
（原因：线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务）。
调用start()方法，启动线程。
(1)实现Runnable接口避免了单继承的局限性
(2)继承Thread类线程代码存放在Thread子类的run方法中
实现Runnable接口线程代码存放在接口的子类的run方法中；
在定义线程时，建议使用实现Runnable接口，因为几乎所有多线程都可以使用这种方式实现
Thread类用于描述线程。Thread类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；
start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的
代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，
一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，
它包含了要执行的这个线程的内容，Run方法运行结束,此线程随即终止。
run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,
其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，
这样就没有达到多线程的目的。
新建：new一个Thread对象或者其子类对象就是创建一个线程，当一个线程对象被创建，但是没有开启，这个时候，
只是对象线程对象开辟了内存空间和初始化数据。
就绪：新建的对象调用start方法，就开启了线程，线程就到了就绪状态。
在这个状态的线程对象，具有执行资格，没有执行权。
运行：当线程对象获取到了CPU的资源。
在这个状态的线程对象，既有执行资格，也有执行权。
冻结：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行资格和执行权。
当然，他们可以回到运行状态。只不过，不是直接回到。
而是先回到就绪状态。
死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，在内存中变成了垃圾。
9、sleep()和wait()的区别：
(1)这两个方法来自不同的类，sleep()来自Thread类，和wait()来自Object类。
(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，
要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法
(3)sleep()释放资源不释放锁，而wait()释放资源释放锁；
(4)使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
10、多线程安全问题：
(1)原因:当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于线程的随机性导致
一个线程对多条语句，执行了一部分还没执行完，另一个线程抢夺到cpu执行权参与进来执行，
此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。
(2)解决方法:对多条操作共享数据的语句进行同步，一个线程在执行过程中其他线程不可以参与进来
11、Java中多线程同步是什么？
同步是用来解决多线程的安全问题的，在多线程中，同步能控制对共享数据的访问。如果没有同步，当一个线程在
修改一个共享数据时，而另外一个线程正在使用或者更新同一个共享数据，这样容易导致程序出现错误的结果。
12、什么是锁?锁的作用是什么?
锁就是对象
锁的作用是保证线程同步，解决线程安全问题。
持有锁的线程可以在同步中执行，没有锁的线程即使获得cpu执行权，也进不去。
13、同步的前提:
(1)必须保证有两个以上线程
(2)必须是多个线程使用同一个锁，即多条语句在操作线程共享数据
(3)必须保证同步中只有一个线程在运行
14、同步的好处和弊端
好处：同步解决了多线程的安全问题
弊端：多线程都需要判断锁，比较消耗资源
15、同步的两种表现形式：
(1)同步代码块:
可以指定需要获取哪个对象的同步锁,使用synchronized的代码块同样需要锁,但他的锁可以是任意对象
考虑到安全问题，一般还是使用同一个对象，相对来说效率较高。
注意：
虽然同步代码快的锁可以使任何对象，但是在进行多线程通信使用同步代码快时，
必须保证同步代码快的锁的对象和，否则会报错。
同步函数的锁是this，也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是
同一个对象，也就是都是this锁代表的对象。
格式：
synchronized(对象)
{
需同步的代码;
}(2)同步函数
同步方法是指进入该方法时需要获取this对象的同步锁，在方法上使用synchronized关键字，
使用this对象作为锁，也就是使用了当前对象，因为锁住了方法，所以相对于代码块来说效率相对较低。
注:静态同步函数的锁是该方法所在的类的字节码文件对象，即类名.class文件
格式：-
修饰词 synchronized 返回值类型 函数名(参数列表)
{
需同步的代码;
}
两个线程对两个同步对象具有循环依赖时，就会发生死锁。即同步嵌套同步，而锁却不同。
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，
而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程)，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
void join() 等待该线程终止。
void join(long millis) 等待该线程终止的时间最长为 millis 毫秒。
throws InterruptedException
特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行
作用: join可以用来临时加入线程执行；
yield():暂停当前正在执行的线程对象，并执行其他线程
setPriority(int newPriority):更改线程优先级
int getPriority() 返回线程的优先级。
String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组
(1)用来处理设备(硬盘，控制台，内存)间的数据。
(2)java中对数据的操作都是通过流的方式。
(3)java用于操作流的类都在io包中。
(4)按照流操作的数据的类型不同：分为字节流和字符流。字符流是为了方便中文的操作而来的。
(5)按照流的流向不同分为：输入流，输出流
输出字节流：OutputStream：字节写入流抽象类
输入字节流：InputStream：字节读取流抽象类
输出字符流：Writer：字符写入流的抽象
输入字符流：Reader: 字符读取流的抽象类
OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流的输出对象
InputStreamReader：是Reader的子类，将输入的字节流变成字符流，即将一个字节流的输入对象变为字符流的输入对象。
字节内存流：ByteArrayInputStream（内存字节输入流）、ByteArrayOutputStream（内存字节输出流）。
字符内存流：CharArrayReader（内存字符输入流）、CharArrayWriter（内存字符输出流）。
分为管道输出流（PipedOutputStream）、管道输入流（PipedInputStream）。
如果想进行管道输出，则必须把输出流连接在输入流上，在PipedOutputSream类上有如下方法用于连接管道。
打印流提供了非常方便的打印功能，可以打印任何的数据类型，如小数、整数、字符串等。
包含字节打印流（PrintStream）和字符打印流（PrintWriter）
主要包括以下三种工具类
1）组件：Component
2）容器：Container
3）布局管理器：LayoutManager
（1）基本容器JFrame
（2）标签组件JLabel
（3）按钮组件JButton
（4）布局管理器
（6）文本框和文本区框和密码输入框：JTextField和JTextArea和JPasswordField。
实现简单记事本
package demo;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.KeyStroke;
public class TextPad implements ActionListener{
JFrame frame;
JMenuBar bar;
JMenu fileMenu,editMenu,formatMenu,lookMenu;
JMenuItem newItem,openItem,saveItem,saveAnotherItem,closeItem;
ImageIcon newIcon,openIcon,saveIcon,saveAnotherIcon,closeIcon;
JMenuItem revocationItem,cutItem,copyItem,stickItem,deleteItem,allItem,timeDateItem;
JMenuItem lineItem,typeFaceItem,zoomItem,statusItem;
JScrollPane scroll;
JTextArea area;
JFileChooser chooser; //文件选择框
File file;
public TextPad() {
frame = new JFrame("记事本");
bar=new JMenuBar();
fileMenu=new JMenu("文件");
editMenu=new JMenu("编辑");
formatMenu=new JMenu("格式");
lookMenu=new JMenu("查看");
newIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"newIcon.png");
openIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"openIcon.png");
saveIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"saveIcon.png");
saveAnotherIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"saveAnotherIcon.png");
closeIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"closeIcon.png");
area=new JTextArea();
scroll=new JScrollPane(area);
newItem=new JMenuItem("新建（N）",newIcon);
openItem=new JMenuItem("打开（O）",openIcon);
saveItem=new JMenuItem("保存（S）",saveIcon);
saveAnotherItem=new JMenuItem("另存为（D）",saveAnotherIcon);
closeItem=new JMenuItem("关闭（X）",closeIcon);
revocationItem=new JMenuItem("撤销（Z）");
cutItem=new JMenuItem("剪切（T）");
copyItem=new JMenuItem("复制（ C）");
stickItem=new JMenuItem("粘贴（V）");
deleteItem=new JMenuItem("删除（P）");
allItem=new JMenuItem("全选（A）");
timeDateItem=new JMenuItem("时间日期（Q）");
lineItem=new JMenuItem("自动换行（W）");
typeFaceItem=new JMenuItem("字体（F）");
zoomItem=new JMenuItem("缩放（R）");
statusItem=new JMenuItem("状态栏（S）");
//加上监视器
newItem.addActionListener(this);
openItem.addActionListener(this);
saveItem.addActionListener(this);
saveAnotherItem.addActionListener(this);
revocationItem.addActionListener(this);
cutItem.addActionListener(this);
copyItem.addActionListener(this);
stickItem.addActionListener(this);
deleteItem.addActionListener(this);
allItem.addActionListener(this);
timeDateItem.addActionListener(this);
lineItem.addActionListener(this);
typeFaceItem.addActionListener(this);
zoomItem.addActionListener(this);
statusItem.addActionListener(this);
fileMenu.add(newItem);
fileMenu.add(openItem);
fileMenu.add(saveItem);
fileMenu.add(saveAnotherItem);
fileMenu.addSeparator();
fileMenu.add(closeItem);
editMenu.add(revocationItem);
editMenu.add(cutItem);
editMenu.add(copyItem);
editMenu.add(stickItem);
editMenu.add(deleteItem);
editMenu.add(allItem);
editMenu.add(timeDateItem);
formatMenu.add(lineItem);
formatMenu.add(typeFaceItem);
lookMenu.add(zoomItem);
lookMenu.add(statusItem);
newItem.setMnemonic(KeyEvent.VK_N);
openItem.setMnemonic(KeyEvent.VK_O);
saveItem.setMnemonic(KeyEvent.VK_S);
saveAnotherItem.setMnemonic(KeyEvent.VK_D);
closeItem.setMnemonic(KeyEvent.VK_X);
revocationItem.setMnemonic(KeyEvent.VK_Z);
cutItem.setMnemonic(KeyEvent.VK_T);
copyItem.setMnemonic(KeyEvent.VK_C);
stickItem.setMnemonic(KeyEvent.VK_V);
deleteItem.setMnemonic(KeyEvent.VK_P);
allItem.setMnemonic(KeyEvent.VK_A);
timeDateItem.setMnemonic(KeyEvent.VK_Q);
//快捷键
newItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_N,InputEvent.CTRL_DOWN_MASK));
openItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_O,InputEvent.CTRL_DOWN_MASK));
saveItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_S,InputEvent.CTRL_DOWN_MASK));
saveAnotherItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_D,InputEvent.CTRL_DOWN_MASK));
closeItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_X,InputEvent.CTRL_DOWN_MASK));
revocationItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_Z,InputEvent.CTRL_DOWN_MASK));
cutItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_T,InputEvent.CTRL_DOWN_MASK));
copyItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_C,InputEvent.CTRL_DOWN_MASK));
stickItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_V,InputEvent.CTRL_DOWN_MASK));
deleteItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_P,InputEvent.CTRL_DOWN_MASK));
allItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_A,InputEvent.CTRL_DOWN_MASK));
timeDateItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_Q,InputEvent.CTRL_DOWN_MASK));
bar.add(fileMenu);
bar.add(editMenu);
bar.add(formatMenu);
bar.add(lookMenu);
frame.setJMenuBar(bar);
frame.add(scroll);
frame.setSize(600,400);
frame.setLocation(200, 100);
frame.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent event) {
Object obj=event.getSource();
if(obj instanceof JMenuItem) {
JMenuItem item = (JMenuItem) obj;
if(item==newItem) { //文件栏
new TextPad();
}else if(item==openItem) {
chooser=new JFileChooser();
chooser.showOpenDialog(null);
file=chooser.getSelectedFile();
try {
FileInputStream fis=new FileInputStream(file);
byte[] b = new byte[fis.available()];
fis.read(b);
area.append(new String(b));
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}else if(item==saveItem) {
file=chooser.getSelectedFile();
FileOutputStream fos;
try {
fos = new FileOutputStream(file);
byte[] b=area.getText().getBytes();
fos.write(b);
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
}
}else if(item==saveAnotherItem) {
chooser=new JFileChooser();
chooser.showSaveDialog(null);
file=chooser.getSelectedFile();
try {
if(!file.exists()) {
file.createNewFile();
}
FileOutputStream fos=new FileOutputStream(file);
byte[] b=area.getText().getBytes();
fos.write(b);
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}else if(item==closeItem) {
System.exit(1);
}
else if(item==cutItem) { //编辑栏
area.cut();
}else if(item==copyItem) {
area.copy();
}else if(item==stickItem) {
area.paste();
}else if(item==allItem) {
area.selectAll();
}else if(item==deleteItem) {
String temp=area.getSelectedText();
int start=area.getSelectionStart();
int end=area.getSelectionEnd();
area.replaceRange("", start, end);
}else if(item==timeDateItem) {
Date d = new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateNewStr=sdf.format(d);
area.append(dateNewStr);
}
}
}
}
眨眼间，一个学期就过去了，这个学期学的语言是java，java和c有很多相似的又有很多不同。最初接触java时给我最大的不同便是语法，第一次看java代码时给我的感觉是一堆一堆很繁琐，不像c,很简洁很明了。后来经过一段时间的学习，也慢慢了解了java，慢慢发现java有很多还是和c很相象的，例如循环语句，条件语句这些，但也有很多不用，首先最大的不同便是语法上的。在这个学期开始时，对于java其实是没有跟上去的，可能与c的相差还是有点大，对于java的编程有点习惯用c的想法去想去思考，导致很多理解不来，所以最初一段时间是没跟上来，后来经过之后的学习以及自己再往前复习复习才慢慢跟上，现在也还是理解最基础的很多还是不知道，所以这个学期的java其实是没怎么学好的。之后再寒假还得多看看java。
标签：action ide java io vax layout dac package 性能 public
原文地址：https://www.cnblogs.com/cxnkkk/p/12037163.html
