一、第一个程序
public class Main{
public static void main(String args[]){
System.out.println("Hello World!");
}
}
二、屏幕输出的几种方式
public class Main{
public static void main(String args[]){
int a = 1;
System.out.println("a表示数字 " + a);
//基于Unicode码，会自带换行符
System.out.print((int)'a');
//进行Ascall码的转换和输出，只能输出字符和数字
System.out.println();
System.out.printf("我是一个例子，我的编号是%d,我的Ascall码为%d",a,(int)'a');
//类似于C的printf(),也是基于Ascall码
}
}
三、import java.util.Scanner类（输出文本控制台）
import java.util.Scanner;
class ScannerTest{
public static void main(String args[]){
Scanner in = new Scanner(system.in);//键盘
int a = in.nextInt();
//nextInt() 整型输入
//nextDouble() 双精度浮点数输入
//next() 单个字符输入
//hasNext() 检测字符输入
//nextLine() 输入字符串
System.out.printf("%d的平方是%d",a,a*a);
//另一种表示方法System.out.println(a+"的平方"+(a*a));
}
}
四、Java.io包
//检测字符
import java.io.IOException;
public class Main{
public static void main(String args[]){
char c = ' ';
System.out.println("Please imput a char");
try{
c = (char)System.in.read();
//读取字符
}catch(IOException e){}
System.out.println("You have entered:"+ c);
}
}
//检测字符串
public class Main{
public static void main(String args[]){
String s = " ";
System.out.println("Please input a string");
try{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//封装成对象
s = in.readLine();
//键盘输入并读取
}catch(IOException e){}
System.out.println("You have entered:"+ s);
}
}
五、强制转换类型
import java.util.Scanner;
public class Main{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
String S;
double n;
S = in.nextLine();
n = Double.parseDouble(S);
//Double.parseDouble() 转化为浮点数类型
//Integer.parseInt() 转化为整型
System.out.println(n);
}
}
六、图形界面输入输出（Frame）
创建Applet程序
关闭键作用：
this.setDefaultCloseOperation(0);
// DO_NOTHING_ON_CLOSE，不执行任何操作。
this.setDefaultCloseOperation(1);
//HIDE_ON_CLOSE，只隐藏界面，setVisible(false)。
this.setDefaultCloseOperation(2);
//DISPOSE_ON_CLOSE,隐藏并释放窗体，dispose()，当最后一个窗口被释放后，则程序也随之运行结束。
this.setDefaultCloseOperation(3);
//EXIT_ON_CLOSE,直接关闭应用程序，System.exit(0)。一个main函数对应一整个程序。
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class AppAppletInOut{
public static void main(String args[]){
new AppFrame();
}
}
class AppFrame extends JFrame{
JTextField in = new JTextField(10);
//输入格大小
JButton btn = new JButton("求平方");
//按钮
JLabel out = new JLabel("用于显示结果");
//文字说明
public AppFrame(){
setLayout(new FlowLayout());
getContentPane().add(in);
getContentPane().add(btn);
getContentPane().add(out);
//激活按钮
btn.addActionListener(new BtnActionAdapter());
//监视按钮，使按钮起作用
setSize(400,100);
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
//关闭按钮
setVisible(true);
//使窗口可见
}
class BtnActionAdapter implements ActionListener {
public void actionPerformed( ActionEvent e) {
String s = in.getText();
double d = Double.parseDouble(s);
double sq = d*d;
out.setText(d +"的平方是： " + sq);
}
}
}
同时作为Application与Applet的程序：
必备三个条件：
1、它是Applet的派生(extends Applet)
2、它含有main(),以便作为Application
3、在main中创建一个用户界面(Frame），并将这个Applet加入。
public class Main extends Applet {
public static void main(String[] args) {
Frame frame = new Frame();
Main app = new Main();
app.init();
frame.add(app);
frame.setSize(400, 100);
//frame.show();
frame.setVisible(true);
}
}
//关闭键不起作用
JDialog窗体是Swing组件中的对话框，它继承了AWT组件中的java.awt.Dialog类。
JDialog的功能是从一个窗体中弹出另一个窗体。
JDialog窗体实质上就是另一种类型的窗体，它与JFrame窗体类似，
在使用时也需要调用getContentPane()方法将窗体转换为容器，然后在容器中设置窗体的特性。
在应用程序中创建JDialog窗体需要实例化JDialog类，通常使用以下几个JDialog类的构造方法。
public JDialog(): 创建一个没有标题和父窗体的对话框。
public JDialog(Frame f):创建一个指定父窗体的对话框，但该窗体没有标题。
public JDialog(Frame f,boolean model):创建一个指定父窗体的对话框，并指定类型，但该窗体没有标题。
public JDialog(Frame f,String title):创建一个指定标题和父窗体的对话框。
public JDialog(Frame f,String title,boolean model):创建一个指定标题、窗体和模式的对话框。
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
class MyJDialog extends JDialog{
public MyJDialog(Main frame)
{
super(frame,"第一个JDialog窗体",true);//实例化一个JDialog类对象，指定对话框的父窗体、窗体标题和类型
Container c = getContentPane();//创建一个容器
c.add(new JLabel("这是一个对话框"));//在容器中添加标签
setBounds(120,120,250,200);//设置对话框窗体大小
}
}
public class Main extends JFrame{
public static void main(String[] args) {
new Main();
}
public Main(){
setTitle("窗体");
setBounds(100,100,300,200);//设置窗体坐标和大小
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
//设置窗体关闭规则，关闭窗口时释放窗体资源
Container c = getContentPane();//创建一个容器
c.setLayout(null);//取消布局管理器
JLabel jl = new JLabel("这是一个JFrame窗体");//在窗体中设置标签
jl.setHorizontalAlignment(SwingConstants.CENTER);//将标签文字设置在标签中间位置
c.add(jl);
JButton bl = new JButton("弹出对话框");
bl.setBounds(40, 40, 100, 20);
bl.addActionListener(new ActionListener() {//为按钮添加鼠标单击事件
public void actionPerformed(ActionEvent e) {
new MyJDialog(Main.this).setVisible(true);//使MYJDialog窗体可见
}
});
c.add(bl);
setVisible(true);//设置窗体为可见
}
}
七、字符类型
//字符的输出
public class Main{
public static void main(String args[]){
char A = '\n'; //char类型只能存储一个字符
System.out.println("这是A代表的意思：" + A);
//输出换行符
char a ='a';
System.out.println("a就是代表字符a：" + a);
char b = 'Z'-'A';
System.out.println("字符Z-字符A得到：" + b);
//不会输出，但转int可表示字符间距
System.out.println("Z-A的Unicode码差为" + (int)b);
//java允许直接转换char类型得到Unicode码
char c = 'd';
System.out.println("字符d和a之间的间隔为" + (c-a));
//数据会先整型化，再输出字符间隔
char d = '\u0041';
//十六进制
System.out.println("\u0041代表字符" + d);
a++;
System.out.println("字符a后的字符为" + a);
//Unicode码按照顺序排列，输出a++代表的当前字符的下一个字符
System.out.println((int)'A');
//A的统一码为65,十六进制即41
System.out.print((char)('a'+('A'-'a')));
System.out.print((char)('A'+('a'-'A')));
//输出大小写转换
}
}
//字符串的输出
public class Main{
public static void main(String args[]){
String s = new String("this ");
String a = "a string";
System.out.println(s+a);
//支持字符串拼接
if(s.equals("this ")){
System.out.println("YES");
//String类应用equals来判断数据是否相同
}
}
}
//字符串switch 1.7版本以上
public class Main{
public static void main(String args[]) {
String a = "a";
switch (a)
{
case "a":System.out.print(123);
break;
default:break;
}
}
}
//字符串的操作
public class Main{
public static void main(String args[]){
String a = "abc";
String b = " ABC ";
System.out.println(a.compareTo(b));
//a小于b输出负数，相等为零，大于为正
System.out.println(a.compareToIgnoreCase(b));
//可以忽略大小写
System.out.println(a.length()+" "+b.length());
System.out.println(a.charAt(2));
//访问index上的单个字符
System.out.println(a.substring(1));
//得到从n到末尾的全部内容
System.out.println(a.substring(0,3));
//得到m到n的全部内容
System.out.println(a.indexOf("b"));
//没有返回-1
System.out.println(a.indexOf("a",1));
System.out.println(a.lastIndexOf(a));
//从右开始检查
System.out.println(a.lastIndexOf("a",3));
//从右第三个开始
System.out.println(a.startsWith("a"));
//检查开头是不是某字符
System.out.println(a.endsWith("c"));
//检查结尾是不是某字符
System.out.println(b.trim());
//去掉两端的空格
System.out.println(a.replace("a","b"));
System.out.println(b.toLowerCase());
System.out.println(a.toUpperCase());
}
}
八、数据类型
public class Main{
public static void main(String args[]){
char VOID; //字符，2字节
int a = 200; //整型
float b; //单精度浮点数，4字节
double B; //双精度浮点数，8字节
short f; //短整型，4字节
long e; //长整型，8字节
byte c; //字节类型，比特,1字节，范围-128~127
boolean d; //逻辑类型，布尔，1字节，只存在0(true)和1(false)两种状态
int a1 = 012;
System.out.println(a1);
//八进制
int a2 = 0X12;
System.out.println(a2);
//十六进制
int a3 = 0B00010010;
System.out.println(a3);
//二进制
double B1 = 123_456.654_321;
System.out.println(B1);
//千分位可以用下划线"_"分隔
double B2 = 3.14e1;
double B3 = 1E1;
System.out.println(B2*B3);
//科学计数法，En代表10^n
long e1 = 3l;
long e2 = 3L;
//声明long型常量
float b1 = 1.0f;
float b2 = 1.0F;
//声明float浮点数
c = (byte)a;
System.out.print(c);
//byte为一字节8位，最高位是符号位，即最大值是01111111，因正数的补码是其本身，即此正数为01111111十进制表示形式为127
//而最小负数为10000000，其反码为01111111，原码为10000000表示-128
//200对应的二进制位111000100，由于int是32位的二进制，而当int转成byte的时候，那么计算机会只保留最后8位，即11001000
//-56 对应正数56（00111000）→所有位取反（11000111）→加00000001(11001000)
//所以输出了-56
}
}
九、注释
十、三目运算符？用法
import java.util.Random;
public class Main{
public static void main(String args[]){
Random r = new Random();
int a = 5;
int b = r.nextInt(10);
int c = a>b?a:b;
System.out.println(c);
System.out.print(b);
}
}
十一、随机数
import java.util.Random;
public class Main{
public static void main(String args[]){
Random r = new Random(5);
//设置种子，设置会固定数值，否则数值会变换
int ran1 = r.nextInt(100);
//获取整数随机数
System.out.println(ran1);
double ran2 = Math.random();
//Math的随机数一般为double类型，介于0.0~1.0之间
System.out.println(ran2);
long ran3 = System.currentTimeMillis();
//方法返回从1970年1月1日0时0分0秒（这与UNIX系统有关）到现在的一个long型的毫秒数，
// 取模之后即可得到所需范围内的随机数
System.out.print(ran3);
}
}
十二、结构语法
public class Main{
public static void main(String args[]){
//if(){}
//else{}
//else if ()
/*
switch(){
case 1:
break;
···
···
default:
}
*/
//while(){}
//continue
//for(int i = 10; i<0 ; i--){}
//do{}while()
}
}
十二、数组运用
import java.util.Scanner;
public class Main{
private int year;
private int month;
private int day;
public Main(int year,int month){
this.year=year;
this.month=month; //this指针指向对象内的数据
}
//构造函数
public static void main(String args[]){
Scanner in = new Scanner(System.in);
**建立对象数组**
Main []dates = new Main[2];
dates[0] = new Main(1 , 2);
dates[1] = new Main(4 , 5); //为数据赋值
System.out.println(dates[0].year+ dates[1].month);
**定义方式**
int a[] = new int[3],i = 2;
//在java中数组只是一个引用类型，不能直接指定数组元素的个数，如：int a[5]在这里就是非法的
//int [] a ,b;
//当数组符号[]在数据项前面时代表定义多个数组，即后面定义的均为数组类型；
System.out.println("这里输出数组的长度 Length ：" + a.length() )
while(i >= 0){
a[i] = in.nextInt();
i--;
}
i++;
**一般输出**
for(;i<3;i++ )
System.out.println(a[i]);
**利用length输出**
for(int j = 0; j < a.length ; j++){
System.out.println(a[j]);
}
**只读性遍历的for语句输出**
for(int A : a){
System.out.println( A );
}
**数组的复制**
int []b = {7,8,9};
System.arraycopy( a , 0 , b , 0 , a.length) ;
//第一个位置是源数组，第二个位置是被复制开始的位置，第三个位置是目的数组，第四个位置是复制开始的位置，第五个位置是复制元素的个数
**多维数组**
int [][] t = new int [2][];
t [0] = new int [2];
t [1] = new int [4];
//和C++不同，Java数组类型为应用，而C++为指针类型，所以像C++语法int t[][] = new int [][2]在这里就属于非法
}
}
十三、类的定义
//类是组成Java程序的基本要素
//是一类对象的原型
//它封装了一类对象的状态和方法（它将变量和方法封装到一个类中）
//字段（field）是类的属性，用变量来表示（字段又称为域，域变量，属性，成员变量）
//方法（method）是类的功能与操作，用函数来表示
import java.util.Scanner;
public class Main {
private String name;
private int age;
//构造方法
//一般情况下，类都有一个至多个构造方法
//如果没有定义任何构造方法，系统会自动产生一个构造方法，称为默认构造方法
//默认构造方法不带参数，并且方法体为空
public Main(){
this("暖羊羊",8,100);
//使用this在当前构造函数中调用另一种构造函数，此条调用语句需要放在第一句
Scanner in = new Scanner(System.in);
name = in.nextLine();
System.out.print("ok");
age = in.nextInt();
}
//一个类如果显式的定义了带参构造函数，那么默认无参构造函数自动失效
//这里父类如果带了参数，那么后继继承的子类就无法使用无参构造函数
public void printEmployee(){
System.out.println("第一个是"+ name + " 年龄" + age );
}
//方法重载：多个方法有相同的名字，编译时能识别出来
//这些方法的签名（方法类型）不同，或者是个数（变量数量）不同，或者是参数类型（变量类型）不同
//通过方法重载可以实现多态
public void printEmployee(int age){
System.out.println("年龄:" + this.age );
}//方法重载
public Main(String name, int age ,int result){}//构造方法重载
public static void main(String args[]) {
//Main Test = new Main();
//如果调用了子类构造函数，就不必再次创建
//System.out.print("OK");
MainSon test = new MainSon("懒羊羊",7);
test.print();
}
}
//使用extends来继承父类，如果没有extends子句则该类默认为java.lang.Object的子类
//继承的好处在于可以提高程序的抽象的抽象程度
//实现代码的重用，提高开发效率和可维护性
class MainSon extends Main
{
private int age;
private String name;
//重新定义了printEmployee函数，对父类printEmployee进行了覆盖
public void printEmployee(){
System.out.println("第二个是"+ name + " 年龄" + age );
}
//因为继承不能继承到父类的构造方法，所以需要定义新的构造函数
//而且子类的对象也属于父类的对象（子类可以使用父类方法），父类的对象不是子类的对象
//如果父类对象引用指向的是一个子类对象，那么这个父类对象的引用可以强制转换成子类对象的应用
public MainSon(String name, int age) {
this.name = name;
this.age = age;
//表示域变量，而name，age只是参数变量
}
public void print(){
super.printEmployee();
//访问父类的方法
this.printEmployee();
//访问该类的方法
}
}
十四、包和导入的定义
package pkg1[.pkg2[.pkg3...]];
1.包及子包的定义，实际上是为了解决名字空间、冲突，它与类的继承没有关系，事实上，一个子类与其父类可以位于不同的包中。
2.包的定义有两方面：一是名字空间，储存路径（文件夹），二是可访问性（同一个包中的各个类，默认情况下可以互相访问）。
3.包层次的根目录是由环境变量CLASSPATH来确定的。
4.在简单情况下，没有package语句，这时称为无名包。
5.像JDK中就有很多包，如：>java.applet、java.awt等等。
import package1[.package2...].(classname|*);1.使用Java包内提供的类，使用import导入所需要的类。
2 使用时，import java.util.Scanner和import java.util,这里使用只能表示本层次的所有类，不包括子层次下的类。
3 java编译器会自动导入java.lang.*javac可以将.class文件放入到相应的目录，只需要一个命令选项-d来指明包的根目录即可，如javac -d d:\tang\ch04 d:\tang\ch04\pk\TestPkg.java，javac -d pk*.java，其中‘.’代表当前目录；运行改程序，需要指明含有的main的类名：java pk.TestPkg。
包的目录是由环境变量CLASSPATH来确定的：
一是在java及javac命令行中，用-classpath d:\tang\ch04;c:\java\classes;.pk.TestPkg。
二是设定classpath环境变量，windows可手动设置，也可用命令行设定，set classpath = d:\tang\ch04;c:\java\classes;
