标签：
Public static void main(String args[])—从main开始处理
区分大小写
方法名：第一个小写开头，其他字母大写开头
myFirstMethod
类：概念 不存在内存 鱼
对象：实体 存在内存 鲤鱼、带鱼（变量和函数放在类里面）
类名：大写 MyTestName
?局部变量
‚类变量/静态变量
ƒ实例变量
成员变量：类中定义（类的成员变量）
Static修饰——静态变量或类变量（属于类）
没有static——实例变量
实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
类的静态变量在内存中只有一个，java虚拟机在加载类的过程中为静态变量分配
1、静态变量或类变量static（在类里面定义，类创建的时候就会加载静态变量，然后创建对象）
类变量也称为静态变量在类的static关键字声明的，但在方法外面，构造函数或块。
房子：类
人：对象
家具电器：static 公用 类拥有的（房子） 改动了家用电器，弄坏了就是永久的坏了别人用
的时候也是坏的。
Static一改动就是永久性的改动
类创建的时候加载静态变量和静态方法（这个时候还没有对象——人），所以这个时候不能引用对象的东西
人身上的衣服和人的行为：非静态变量和方法 每个人都有但不一定一样，不是公用的，是
私有的，可以随意改动自己的变量，不会对其他变量产生影响
方法直接的变量是不能进行互调（实例变量）
2、实例变量
在类中声明，但在方法的外面，构造函数或任何块。
当一个对象与使用关键字 “new” 来创建，在对象被销毁销毁创建的实例变量。（对象被销毁，实例变量也被销毁）
访问修饰符可以给出实例变量。-default、public、private、protected
实例变量默认值：数字——0
布尔值——false
字符——null
实例变量为对象的属性，必须创建了实例对象，实例变量才会被分配空间，才能使用这个实例变量
import java.io.*;
public class WholeTest{
// this instance variable is visible for any child class.
public String name;
// 全局变量name——实例变量，无static修饰
// salary variable is visible in WholeTest class only.
private double salary;
// 全局变量salary——实例变量，无static修饰，可用访问修饰符修饰
// The name variable is assigned in the constructor.
public WholeTest (String empName){
name = empName;
// 局部变量empName
}
// The salary variable is assigned a value.
public void setSalary(double empSal){
salary = empSal;
// 局部变量empSal
}
// This method prints the WholeTest details.
public void printEmp(){
System.out.println("name : " + name );
// 这里的name显示的是全局
System.out.println("salary :" + salary);
// 这里的salary显示的全局
}
public static void main(String args[]){
WholeTest empOne = new WholeTest("Ransika");
empOne.setSalary(1000);
empOne.printEmp();
}
}
----实例变量与静态变量（类成员变量）
public class VarTest{
public static int a=0;
public int b=1;
// 实例变量，只能通过创建的实例引用
public static void main(String [] args)
{
int c=0;
// 局部变量
a++;
System.out.println(a);
// 1
System.out.println(++a);
// 2
System.out.println(a);
// 2
System.out.println(c);
// 0
VarTest vt=new VarTest();
System.out.println(vt.b);
// 实例变量只能通过实例引用 vt.b
// 1
}
}
局部变量：形参、方法内定义，代码块中定义的变量
1、访问修饰符不能用于局部变量。
访问修饰符：default、public、private、protected
不可访问修饰符：abstract、final
2、局部变量在第一次使用事情应该初始化
所有变量必须先声明，再使用
3.2.1非静态代码块
直接由 { } 包起来的代码，称为非静态代码块
3.2.2静态代码块
直接由 static { } 包起来的代码，称为静态代码块
每个类都有构造方法，若没有显示的定义，Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
无参与有参
public class Puppy{
public Puppy(){
}
——无参构造方法
public Puppy(String name){
// 这个构造器仅有一个参数：name
}}
创建对象
对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name
System.out.println("Passed Name is :" + name );
}
public static void main(String []args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
——调用构造函数 public Puppy(String name)初始化对象
}}
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name
System.out.println("Passed Name is :" + name );
}
public static void main(String []args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy();
——调用默认的构造函数 public Puppy()初始化对象
}}
调用类中的变量：myPuppu.vari;
调用类中的方法：myPuppu.Method(name);
一个类的两个方法拥有相同的名字，但是有不同的参数列表
方法内定义的变量被称为局部变量。
局部变量的作用范围从声明开始，直到包含它的块结束。
局部变量必须声明才可以使用。
finalize() 方法
它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做finalize( )，它用来清除回收对象。
在finalize()方法里，你必须指定在对象销毁时候要执行的操作
finalize()一般格式是：
protected void finalize(){
// 在这里终结代码}
关键字protected是一个限定符，它确保finalize() 方法不会被该类以外的代码调用。
当然，Java的内存回收可以由JVM来自动完成。如果你手动使用，则可以使用上面的方法。
public class FinalizationDemo {
public static void main(String[] args) {
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);
c2 = c3 = null;
System.gc(); //调用Java垃圾收集器
} }
class Cake extends Object {
private int id;
public Cake(int id) {
this.id = id;
System.out.println("Cake Object " + id + "is created");
}
protected void finalize() throws java.lang.Throwable {
super.finalize();
System.out.println("Cake Object " + id + "is disposed");
} }
file(内存)----输入流---->【程序】----输出流---->file(内存)
字节流和字符流
字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件
结论：优先选用字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。
?输入流：读操作 数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道
‚输出流：写操作 将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道
|
|
字节流 |
字符流 |
|
输入流 |
InputStream |
Reader |
|
输出流 |
OutputStream |
Writer |
read() 从输入流中读取数据的下一个字节（逐字节读取）
read(byte[]) 从输入流中读取一定的字节（如果文件小，读取文件后会有大量的空白）
Stream ：输入输出
InputStream+OutputStream
输入流用于从源读取数据，输出流用于向目标写数据。
FileInputStream：从文件读取数据，它的对象可以用关键字new来创建。
创建一个输入流对象来读取文件：
InputStream f = new FileInputStream("C:/java/hello");
获取文件中内容并显示
注意：不识别\，汉字
注意地址应该写成C:/Users/Administrator/Desktop/HelloWorld.java
或者String fileName="C:\\Users\\Administrator\\Desktop\\HelloWorld.java";
import java.io.*;
public class hello{
public static void main(String [] args)throws IOException{
String fileName="C:"+File.separator+"Users"+File.separator+"Administrator"+File.separator+"Desktop"+File.separator+"HelloWorld.java";
（或者：File f=new File("C:/Users/Administrator/Desktop/HelloWorld.java");
或者String fileName="C:\\Users\\Administrator\\Desktop\\HelloWorld.java";
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
in.read(b);——从输入流中读取一定数量的字节
in.close();
System.out.println(new String(b));
}
}
判断是否读到末尾，读到末尾为-1跳出
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int count =0;
int temp=0;
while((temp=in.read())!=(-1)){
b[count++]=(byte)temp;
}
in.close();
System.out.println(new String(b));
}
}
temp=in.read() 逐字读
temp=in.read()!=-1 没有读到末尾，继续读取
注意：当读到文件末尾的时候会返回-1.正常情况下是不会返回-1的。
向文件中写入字符串
import java.io.*;
public class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
OutputStream out =new FileOutputStream(f);——输出流
String str="Hello World";
byte[] b=str.getBytes();——将String变成byte数组
out.write(b); ——往文件中写入b中字节内容
out.close();——关闭
}
}
逐字节来写入文件中
/**
* 字节流
* 向文件中一个字节一个字节的写入字符串
* */
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
OutputStream out =new FileOutputStream(f);
String str="Hello World！！";
byte[] b=str.getBytes();
for (int i = 0; i < b.length; i++) {
out.write(b[i]);
}
out.close();
}
}
向文件中添加新的内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
OutputStream out =new FileOutputStream(f,true);
//true表示追加模式，否则为覆盖 OutputStream out=FileOutputStream(f,true)
String str="Rollen";
//String str="\r\nRollen"; 可以换行
byte[] b=str.getBytes();
for (int i = 0; i < b.length; i++) {
out.write(b[i]);
}
out.close();
}
}
5.3 字符输入流 reader——FileReader读出
Char
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName="D:"+File.separator+"hello.txt";
File f=new File(fileName);
char[] ch=new char[100];
Reader read=new FileReader(f);
int count=read.read(ch); ——按字符长度读取
read.close();
System.out.println("读入的长度为："+count);
System.out.println("内容为"+new String(ch,0,count));
}
}
5.4 字符输出流 write——写入
5.5 字节转换字符
可访问的修饰符：public、default、protected、private
Default：同一包
Public：所有类可见
Private：同一类可见
Protected：同一包中的类和子类
不可访问的修饰符：final、abstract、strictfp
为了实现一些其他的功能，Java也提供了许多非访问修饰符。
static修饰符，用来创建类方法和类变量。
Final修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
Abstract修饰符，用来创建抽象类和抽象方法。
Synchronized和volatile修饰符，主要用于线程的编程。
导入类：通过包名导入类 java.awt.Frame
Import java.awt.Frame
类名：可能出现重复（就像街道，所以要点名哪里街道：市省）
引入类后通过创建对象才能用呢（对象才是存在的）
Import java.awt.Frame
public class MyTest(){
Public static void main(String args[])
{
（变量）Frame w=new Frame(); -----new通过Frame这个类创建对象
--w就是能装对象的变量，存放对象的地址，指向这个对象
W.show();
w.setSize(300,400);
}
}
栈与堆
栈：薯片桶 先放后吃
堆：无顺序
new: new
源文件—编译成为字节码（中间件文件，而不是0,1）.class 文件
Jvm—运行字节码文件为
Javac.exe —.class 文件
Java.exe
一个文件只有一个类 是public
Java不允许将画直接画在窗体中，而是将画放在画布上 再放在窗体上
画与框架：画画在纸上，用框将其裱起来
提供画布类
为画布类创建对象 将画画在对象上 再将画布放在窗体
类与类的关系：继承
没有内容的画布 继承有内容的画布
Class MyPanel extends Panel
对象：类的实例
类：方法和变量
实例变量：对象都有一个独特的实例变量，对象的状态由实例变量决定
必须先显示声明再使用
8种基本数据操作类型：int 、、、
String 不是基本数据类型
For与while
For：知道循环多少次
While：不知道循环多少次
While（true）死循环 一直循环下去
一个程序有多个不同的片段——进程
五个孩子玩一个车 车—CPU
五个孩子—线程
一个车能哄五个孩子
五个孩子轮着玩车—轮转
车轮着给五个孩子玩，每个时候只有一个孩子玩—CPU轮着给每个线程用，每个时刻只有一个线程
不同的程序：进程
进程：一个独立的程序；一个正在运行的记事本和浏览器属于不同的两个进程
线程：进程运行后，系统会给程序在内存分配独立的空间
在一个进程中能够共同运行的两段代码
run 每个类都可以拥有
Cpu在一些情况下会遇到run
Run也是一个孩子 也希望有车玩
class MyPanel extends Panel implements Runnable{
Public void paint(Graphic g){
} —因为MyPanel继承Panel 所以MyPanel有paint（）
Public void run(){
}—MyPanel没有这个run，哪里来的呢？——就是runnable 系统通过runnable知道有run
}
Import java.awt.*
Public class MyTest{
public static void main(String [] args){
Frame w=new Frame();
w.setSize(300,400);
MyPanel mp=new MyPanel();
w.add(mp);
Thread t=new Thread(mp);
t.start();
w.show();
}
}
标签：
原文地址：http://www.cnblogs.com/Mandy-ywl/p/5588310.html
