1.abstracttest
package abstracttest;
/*
* 抽象类和抽象方法
* 抽象类也可以像普通类一样,有构造方法、一般方法、属性,
* 更重要的是还可以有一些抽象方法,留给子类去实现,而且在抽象类中声明构造方法后,在子类中必须明确调用。
*/
abstract public class Abstract {
String name ;
int age ;
String occupation ;
public Abstract(String name){
this.name=name;
}
public Abstract(String name,int age,String occupation)
{
this.name = name ;
this.age = age ;
this.occupation = occupation ;
}
// 声明一抽象方法talk()
public abstract String talk() ;
}
package abstracttest;
public class ExtendAbstract extends Abstract {
public ExtendAbstract(String name) {
super(name);
}
//与一般类相同,在抽象类中,也可以拥有构造方法,但是这些构造方法必须在子类中被调用。
// public ExtendAbstract(String name,int age,String occupation)
// {
// this.name = name ;
// this.age = age ;
// this.occupation = occupation ;
// }
public ExtendAbstract(String name, int age, String occupation) {
super(name, age, occupation);
}
public String talk() {
return "学生——>姓名:"+this.name+",年龄:"+this.age+",职业: 22 "+this.occupation+"!" ;
}
}
package abstracttest;
public class AbstarctTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ExtendAbstract extendabstract=new ExtendAbstract("张三",20,"学生");
System.out.println(extendabstract.talk());
}
}
2.array
package array;
public class ArrayCopy {
/**
* @数组的拷贝
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a1[] = {1,2,3,4,5} ; //声明两个整型数组a1、a2,并进行静态初始化
int a2[] = {9,8,7,6,5,4,3} ;
System.arraycopy(a1,0,a2,0,3); // 执行数组拷贝的操作,System.arrayCopy(source,0,dest,0,x):
//语句的意思就是:复制源数组从下标0开始的x个元素到目标数组,
//从目标数组的下标0所对应的位置开始存取。
System.out.print("a1数组中的内容:");
for(int i=0;i<a1.length;i++) // 输出a1数组中的内容
System.out.print(a1[i]+" ");
System.out.print("\na2数组中的内容:");
for(int i=0;i<a2.length;i++) //输出a2数组中的内容
System.out.print(a2[i] +" ");
System.out.println("\n数组拷贝完成!");
}
}
package array;
import java.util.Arrays;
public class ArraySort {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[] = {4,32,45,32,65,32,2} ;
System.out.print("数组排序前的顺序:");
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
Arrays.sort(a); // 数组的排序方法
System.out.print("\n数组排序后的顺序:");
for(int i=0;i<a.length;i++)
System.out.print(a[i]+" ");
}
}
package array;
public class ArrayTest {
/**
* @数组
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i,min,max;
int A[]={74,48,30,17,62}; // 声明整数数组A,并赋初值
min=max=A[0];
System.out.print("数组A的元素包括: ");
for(i=0;i<A.length;i++)
{
System.out.print(A[i]+" ");
if(A[i]>max) // 判断最大值
max=A[i];
if(A[i]<min) // 判断最小值
min=A[i];
}
System.out.println("\n数组的最大值是:"+max); // 输出最大值
System.out.println("数组的最小值是:"+min); //
}
}
package array;
public class TwoArrayTest {
private static int ss;
static int ii;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int i,j,sum=0;
int num[][]={{30,35,26,32},{33,34,30,29},{22,34,24,56}}; // 声明数组并设置初值
for(i=0;i<num.length;i++) // 输出销售量并计算总销售量
{
System.out.print("第 "+(i+1)+" 个人的成绩为:");
System.out.println(i);
for(j=0;j<num[i].length;j++)
{
System.out.print(num[i][j]+" ");
sum+=num[i][j];
}
System.out.println();
}
System.out.println("总成绩是 "+sum+" 分!");
}
}
3.collection
package collection;
import java.awt.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
public class CollectionDemo {
/**
* Collection操作
*/
public static void main(String[] args) {
//Collection collectionss=(Collection) new List();
//Object[] a=(Object[]) new Object();
Collection collection1=new ArrayList();
//Collection collection1=new LinkedList(); //创建一个集合对象
System.out.println(collection1.add("333"));
collection1.add("000"); //添加对象到Collection 集合中
collection1.add("111");
collection1.add("222");
System.out.println("集合collection1 的大小:"+collection1.size());
System.out.println("集合collection1 的内容:"+collection1);
collection1.remove("000"); //从集合collection1 中移除掉 "000" 这个对象
System.out.println("集合collection1 移除 000 后的内容:"+collection1);
System.out.println("集合collection1 中是否包含000 :"+collection1.contains("000"));
System.out.println("集合collection1 中是否包含111 :"+collection1.contains("111"));
Collection collection2=new ArrayList();
collection2.addAll(collection1); //将collection1 集合中的元素全部都加到collection2中
System.out.println("集合collection2 的内容:"+collection2);
collection2.clear(); //清空集合 collection1 中的元素
System.out.println("集合collection2 是否为空:"+collection2.isEmpty());
//将集合collection1 转化为数组
Object s[]= collection1.toArray();
//Object s[]= collection1.toArray(Object[] a);
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
}
}
package collection;
import java.util.*;
public class IteratorDemo {
/**
* 迭代器
*/
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("s1");
collection.add("s2");
collection.add("s3");
Iterator iterator = collection.iterator();//得到一个迭代器
while (iterator.hasNext()) {//遍历
Object element = iterator.next();
System.out.println("iterator = " + element);
}
if(collection.isEmpty())
System.out.println("collection is Empty!");
else
System.out.println("collection is not Empty! size="+collection.size());
Iterator iterator2 = collection.iterator();
while (iterator2.hasNext()) {//移除元素
Object element = iterator2.next();
System.out.println("remove: "+element);
iterator2.remove();
}
Iterator iterator3 = collection.iterator();
if (!iterator3.hasNext()) {//察看是否还有元素
System.out.println("还有元素:"+iterator.hasNext());
}
if(collection.isEmpty())
System.out.println("collection is Empty!");
//使用collection.isEmpty()方法来判断
System.out.println(collection.size());
}
}
package collection;
import java.util.LinkedList;
public class LinkedListDemo {
/**
* LinkedList
*/
public static void main(String[] args) {
LinkedList linkedlist=new LinkedList();
linkedlist.addFirst("Bernadine");
linkedlist.addFirst("Elizabeth");
linkedlist.addFirst("Gene");
linkedlist.addFirst("Elizabeth");
linkedlist.addFirst("Clara");
System.out.println(linkedlist.get(3));
System.out.println(linkedlist);
linkedlist.removeLast();
linkedlist.removeLast();
System.out.println(linkedlist);
}
}
package collection;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorDemo {
/**
* ListIteratorDemo
*/
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
System.out.println("下标0 开始:"+list.listIterator(0).next()); //next()
System.out.println("下标1 开始:"+list.listIterator(1).next());
System.out.println("子List 1-3:"+list.subList(1,3)); //子列表
ListIterator it = list.listIterator(); //默认从下标0 开始
//隐式光标属性add 操作 ,插入到当前的下标的前面
it.add("sss");
System.out.println(it.next());
System.out.println(it.nextIndex());
System.out.println(it.next());
while(it.hasNext()){
System.out.println("Index="+it.nextIndex()+",Object="+it.next());
}
ListIterator it1 = list.listIterator();
System.out.println(it1.next());
it1.set("ooo");
ListIterator it2 = list.listIterator(list.size());//下标
while(it2.hasPrevious()){
System.out.println("previous Index="+it2.previousIndex()+",Object="+it2.previous());
}
}
}
package collection;
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
/**
*Map
*/
public static void main(String[] args) {
Map map1 = new HashMap();
Map map2 = new HashMap();
map1.put("1","aaa1");
map1.put("2","bbb2");
map2.put("10","aaaa10");
map2.put("11","bbbb11");
//根据键 "1" 取得值:"aaa1"
System.out.println("map1.get(\"1\")="+map1.get("1"));
// 根据键 "1" 移除键值对"1"-"aaa1"
System.out.println("map1.remove(\"1\")="+map1.remove("1"));
System.out.println("map1.get(\"1\")="+map1.get("1"));
map1.putAll(map2);//将map2 全部元素放入map1 中
map2.clear();//清空map2
System.out.println("map1 IsEmpty?="+map1.isEmpty());
System.out.println("map2 IsEmpty?="+map2.isEmpty());
System.out.println("map1 中的键值对的个数size = "+map1.size());
System.out.println("KeySet="+map1.keySet());//set
System.out.println("values="+map1.values());//Collection
System.out.println("entrySet="+map1.entrySet());
System.out.println("map1 是否包含键:11 = "+map1.containsKey("11"));
System.out.println("map1 是否包含值:aaa1 = "+map1.containsValue("aaa1"));
}
}
package collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetDemo {
/**
* @param args
*/
public static void main(String[] args) {
Set set1 = new HashSet();
if (set1.add("a")) {//添加成功
System.out.println("1 add true");
}
if (set1.add("a")) {//添加失败
System.out.println("2 add true");
}
set1.add("000");//添加对象到Set 集合中
set1.add("111");
set1.add("222");
System.out.println("集合set1 的大小:"+set1.size());
System.out.println("集合set1 的内容:"+set1);
set1.remove("000");//从集合set1 中移除掉 "000" 这个对象
System.out.println("集合set1 移除 000 后的内容:"+set1);
System.out.println("集合set1 中是否包含000 :"+set1.contains("000"));
System.out.println("集合set1 中是否包含111 :"+set1.contains("111"));
Set set2=new HashSet();
set2.add("111");
set2.addAll(set1);//将set1 集合中的元素全部都加到set2 中
System.out.println("集合set2 的内容:"+set2);
set2.clear();//清空集合 set1 中的元素
System.out.println("集合set2 是否为空:"+set2.isEmpty());
Iterator iterator = set1.iterator();//得到一个迭代器
while (iterator.hasNext()) {//遍历
Object element = iterator.next();
System.out.println("iterator = " + element);
}
//将集合set1 转化为数组
Object s[]= set1.toArray();
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
}
}
4.configuration
package configuration;
public class ConfigTest {
/**
* Configuration配置文件测试
*/
public static void main(String[] args) {
String name=new ConfigUtil("config.properties").getValue("name");
System.out.println(name);
}
}
package configuration;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 读取properties配置文件
*/
public class ConfigUtil {
private Properties propertie;
private InputStream inputFile;
/**
* 初始化Configuration类
*/
public ConfigUtil()
{
propertie = new Properties();
}
/**
* 初始化Configuration类
* @param filePath 要读取的配置文件的路径+名称
*/
public ConfigUtil(String filePath)
{
propertie = new Properties();
try {
inputFile = this.getClass().getClassLoader().getResourceAsStream(filePath);
propertie.load(inputFile);
inputFile.close();
} catch (FileNotFoundException ex) {
System.out.println("读取属性文件--->失败!- 原因:文件路径错误或者文件不存在");
ex.printStackTrace();
} catch (IOException ex){
System.out.println("装载文件--->失败!");
ex.printStackTrace();
}
}
/**
* 重载函数,得到key的值
* @param key 取得其值的键
* @return key的值
*/
public String getValue(String key)
{
if(propertie.containsKey(key)){
String value = propertie.getProperty(key);//得到某一属性的值
return value;
}
else{
System.out.println("配置文件中不包含该键值对!");
return "";
}
}
}
5.DataType
package DataType;
public class CharTest {
/**
* @char类型
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
char ch1 = 97 ;
char ch2 = 'a' ;
System.out.println("ch1 = "+ch1);
System.out.println("ch2 = "+ch2);
}
}
package DataType;
public class Default {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
byte num1 = 0;
short num2 = 0;
int num3 = 0;
long num4 = 0L;
float num5=0.0f;
double num6=0.0d;
char num7='\u0000';
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
System.out.println(num5);
System.out.println(num6);
System.out.println(num7);
}
}
package DataType;
public class DobleAndFloat {
/**
* @
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double num1 = 6.3e64D ; // 声明num1为double,其值为-6.3×1064
double num2 = 5.34E16d ; // e也可以用大写的E来取代
float num3 = 7.32E2f ; // 声明num3为float,并设初值为7.32f
float num4 = 2.0E38f;
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
}
}
package DataType;
public class Escape {
/**
* @输出双引号等转义字符
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
char ch ='\"';
System.out.println(ch+"测试转义字符!"+ch);
System.out.println("\"hello world!\"");
}
}
package DataType;
public class IntTest {
/**
* @整数数据类型
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
long num =2147483648L; // 声明一长整型变量
System.out.println("num="+num);
int x = java.lang.Integer.MAX_VALUE ;
System.out.println("x = "+x);
System.out.println("x + 1 = "+(x+1));
System.out.println("x + 2 = "+(x+2L));
System.out.println("x + 3 = "+((long)x+3));
}
}
6.file
package file;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
public class CopyFile {
/**
* 文件拷贝和显示文件列表
*/
public static void main(String[] args) {
String filePath1="D:/test/1/1.txt";
String filePath2="D:/test/2/2.txt";
String filePath3="D:/test/";
try {
copy(filePath1,filePath2);
//listFile(filePath3);
} catch (Exception e) {
e.printStackTrace();
}
}
/*
* 文件拷贝
*/
public static void copy(String srcPath,String desPath) throws Exception{
String folderPath="D:/test/1/1";
File folder=new File(folderPath);
//folder.mkdir();
File srcFile=new File(srcPath);
File desFile=new File(desPath);
//srcFile.delete();
// BufferInputStream bis=new BufferInputStream(srcFile); //字节流
// BufferOutputStream bos=new BufferOutputStream(desPath); //字节流
FileInputStream fis= new FileInputStream(srcFile); //字节流
InputStreamReader isr=new InputStreamReader(fis);
BufferedReader br=new BufferedReader(isr); //字符流
FileOutputStream fos= new FileOutputStream(desFile); //字节流
OutputStreamWriter ow=new OutputStreamWriter(fos);
BufferedWriter bw=new BufferedWriter(ow); //字符流
//PrintWriter pw=new PrintWriter(ow);
int c;
while((c=fis.read())!=-1){
bw.write(c);
}
bw.close();
fos.close();
}
/*
* 文件列表,包括文件夹中的文件
*/
private static void listFile(String path) throws Exception{
File file=new File(path);
File files[]=file.listFiles();
for(int i=0;i<files.length;i++){
if(files[i].isDirectory()){
listFile(path+files[i].getName());
}
//System.out.println(files[i].getName());
//System.out.println(files[i].toString());
System.out.println(files[i].getPath());
}
}
}
package file;
public class Static {
static {
System.out.println(1111);
}
/**
* 外部类和主类(main类)执行顺序
*/
public Static(){
System.out.println("主类的构造方法");
}
public static void main(String[] args) {
S.say();
new S().say2();
say3();
}
static class S{
public S(){
System.out.println("S的构造方法");
}
static void say(){
System.out.println("say hello");
}
void say2(){
System.out.println("say hello2");
}
}
static void say3(){
System.out.println("say hello3");
}
}
7.huiwen
package huiwen;
import java.applet.Applet;
import java.awt.Event;
import java.awt.Label;
import java.awt.TextField;
/**
* 回文
* @author Bryant
*
*/
public class Huiwen extends Applet {
Label prompt;
TextField input;
int data;
public void init() {
prompt = new Label("输入数字");
input = new TextField(4);
add(prompt);
add(input);
}
public boolean action(Event e, Object o) {
int data = Integer.parseInt(input.getText());
showStatus("");
input.setText("");
int count = 0;
String[] arr = new String[1000000];
while (data != 0) {
arr[count] = String.valueOf(data % 10);
data = data / 10;
count++;
}
int j = count - 1;
boolean flag = true;
for (int i = 0; i < count / 2; i++, j--) {
if (!arr[i].equals(arr[j])){
showStatus("不是回文数");
flag = false;
}
}
if(flag){
showStatus("是回文数");
}
repaint();
return true;
}
}
package huiwen;
import java.applet.Applet;
import java.awt.Event;
import java.awt.Label;
import java.awt.TextField;
/**
* 回文(比第一个省内存)
* @author Bryant
*
*/
public class Huiwen2 extends Applet {
Label lable;
TextField input;
public void init() {
lable = new Label("输入数字");
input = new TextField(100);
add(lable);
add(input);
}
public boolean action(Event e, Object o) {
String text = input.getText().trim();
showStatus("");
input.setText("");
StringBuilder sb = new StringBuilder(text);
if (sb.reverse().toString().equals(text)) {
showStatus("不是回文数");
} else {
showStatus("是回文数");
}
repaint();
return true;
}
}
8.innerclass
package innerclass;
/*
* 内部类的使用
*/
public class OuterClass {
int score=100;
void inst(){
Inner in=new Inner();
in.display();
}
public class Inner{ //内部类也可以通过创建对象从外部类之外被调用,只要将内部类声明为public即可
void display(){
String name="zhangsan";
System.out.println("score="+score);//内部类可以直接调用外部类的属性
}
}
public static class Inner2{
void display(){
String name="zhangsan";
//System.out.println("score="+score); //用static也可以声明内部类,用static声明的内部类则变成外部类,
//但是用static声明的内部类不能访问非static的外部类属性。
}
}
// void print(){
// System.out.println("name="+name); //外部类不能使用内部类的属性
// }
}
package innerclass;
public class OuterClassTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
OuterClass out=new OuterClass();
out.inst();
OuterClass.Inner innner=out.new Inner();
innner.display();//内部类也可以通过创建对象从外部类之外被调用,只要将内部类声明为public即可
}
}
package innerclass;
/*
* 在外部类方法中定义内部类
*/
public class OuterClass2 {
int score = 95;
void inst()
{
class Inner
{
void display()
{
System.out.println("成绩: score = " + score);
}
}
Inner in = new Inner();
in.display();
}
}
package innerclass;
public class OuterClassTest2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
{
OuterClass2 outer = new OuterClass2();
outer.inst() ;
}
}
}
package innerclass;
/*
* 在方法中定义的内部类只能访问方法中的final类型的局部变量,
* 因为用final定义的局部变量相当于是一个常量,它的生命周期超出方法运行的生命周期.
*/
public class OuterClass3 {
int score = 95;
void inst(final int s)
{
final int temp = 20 ;
class Inner
{
void display()
{
System.out.println("成绩: score = " + (score+s+temp));
}
}
Inner in = new Inner();
in.display();
}
}
package innerclass;
public class OuterClassTest3 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
OuterClass3 outer=new OuterClass3();
outer.inst(5);
}
}
package innerclass;
public class SetApple {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
apple a=new apple();
a.appleweight=0.5;
System.out.println("苹果重1两");
System.out.println(a.bite());
a.appleweight=5;
System.out.println("苹果重5两");
System.out.println(a.bite());
}
}
//内部类
class apple{
long applecolor;
double appleweight;
boolean eatup;
public boolean bite(){
if(appleweight<1){
System.out.println("苹果已经吃完了");
eatup=true;
}else{
System.out.println("苹果吃不下了");
eatup=false;
}
return eatup;
}
}
package innerclass;
public class TestExtend extends Employee {
/**
* @param args
*/
public TestExtend(String name,int salary){
super(name,salary);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("覆盖的方法调用" + getSalary("张三",500));
System.out.println("继承的方法调用" + getSalary2("李四",500));
System.out.println("覆盖的方法调用" + getSalary("张三",10000));
System.out.println("继承的方法调用" + getSalary2("李四",10000));
}
public static String getSalary(String name, int salary) //重写父类的方法(覆盖的方法)
{
String str;
if (salary>5000)
str = "名字" + name + "Salary: " + salary;
else
str = "名字" + name + "Salary:低于5000";
return str;
}
public String getSalary3(){
return getSalary();
}
};
class Employee //父类
{
//public String name;//
//public int salary;//
private String name;// 如果把 变量设为private,即私有化变量,则需要增加构造函数初始化类
private int salary;//
public Employee(String _name,int _salary){
name=_name;
salary=_salary;
}
public static String getSalary(String name, int salary)
{
String str;
str = "名字" + name + "Salary: " + salary;
return str;
}
public static String getSalary2(String name, int salary)
{
String str;
str = "名字" + name + "Salary: " + salary;
return str;
}
public String getSalary(){
String str;
str = "名字" + name + "Salary: " + salary;
return str;
}
};
9.io
package io;
import java.io.*;
public class SystemIo {
/**
* @System.in
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int bytes = 0;
byte buf[] = new byte[255];
System.out.print("请输入您的文本:");
try{
bytes = System.in.read(buf,0,255);
System.out.print(bytes);
System.out.println("");
String inStr = new String(buf,0,bytes);
System.out.println(inStr);
}catch(IOException e){
System.out.println(e.getMessage());
}
}
}
10.local
package local;
import java.util.Locale;
public class LocaleList {
/**
* @param args
*/
public static void main(String[] args) {
//返回Java 所支持的全部国家和语言的数组
Locale[] localeList = Locale.getAvailableLocales();
//遍历数组的每个元素,依次获取所支持的国家和语言
for (int i = 0; i < localeList.length ; i++ )
//打印出所支持的国家和语言
System.out.println(localeList[i] .getDisplayCountry() + "=" +
localeList[i] .getCountry()+ " " +
localeList[i] .getDisplayLanguage() + "=" +localeList[i] .getLanguage());
}
}
11.main
package main;
public class MainMethod {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int j = args.length ;
if(j!=2)
{
System.out.println("输入参数个数有错误!") ;
// 退出程序
System.exit(1) ;
}
for (int i=0;i<args.length ;i++ )
{
System.out.println(args[i]) ;
}
}
}
12.privatetest
package privatetest;
public class Change {
int x=0;
}
package privatetest;
public class ChangeTest {
/**
* @引用数据类型 传递修改值(改变值,值类型不改变)
* 在fun方法中所做的操作,是会影响原先的参数
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Change c = new Change() ;
c.x = 20 ;
fun(c) ;
System.out.println("x = "+c.x);
}
public static void fun(Change c1)
{
c1.x = 25 ;
}
}
package privatetest;
public class Person {
String name ;
int age ;
}
package privatetest;
/*
* 封装
*/
public class PersonPrivate {
private String name ;
private int age ;
private static void talk()
{
//System.out.println("我是:"+name+",今年:"+age+"岁");
}
public void say()
{
talk();
}
public void setName(String str)
{
name = str ;
}
public void setAge(int a)
{
if(a>0)
age = a ;
}
public String getName()
{
return name ;
}
public int getAge()
{
return age ;
}
}
package privatetest;
public class PersonTest {
/**
* @引用数据类型值传递(改变值)
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 声明一对象p1,此对象的值为null,表示未实例化
Person p1 = null ;
// 声明一对象p2,此对象的值为null,表示未实例
Person p2 = null ;
// 实例化p1对象
p1 = new Person() ;
// 为p1对象中的属性赋值
p1.name = "张三" ;
p1.age = 25 ;
// 将p1的引用赋给p2
p2 = p1 ;
// 输出p2对象中的属性
System.out.println("姓名:"+p2.name);
System.out.println("年龄:"+p2.age);
//p2=null;
p1 = null ;
// System.out.println("姓名:"+p1.name);
// System.out.println("年龄:"+p1.age);
p2.name="李四";
System.out.println("姓名:"+p2.name);
}
}
package privatetest;
/*
* 构造方法私有化
*/
public class PublicToPrivate {
private PublicToPrivate()
{
System.out.println("private TestSingleDemo1 .") ;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
new PublicToPrivate() ;
}
}
13.randow
package randow;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Randow {
/**
* 生成随机数
*/
public static void main(String[] args) {
// int[] ints = new int[100];
// for(int i=0;i<100;i++) {
// int temp = (int) (Math.random()*100+1);
// for(int j=0;j<i;j++) {
// if(temp==ints[j]) {
// temp = (int) (Math.random()*100+1);
// j=0;
// }
// }
// ints[i]=temp;
// }
// Arrays.sort(ints);
// for(int index:ints) {
// if(index%10==0)
// System.out.println();
// System.out.print(index+" ");
// }
//随机生成不重复的两位数
String result="";
String str[]={"0","1","2","3","4","5","6","7","8","9"};
Random r=new Random();
while(result.length()<=1){
int i=r.nextInt(10);
if(result.indexOf(str[i])==-1){
result=result+str[i];
}
}
// System.out.println(result);
validateCode(2);
getNum();
random2();
}
//生产2位随机数
public static void validateCode(int code_len) {
int count = 0;
char str[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
StringBuffer pwd = new StringBuffer("");
Random r = new Random();
while (count < code_len) {
int i = Math.abs(r.nextInt(10));
//int j = Math.abs(r.nextInt(10));
if (i >= 0 && i < str.length) {
pwd.append(str[i]);
count++;
}
}
// System.out.println(pwd.toString());
String pwd2="";
//return pwd.toString();
}
/**
* 产生两位不重复的随机数
*
* @return
*/
protected static void getNum() {
Map<String, String> map = new HashMap<String, String>();
for (int i = 0; i < 99; i++) {
String key = i < 10 ? "0" + i : i + "";
map.put(key, key);
}
String num = getRandom();
if (map.containsKey(num)) {
getNum();
}else{
System.out.println(num);
}
}
public static String getRandom() {
String str = "";
Random random = new Random();
int num = random.nextInt(100);
if (num < 10) {
str = "0" + num;
} else {
str = num + "";
}
//System.out.println(str);
return str;
}
public static int[] random2(){
int send[]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21};
int temp1,temp2,temp3;
Random r=new Random();
for(int i=0;i<send.length;i++){
temp1=Math.abs(r.nextInt())%(send.length-1);
temp2=Math.abs(r.nextInt())%(send.length-1);
if(temp1!=temp2){
temp3=send[temp1];
send[temp1]=send[temp2];
send[temp2]=temp3;
}
}
//System.out.println(send);
return send;
}
}
14.recursion
package recursion;
public class RecursionTest {
/**
* 递归
* @param args
*/
int sum=0;
int a=0;
public void sum(){
sum+=a;
a+=1;
if(a<5){
sum();
}
}
public static void main(String[] args) {
RecursionTest test=new RecursionTest();
test.sum();
System.out.println("计算结果为:"+test.sum);
}
}
15.statictest
package statictest;
/*
* static静态变量的使用
*/
public class Person {
String name ;
static String city = "中国";
int age ;
static int count=0 ;
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public String talk()
{
return "我是:"+this.name+",今年:"+this.age+"岁,来自:"+city;
}
public Person()
{
count++ ; // 增加了一个对象
System.out.println("产生了:"+count+"个对象!");
talk();
}
}
package statictest;
public class StaticPersonTest {
/**
* static 静态变量修改的是所有对象的属性
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Person p1 = new Person("张三",25) ;
Person p2 = new Person("李四",30) ;
Person p3 = new Person("王五",35) ;
System.out.println("修改之前信息:"+p1.talk()) ;
System.out.println("修改之前信息:"+p2.talk()) ;
System.out.println("修改之前信息:"+p3.talk()) ;
System.out.println(" ************* 修改之后信息 **************");
// 修改后的信息
p1.city = "美国" ;
p1.name="wangliu";
//只有静态变量才可以用类名直接调用
//Person.city="呵呵";
System.out.println("修改之后信息:"+p1.talk()) ;
System.out.println("修改之后信息:"+p2.talk()) ;
System.out.println("修改之后信息:"+p3.talk()) ;
new Person().talk();
//new Person();
}
}
package statictest;
/*
* 静态方法的使用(静态方法调用的变量只能是静态的),静态方法调用非静态方法必须实例化
*/
public class Person2 {
String name ;
private static String city = "中国";
int age ;
public Person2(String name,int age)
{
this.name = name ;
this.age = age ;
}
public Person2()
{
}
//静态变量既可以在静态方法中使用,也可在非静态方法中使用。
public String talk()
{
return "我是:"+this.name+",今年:"+this.age+"岁,来自:"+city;
//return null;
//非静态方法不能调用静态方法(错,可以)
//setCity("");
}
public void talk2(){
setCity("");
}
public static void setCity(String c)
{
//静态方法中不能使用this
//this.city=c;
//静态方法调用的变量只能是静态的
//name=c;
city = c ;
//静态方法调用非静态方法必须实例化
new Person2().talk();
}
}
package statictest;
public class StaticPersonTest2 {
/**
* static 静态方法的调用
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Person2 p1 = new Person2("张三",25) ;
Person2 p2 = new Person2("李四",30) ;
Person2 p3 = new Person2("王五",35) ;
System.out.println("修改之前信息:"+p1.talk()) ;
System.out.println("修改之前信息:"+p2.talk()) ;
System.out.println("修改之前信息:"+p3.talk()) ;
System.out.println(" ************* 修改之后信息 **************");
// 修改后的信息
//p1.city = "美国" ;
//只有静态变量才可以用类名直接调用
Person.city="呵呵";
Person2.setCity("美国") ;
System.out.println("修改之后信息:"+p1.talk()) ;
System.out.println("修改之后信息:"+p2.talk()) ;
System.out.println("修改之后信息:"+p3.talk()) ;
//调用类的方法是调用无参的构造方法,或者不写构造方法,直接实例化后调用
new Person2().talk();
}
}
package statictest;
/*
* 静态代码块(首先被执行)
*/
public class Person3 {
public Person3()
{
System.out.println("1.public Person()");
}
// 此段代码会首先被执行
static
{
System.out.println("2.Person类的静态代码块被调用!");
}
}
package statictest;
/*
* 静态代码块首先被执行
*/
public class StaticPersonTest3 {
static
{
System.out.println("3.TestStaticDemo5类的静态代码块被调用!");
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("4.程序开始执行!");
// 产生两个实例化对象
new Person3() ;
}
}
16.string
package string;
public class StringDemo {
/**
* 由程序输出结果可以发现,str1与str3相等,这是为什么呢?
* 还记得上面刚提到过“==”是用来比较内存地址值的。现在str1与str3相等,则证明str1与str3是指向同一个内存空间的。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String str1 = "java" ;
String str2 = new String("java") ;
String str3 = "java" ;
System.out.println("str1 == str2 ? --- > "+(str1==str2)) ;
System.out.println("str1 == str3 ? --- > "+(str1==str3)) ;
System.out.println("str3 == str2 ? --- > "+(str3==str2)) ;
}
}
package string;
public class StringTest1 {
/**
* ==号比较内存地址值是否相同
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String str1 = new String("java") ;
String str2 = new String("java") ;
String str3 = str2 ;
if(str1==str2)
{
System.out.println("str1 == str2");
}
else
{
System.out.println("str1 != str2") ;
}
if(str2==str3)
{
System.out.println("str2 == str3");
}
else
{
System.out.println("str2 != str3") ;
}
}
}
package string;
public class StringTest2 {
/**
* equals比较2个对象的内容是否一致
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String str1 = new String("java") ;
String str2 = new String("java") ;
String str3 = str2 ;
if(str1.equals(str2))
{
System.out.println("str1 equals str2");
}
else
{
System.out.println("str1 not equals str2") ;
}
if(str2.equals(str3))
{
System.out.println("str2 equals str3");
}
else
{
System.out.println("str2 note equals str3") ;
}
}
}
17.supertest
package supertest;
/*
* 继承
*/
public class Person {
String name;
int age;
public Person()
{
System.out.println("1.public Person(){}") ;
}
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
public void talk(){
}
}
package supertest;
public class Student extends Person {
String school ;
// 子类的构造方法
public Student()
{
super("张三",25);
System.out.println("2.public Student(){}");
}
}
package supertest;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Student s = new Student() ;
s.school="北京";
System.out.println("姓名:"+s.name+",年龄:"+s.age+",学校:"+s.school);
}
}
18.test
package test;
public class EqualsTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String s1="hello";
String s2="hello";
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
String s3=new String("hello");
String s4=new String("hello");
System.out.println(s3==s4);
System.out.println(s3.equals(s4));
char b=97;
System.out.println(b);
}
}
19.thistest
package thistest;
/*
* this 调用构造方法,只能放在首行
*/
public class Person {
String name ;
int age ;
public Person()
{
System.out.println("1. public Person()");
}
public Person(String name,int age){
// 调用本类中无参构造方法
this() ;
this.name = name ;
this.age = age ;
System.out.println("2. public Person(String name,int age)");
}
}
package thistest;
public class ThisPersonTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
new Person("张三",25) ;
}
}
20.thread
package thread;
public class MyThread {
/**
* 主线程
*/
public static void main(String[] args) {
ThreadDemo t1=new ThreadDemo("实例线程1");
t1.startthread();
//t1.runthread();
ThreadDemo t2=new ThreadDemo("实例线程2");
t2.startthread();
//t2.runthread();
}
}
package thread;
public class ThreadDemo extends Thread {
Thread thread;
String str;
//构造函数
public ThreadDemo(String str1){
this.str=str1;
}
//启动线程
public void startthread(){
thread=new Thread(this);
thread.start();
}
public void runthread(){
int i=0;
while(thread!=null){
try{
if(i==5)
sleep(10000);
}catch(Exception e){
System.out.print(e.getMessage());
}
System.out.println(str);
i++;
}
}
}
package thread;
public class TwoThreadDemo extends Thread {
//String name;
/**
* 静态方法调用非静态方法必须实例化
*/
public static void main(String[] args) {
TwoThreadDemo tt = new TwoThreadDemo();
tt.start();
for ( int i = 0; i < 3; i++ ) {
System.out.println("Main thread");
}
new TwoThreadDemo().run1();
run2();
}
// public TwoThreadDemo(String name){
// this.name=name;
// }
public void run() {
for ( int i = 0; i < 3; i++ ) {
System.out.println("Run thread");
}
}
public void run1() {
for ( int i = 0; i < 3; i++ ) {
System.out.println("New thread");
}
// run2();
}
public static void run2(){
for ( int i = 0; i < 3; i++ ) {
System.out.println("My thread");
}
}
}
package thread;
//设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1
//以下程序使用内部类实现线程,对j增减的时候没有考虑顺序问题
public class ThreadTest{
private int j;
public static void main(String args[]){
ThreadTest tt=new ThreadTest();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();
}
}
}
class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
}
}
}