1.Collection中常见方法的案例.
1.创建测试类
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class Demo {
public static void main(String[] args) {
int arr[] = { 1, 2, 3 };
// 第一种方法foreach语句
for (int a : arr) {
System.out.println(a);
}
// 第二种方法多态
List<String> list = new Vector<String>();
list.add("one");
list.add("two");
list.add("three");
for (String temp : list) {
System.out.println(temp);
}
//第三种方法
Iterator<String> it = list.iterator(); // 返回一个迭代器
while (it.hasNext()) {// 判断是否有下一个元素
String t = it.next();// 获取下一个元素
System.out.println(t);
}
// 第四种方法转换成数组处理
Object objs[] = list.toArray();
for (Object obj : objs) {
String tt = (String) obj;
System.out.println(tt);
}
// 第五种方法直接转换成指定数组类型
String strs[] = list.toArray(new String[0]);
System.out.println("-------------------");
for (String str : strs) {
System.out.println(str);
}
System.out.println("-------Integer------------");
// 第六种方法写方式
Integer arrs[] = new Integer[] { 1, 2, 3 };// 3
List<Integer> i = Arrays.asList(arrs);
for (Integer in : i) {
System.out.println(in);
}
System.out.println("长度" + i.size());
if (i.contains(1)) {
System.out.println("含有1");
} else {
System.out.println("不含有1");
}
}
}
2. ArrayList的案例
1.创建测试类
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo1 {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加数据
list.add("three");
list.add("one");
list.add("two");
list.add(null);
list.add("a");
list.add("b");
list.add(null);
list.add("c");
list.add(null);
//通过迭代器,迭代数据
Iterator<String> lit = list.iterator();
while(lit.hasNext()){
System.out.println(lit.next());
}
//指定位置插入数据
list.add(1, "xxxx");//o(n-i)
//for循环迭代
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
}
3. LinkedList的案例
1.测试类
import java.util.Iterator;
import java.util.LinkedList;
public class Demo2 {
public static void main(String[] args) {
// List 接口的链接列表实现
LinkedList<String> list = new LinkedList<String>();
/*
list.add("three");
list.add("one");
list.add("two");
list.add(null);
list.add("a");
list.add("b");
list.add(null);
list.add("c");
list.add(null);*/
list.push("one");
list.push("two");
list.push("three");
list.push("four");
// 通过迭代器,迭代数据
/*Iterator<String> lit = list.iterator();
while (lit.hasNext()) {
System.out.println(lit.next());
}*/
// 指定位置插入数据
/*list.add(1, "xxxx");// o(n-i)
// for循环迭代
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}*/
Iterator<String> lit = list.iterator();
while(lit.hasNext()){
System.out.println(list.pop());
}
System.out.println(list.size()+"---------");
}
}
4. Vector案例
1.测试类
import java.util.Vector;
public class Demo3 {
public static void main(String[] args) {
//ArrayList<String> v = new ArrayList<String>(); //10
Vector<String> v = new Vector<String>();//10
//同步
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");
//观察Vector是以 成倍增长的效果,ArrayList看不出效果但是以50%的增长.
System.out.println(v.size()+"--"+v.capacity());
}
}
5. HashSet类案例
1.测试类
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Demo4 {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();//ctrl+shift+O导包
set.add("one");
set.add("one");
set.add("two");
set.add("three");
set.add("four");
/*for(int i=0;i<set.size();i++){
set.
}*/
System.out.println("长度::::"+set.size());
Iterator<String> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
2.测试类
1.创建实体类
public class Employee {
private int cardId;
public Employee(int cardId) {
this.cardId = cardId;
}
@Override
public boolean equals(Object obj) {
// 判断是否为空
if (obj == null) {
return false;
}
// 判断是否是Emploee的类型
if (obj instanceof Employee) {
// 造型
Employee e = (Employee) obj;
if (e.cardId == this.cardId) {
System.out.println("xxxxxxxxxxxx");
return true;
}
}
return false;
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return cardId;
}
@Override
public String toString() {
return "Employee [cardId=" + cardId + "]";
}
}
2.创建集合类测试
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Demo5 {
public static void main(String[] args) {
Set<Employee> set = new HashSet<Employee>();
set.add(new Employee(1));
set.add(new Employee(2));
set.add(new Employee(3));
set.add(new Employee(4));
set.add(new Employee(1));
System.out.println("长度:::"+set.size());
Iterator<Employee> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next().toString());
}
}
}
6 .TreeSet类案例
1.创建测试类
import java.util.Iterator;
import java.util.TreeSet;
public class Demo6 {
public static void main(String[] args) {
//创建对象
TreeSet<String> set = new TreeSet<String>();
//添加数据
set.add("f");
set.add("y");
set.add("A");
set.add("Z");
System.out.println("长度::::"+set.size());
System.out.println("第一个元素:"+set.first());
System.out.println("最后个元素:"+set.last());
System.out.println("--------------------");
Iterator<String> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
7.数组字符排序案例
1.数组字符排序案例
import java.util.Arrays;
import java.util.Collections;
public class Demo7 {
public static void main(String[] args) {
//排序
String demos[]={"hello","chenhj","test","中国"};
/*Arrays.sort(demos, new StringComparator());
for(String demo:demos){
System.out.println(demo);
}*/
/*Collections.sort(Arrays.asList(demos));
for(int i=0;i<demos.length;i++){
System.out.println(demos[i]);
}*/
Arrays.sort(demos);
for(int i=0;i<demos.length;i++){
System.out.println(demos[i]);
}
}
}
2.所依赖的Comparator
import java.util.Comparator;
public class StringComparator implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
// TODO Auto-generated method stub
return o1.compareTo(o2);
}
}
8. TreeSet排序案例
1.集合依赖的实体Bean
public class Student implements Comparable {
private String name;
public Student(String name) {
this.name=name;
}
@Override
public String toString() {
return "Student [name=" + name + "]";
}
@Override
public int compareTo(Object obj) {
Student stu = (Student) obj;
return this.name.compareTo(stu.name);
}
}
2.集合测试类排序测试
import java.util.Iterator;
import java.util.TreeSet;
public class Demo8 {
public static void main(String[] args) {
Student stu1 = new Student("举个");
Student stu2 = new Student("过量");
Student stu3 = new Student("泽董");
Student stu4 = new Student("林山");
Student stu5 = new Student("东方不败");
TreeSet<Student> set = new TreeSet<Student>();
set.add(stu1);
set.add(stu2);
set.add(stu3);
set.add(stu4);
set.add(stu5);
Iterator<Student> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next().toString());
}
}
}
9. equals的案例.
1.创建Animal类
package day07;
public class Animal {
private String name;// 作为唯一的标识
// 带有参数的构造器
public Animal(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
/**
* 重新改变两个对象的相等的方式. 根据名称处理,如果名称相等,那个这两个对象就应该相等。
*/
@Override
public boolean equals(Object obj) {
// this obj
// 1.首先判断obj是否等于null值
if (obj == null) {
return false;
}
// 2.判断obj是否是 animal类型
if (obj instanceof Animal) {
// 3.造型对象
Animal animal = (Animal) obj;
// 4.自定义判断的条件
if (this.name.equals(animal.name)) {
return true;
}
}
return true;
}
/*
* @Override public int hashCode() {
*
* return 1; }
*/
public static void main(String[] args) {
Animal animal1 = new Animal("红军");
Animal animal2 = new Animal("红军");
if (animal1.equals(animal2)) {
System.out.println("相等---------------");
} else {
System.out.println("不相等-------------");
}
Animal animal3 = animal2;
if (animal2.equals(animal3)) {
System.out.println("相等---------------");
} else {
System.out.println("不相等-------------");
}
// 总结1.如果两个对象 equals相等 ==判断的值不一定相等。
// 总结2.如果==判断的值相等. equals一定相等 (错)
System.out.println(animal1 == animal2);
System.out.println(animal2 == animal3);
}
}
2.创建另外的测试类
package day07;
import java.util.HashSet;
import java.util.Set;
public class Test {
public static void main(String[] args) {
Animal animal1 = new Animal("小三");
Animal animal2 = new Animal("小三");
Animal animal3 = new Animal("小四");
Animal animal4 = new Animal("小五");
// Animal animal5=animal3; // ==
// hascode 值 相等
// equals 值 false
//看集合数量 4
// hascode 值不等
// equals true
// 看集合数量4
// hascode 值不等
// equals false
// 看集合数量4
// hascode 值 相等
// equals true
// 看集合数量1
// 在不重写equal方法的时候,再看
// 4 a1.equals(a2)处理 操作的
// set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2,并且最多包含一个 null 元素
Set<Animal> animals = new HashSet<Animal>();
animals.add(animal1);
animals.add(animal2);
animals.add(animal3);
animals.add(animal4);
// animals.add(animal5);
if (animal1.equals(animal2)) {
System.out.println("xxxxxxz");
} else {
System.out.println("xxxxxd");
}
System.out.println(animals.size());
}
}
10.String中==与equals的案例
1.创建测试类
package day07;
public class StrDemo {
public static void main(String[] args) {
//创建一个对象 str
String str = new String();
str="xxxx";// xxxx 常量值
String str1= "xxxx";
String str2="xxxx";
System.out.println(str1==str2);
System.out.println(str==str1);
String demo = new String("xxxx");//创建2个对象 demo对象 xxxx对象
System.out.println(demo==str1);
System.out.println(demo==str);
System.out.println(demo.intern()==str1);
System.out.println(demo.equals(str1));
}
}
2.equals案例
package day07;
public class StrDemos {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("abc");
String str="abc";
String str1="abc";
System.out.println(str==str1);
System.out.println(str.equals(str1));
System.out.println(s1.equals(str));//String重写了equals方法 只要内容相等就相等。
}
}
3.String类的常见方法
package day07;
import java.util.Arrays;
public class StringDemos {
public static void main(String[] args) {
String str = "abcdsxaca";
System.out.println("长度:" + str.length());
System.out.println("获取指定索引出的值:" + str.charAt(0));
if (str.contains("a")) {
System.out.println("含有a");
}
// 统计a的次数
int count = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == 'a') {
count++;
}
}
System.out.println("输出a出现的次数为:" + count);
// 统计每个字符出现的次数???
System.out.println("a".compareTo("b")); // a在前-1
System.out.println("b".compareTo("a")); // 1
System.out.println("李".compareTo("陈")); // 0
// 对字符串排序
char arr[] = str.toCharArray();
/*冒泡排序
* for(int i=0;i<arr.length;i++){
for(int j=0;j<arr.length-i-1;j++){
* if(arr[j]>=arr[j+1]){
char temp =arr[j+1];
arr[j+1]=arr[j];
arr[j] = temp; }
*
* } }
*/
Arrays.sort(arr);
System.out.println(new String(arr));
System.out.println(str.charAt(0));
}
}
4.String类常见方法(2)
package day07;
import java.io.ObjectInputStream.GetField;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
public class DemoStr {
public static void main(String[] args) {
Locale locale_zh = Locale.CHINA;
Locale locale = new Locale("zh_CN");
/*String data ="2010/10/10";
String s= String.format(locale_zh, "", data);
System.out.println(s);*/
Calendar c = Calendar.getInstance();//实例化时间对象
String s = String.format("%1$tm %1$te,%1$tY", c);
System.out.println(s);
String x = String.format("%1$,09d", 132);
String x1 = String.format("%1$,19d", 132);
System.out.println(x);
System.out.println(x1);
String s1 = String.format("%1$ty年%1$tm月 %1$td日 %1$tH小时 %1$tM分钟", c);
System.out.println(s1);
}
}
11.StringBuffer案例
1.StringBuffer案例
package day07.str;
public class StrDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("xxxx");
StringBuffer sb1 = sb.append("yy");
System.out.println("--------------"+(sb==sb1));//true
String str= new String("xxxx"); //不可以被改变
String str1 = str+"yy"; //str1
str=str+"yy"; //str //xxxxyy
System.out.println(str==str1);
}
}
12. String、StringBuffer、StringBuilder案例
1.性能对比案例
package day07.str;
public class Test {
private static final String base = "测试";
private static final int count = 1000000;
public static void stringTest() {
long begin, end;
begin = System.currentTimeMillis();
String test = new String(base);
for (int i = 0; i < count / 100; i++) {
test = test + " add ";
}
end = System.currentTimeMillis();
System.out.println((end - begin) + " millis(使用string消耗的时间)");
}
public static void stringBufferTest() {
long begin, end;
begin = System.currentTimeMillis();
StringBuffer test = new StringBuffer(base);
for (int i = 0; i < count; i++) {
test = test.append(" add ");
}
end = System.currentTimeMillis();
System.out.println((end - begin) + " millis (使用)StringBuffer消耗的时间 ");
}
public static void stringBuilderTest() {
long begin, end;
begin = System.currentTimeMillis();
StringBuilder test = new StringBuilder(base);
for (int i = 0; i < count; i++) {
test = test.append(" add ");
}
end = System.currentTimeMillis();
System.out.println((end - begin) + " millis (使用StringBuilder消耗的时间) ");
}
public static void main(String[] args) {
stringTest();
stringBufferTest();
stringBuilderTest();
}
}
13.包装类案例
2.包装类案例
package day07.bz;
public class Demo1 {
public static void main(String[] args) {
Byte byte1 = new Byte((byte) 1);
//NumberFormatException
Integer i = new Integer("12");
System.out.println(i.toString());
System.out.println(i.intValue());//int
Boolean flag = new Boolean("true");
System.out.println(flag);
//java.lang.NumberFormatException
String s="100s";
//面对象
Double d = Double.valueOf(s);
//基本数据类型
double dd = Double.parseDouble(s);
}
}
14. Math类案例
1.创建MathDemo类
package day07.bz;
public class MathDemo {
public static void main(String[] args) {
//返回最大的(最接近正无穷大)double 值,该值小于等于参数,并等于某个整数
System.out.println("结果"+Math.floor(-12.6)); //-13.0
System.out.println("结果"+Math.floor(12.6));//12.0
//返回最小的(最接近负无穷大)double 值,该值大于等于参数,并等于某个整数。
System.out.println("结果"+Math.ceil(-12.6));//-12.0
System.out.println("结果"+Math.ceil(12.6));//13.0
System.out.println("结果"+Math.floor(-12.3));//-13.0
System.out.println("结果"+Math.floor(12.3));//12.0
System.out.println("结果"+Math.ceil(-12.3));//-12.0
System.out.println("结果"+Math.ceil(12.3));//13.0
//floor是向下取
//ceil是向上去
System.out.println(Math.random());
}
}
15. BigDecimal案例
1.BigDecimal案例
package day07.math.bg;
import java.math.BigDecimal;
public class BigDecimalDemo {
public static void test(){
BigDecimal bigDecimal = new BigDecimal(10.123);
BigDecimal bigDecimal1 = new BigDecimal("10.123");
System.out.println(bigDecimal);
System.out.println(bigDecimal1);
}
public static void main(String[] args) {
/**
* 李白无事街上走,
* 提壶去买酒。
* 遇店加一倍,
* 见花喝一斗,
* 五遇花和店,
* 喝光壶中酒,
* 试问李白壶中
* 原有多少斗酒
*
* 倒着推算的逻辑题
*/
BigDecimal bigDecimal = new BigDecimal(0);
for(int i=1;i<=5;i++){
bigDecimal = bigDecimal.add(new BigDecimal("1"));
bigDecimal = bigDecimal.divide(new BigDecimal("2"));
}
System.out.println(bigDecimal);
}
}
16. Date类案例
1.Date类案例
package day07.dates;
import java.util.Date;
public class DateDemo1 {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date);
date = new Date(System.currentTimeMillis());
System.out.println(date);
System.out.println(date.toLocaleString());
}
}
17.DateFormat类案例
1.DateFormat类案例
package day07.dates;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
public class DateDemo2 {
public static void main(String[] args) {
Date date =new Date(); //当前时间
System.out.println(date);
//2013年12月11日 16时12分12秒
//DateFormat dateFormat = DateFormat.getDateInstance();
Locale aLocale = Locale.CHINA;
//FULL LONG MEDIUM SHORT
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.LONG,aLocale);
String demo = dateFormat.format(date);
System.out.println(demo); //系统本地化的效果.. zh_CN
}
}
18. SimpleDateFormat类案例
1.SimpleDateFormat类案例
package day07.dates;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
/**
* 把日期转换成字符串
* @param date
* @param pattern
* @return
*/
public static String dateConvertStr(Date date,String pattern){
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
String demo = sdf.format(date);
return demo;
}
/**
* 把字符串转换成日期
* @param pattern
* @param source
* @return
*/
public static Date strConvertDate(String pattern,String source)throws Exception{
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
Date date1 = sdf.parse(source);
return date1;
}
public static void main(String[] args)throws Exception {
//从日期转换成字符串
System.out.println(dateConvertStr(new Date(), "yyyy''年''MM月dd日'HH'时mm分ss秒"));
Date date = strConvertDate("yyyy年MM月dd日", "1999年10月02日");
System.out.println(dateConvertStr(date, "yyyy年MM月dd日"));
}
}
19. Calendar类案例
1.Calendar类案例
package day07.dates;
import java.util.Calendar;
import java.util.GregorianCalendar;
import util.DateUtil;
public class DemoCalendar {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
System.out.println(c.toString());
String demo = DateUtil.dateConvertStr(c.getTime(), "yyyy年MM月dd日");
System.out.println(demo);
GregorianCalendar cal = new GregorianCalendar();
cal.clear();//清除日期的各个部分
// field value
cal.set(Calendar.YEAR,2006);//重新设置年
cal.set(Calendar.MONTH,Calendar.JULY);//重新设置月
cal.set(Calendar.DAY_OF_MONTH,15);//重新设置日
cal.set(Calendar.HOUR_OF_DAY,12);//重新设置小时
cal.set(Calendar.MINUTE,33);//重新设置分
cal.set(Calendar.SECOND,55);//重新设置秒
String demo1 = DateUtil.dateConvertStr(cal.getTime(), "yyyy年MM月dd日 HH时mm分ss秒");
System.out.println(demo1);
}
}
2.工具类
package util;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtil {
/**
* 把日期转换成字符串
*
* @param date
* @param pattern
* @return
*/
public static String dateConvertStr(Date date, String pattern) {
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
String demo = sdf.format(date);
return demo;
}
/**
* 把字符串转换成日期
*
* @param pattern
* @param source
* @return
*/
public static Date strConvertDate(String pattern, String source)
throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
Date date1 = sdf.parse(source);
return date1;
}
}
20. 多态的案例.
1.创建Animal父类
package www.csdn.net.dm;
public class Animal {
//成员属性
public String name;
//构造器
public Animal() {
System.out.println("---------animal构造器--------");
}
//成员方法
public void fly(){
System.out.println("---animal----fly---");
}
}
2.创建Bird子类
package www.csdn.net.dm;
public class Bird extends Animal{
public String sex;
public Bird() {
System.out.println("----Bird构造器----------");
}
@Override
public void fly() {
//super.fly();
System.out.println("----Bird----fly---");
}
public void fly(float speed){
}
}
3.创建测试类
package www.csdn.net.dm;
public class TestDemo {
public static void main(String[] args) {
// 在实例化子类的对象时,必须先实例化祖先
/*
* Bird b = new Bird();
*
* b.fly();
*/
/*
* Animal animal = new Animal();
*
* animal.fly();
*/
// 子类的对象可以代替父类的对象使用
// 多态性
/**
* 在多态情况下, 一个引用类型的变量如果声明为父类的类型, 但实际引用的是子类对象,则该变量就不能访问子类中添加的属性和方法。
*/
/* */
// 调用子类中的重写方法
/*
* Bird bird = new Bird();
*
* if(bird instanceof Animal){ Animal animal = bird; animal.fly(); }
*/
/*
* ---------animal构造器-------- Exception in thread "main"
* java.lang.ClassCastException: www.csdn.net.dm.Animal cannot be cast
* to www.csdn.net.dm.Bird at
* www.csdn.net.dm.TestDemo.main(TestDemo.java:44)
* 当试图将对象强制转换为不是实例的子类时,抛出该异常
*/
// 父类的对象不能当作是一个子类的对象来使用
/*
* Animal animal = new Animal(); Bird bird = (Bird) animal;
*/// 从父类到子类
// bird.fly();
// 声明的是一个Animal对象,但是实际引用的是Bird的对象
Animal animal = new Bird();
// 把animal对象转换成 Bird对象的时候,需要强制造型的.
Bird bird = (Bird) animal;
bird.fly();
}
}
21. 理解初始化块和静态初始化块案例
1.创建Animal类
package www.csdn.net.test;
public class Animal {
{
System.out.println("---animal初始化块----");
}
public Animal() {
System.out.println("-----animal构造器-------");
}
static {
System.out.println("---Animal--static初始化块-----");
}
public static void main(String[] args) {
new Animal();
}
}
2.创建Bird子类
package www.csdn.net.test;
public class Bird extends Animal {
static {
System.out.println("------bird---static初始化块---");
}
{
System.out.println("----Bird初始化块----");
}
public Bird() {
System.out.println("---Bird构造器-----");
}
public static void main(String[] args) {
new Bird();
/**
* 1.先执行static初始化块。先祖先开始到子类
* 2.再执行祖先的初始化操作(祖先初始化完毕),再执行下一个祖先的初始化。依次到最后的子类。
*/
}
}
3.理解每个main方法输出的结果.
22. final案例
1.基本数据类型数组的声明、初始化和遍历
23.抽象类案例
1.创建抽象类Person
package www.csdn.net.ab;
public abstract class Person {
//public String name;
//1.抽象方法没有方法体
public abstract void teach();
//2.一个类中如果有一个抽象方法,那么这个类必须是抽象类
//3.如果一个类是抽象类,那么这个类中不一定有抽象方法。
//注意:abstract与static、final不 能同时使用(在修饰方法、类的时候)
//abstract本身就不能修饰变量
}
2.创建抽象类的子类Teacher
package www.csdn.net.ab;
/**
*
*如果一个类继承了抽象类,并且没有实现抽象类的方法,那么这个必须定义为抽象类
*/
public abstract class Teacher extends Person{
//5.抽象方法不能定义为private 也就是说修饰符不能是private
public abstract void tea();
}
3.创建Teaher的子类User类
package www.csdn.net.ab;
/*
* 如果一个类继承了抽象类,并且该抽象类的父类也是一个抽象类,依次类推,那么当前这个类
* 必须实现所有抽象类的抽象方法.
*
*/
public class User extends Teacher {
@Override
public void tea() {
// TODO Auto-generated method stub
}
@Override
public void teach() {
// TODO Auto-generated method stub
}
}
24.接口案例
1.创建一个BaseDao封装增删改查的方法.
package www.csdn.net.dao;
import java.util.List;
public interface BaseDao<T> {
public static final int A=90;
/**
* 插入实体
* @param entity
* @return
*/
public abstract boolean insert(T entity);
/**
* 更新实体
* @param entity
* @return
*/
boolean update(T entity);
/**
* 删除实体
* @param entity
* @return
*/
boolean delete(T entity);
/**
* 查询所有实体对象
* @return
*/
List<T> selectAll();
}
2.创建一个实体的接口,并且根据泛型知名操作的实体
package www.csdn.net.dao;
public interface UserDao extends BaseDao<User>{
//抽象方法
boolean login(String name,String pass);
}
3.创建具体的实现类
package www.csdn.net.dao;
import java.util.List;
/**
* 当一个类实现某个接口的时候,就必须实现该接口中的所有方法(祖先中的方法);
*
*/
public class UserDaoImp implements UserDao{
@Override
public boolean insert(User entity) {
// TODO Auto-generated method stub
return false;
}
@Override
public boolean update(User entity) {
// TODO Auto-generated method stub
return false;
}
@Override
public boolean delete(User entity) {
// TODO Auto-generated method stub
return false;
}
@Override
public List<User> selectAll() {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean login(String name, String pass) {
// TODO Auto-generated method stub
return false;
}
}
25.匿名内部类案例
1.窗体关闭操作案例
package www.csdn.net.dmx;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class MyFrame extends Frame {
public MyFrame() {
this.setVisible(true);// 设置窗体可见
this.setBounds(400, 200, 400, 400);// 设置窗体的大小及坐标
// 这样写 就等价于 1和2干的事情。
WindowAdapter wa = new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
System.exit(0);
}
};
// 添加监听
this.addWindowListener(wa);
}
public static void main(String[] args) {
new MyFrame();
// 2.
WindowAdapter wa = new MyWindowAdapter();
}
}
// 1.
class MyWindowAdapter extends WindowAdapter {
@Override
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
System.exit(0);// 程序退出
}
}
3.1.1 继承类的案例.
1.Person类的封装案例
package day05;
public class Person{
public String name;
protected String sex;
int age;
public String cardId;
//Object(){}
public Person(){
System.out.println("---Person的构造器------");
}
public void study(String name){
}
@Override
public String toString() {
return "Person [name=" + name + ", sex=" + sex + ", age=" + age
+ ", cardId=" + cardId + "]";
}
}
/**
* 非私有的属性
*/
2.Student继承Person类的实现
package day05;
/**
* student 子类
* Person 父类
*/
public class Student extends Person{
public String cardId;
private String school;
public Student() {
//card赋值
//super.cardId="0x111111";
this.cardId="0xxxxxx111";
System.out.println("----Student构造器-----");
}
public String getCardId(){
return cardId;
}
public static void main(String[] args) {
Student stu = new Student();
System.out.println(stu.cardId);
}
@Override
public String toString() {
return "Student [cardId=" + cardId + "]";
}
}
3.创建测试类
package day05;
public class Test {
public static void main(String[] args) {
Student stu = new Student();
//System.out.println(stu.getCardId());
//理解修饰符的访问权限
//理解变量隐藏
//理解内存分配的过程
String temp = stu.getCardId();
System.out.println(temp);
}
}
3.1.2 构造器和断点调试案例
1.创建Student类
package day04;
import java.sql.Date;
public class Student {
private int age;
private String name;
private Date birth;// 生日
// 默认的构造器
public Student() {
int age;
this.init();
System.out.println("xxxx");
}
public void init() {
System.out.println("xxxxxxxxxxxx");
String str = "xxx";
System.out.println("xxxxxxxxxxxx");
System.out.println("xxxxxxxxxxxx");
System.out.println("xxxxxxxxxxxx");
System.out.println(str.charAt(0));
}
public Student(String name) {
System.out.println(this.name);
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 130) {
this.age = 0;
} else {
this.age = age;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
}
2.创建测试类
package day04;
public class StudentTest {
public static void main(String[] args) {
/**
* 在Student构造器上打断点.
* 讲解:
* F5 调入
* F6跳过
* F7返回
* Drop to Frame 是返回方法的第一行.
*/
Student student = new Student();
student.setAge(180);
System.out.println(student.getAge());
}
}
3.1.3 构造器案例
1.理解构造器的执行顺序
class Person {
public Person() {
System.out.println("构造器---person---");
}
}
class Student extends Person{
public Student() {
System.out.println("构造器---student--");
}
}
public class Test{
public static void main(String[] args) {
Student stu = new Student();
}
}
2.继承中构造器的理解
1.创建父类
package www.csdn.net.bug;
public class Point {
protected float mx, my;
public Point(float mx, float my) {
this.mx = mx;
this.my = my;
}
public static void main(String[] args) {
Cycle cycle = new Cycle(2.5f);
}
}
2.创建子类
class Cycle extends Point {
protected float mx;
public Cycle(float mx) {
this.mx = mx;
}
}
3.1.4 super案例
1.观察程序运行结果
3.观察程序运行结果
2.观察程序运行结果
3.1.4 重写案例
1.观察程序看是否是方法重写
2.观察程序是否是方法重写,并说出程序3的运行结果
1 递归的案例.
1.阶乘的案例
package day04;
public class Recursion {
/**
* 降阶
* 5!=5*4!
* 4!=4*3!
* 3!=3*2!
* 2!=2*1!
* 1!=1;
*/
static int jieCheng(int n){ //假设n=1
if(n<=1){
return 1;
}else{
return n*jieCheng(n-1); //假设2
}
}
public static void main(String[] args) {
System.out.println(jieCheng(3));
}
}
2.斐波那契数列
package day04;
public class RecursionDemo1 {
/**
* f(1)=0; 1
* f(2)=1;
* f(3)=1;-f(2)+f(1)
* f(4)=2;f(3)+f(2)
* f(n)=; f(n-1)+f(n-2);
*
*/
static int feiNa(int n){
if(n==1){
return 0;
}else if(n==2){
return 1;
}else{
return feiNa(n-1)+feiNa(n-2);
}
}
public static void main(String[] args) {
System.out.println(feiNa(4));
}
}
3.斐波那契数列引发的兔子繁殖问题分析及实现
分析:
经过月数 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
幼仔对数 | 1 | 0 | 1 | 1 | 2 | 3 | 5 | 8 | 13 | 21 | 34 | 55 | 89 |
成兔对数 | 0 | 1 | 1 | 2 | 3 | 5 | 8 | 13 | 21 | 34 | 55 | 89 | 144 |
总体对数 | 1 | 1 | 2 | 3 | 5 | 8 | 13 | 21 | 34 | 55 | 89 | 144 | 233 |
package day04;
import java.sql.Date;
public class RecursionDemo2 {
/**
* 幼崽 n代表月数
*
* @param n
* @return
*/
static int feiNa(int n) { // 月数
if (n == 0) {
return 1;
} else if (n == 1) {
return 0;
} else if (n == 2) {
return 1;
} else if (n == 3) {
return 1;
} else {
return feiNa(n - 1) + feiNa(n - 2);
}
}
/**
* 成崽 n代表月数
*
* @param n
* @return
*/
static int feiNas(int n) { // 月数
if (n == 0) {
return 0;
} else if (n == 1) {
return 1;
} else {
return feiNas(n - 1) + feiNas(n - 2);
}
}
/**
* 总数n代表月数
*
* @param n
* @return
*/
static int feiNass(int n) { // 月数
if (n == 0) {
return 1;
} else if (n == 1) {
return 1;
} else {
return feiNass(n - 1) + feiNass(n - 2);
}
}
public static void main(String[] args) {
System.out.println(feiNa(12));
System.out.println(feiNas(12));
System.out.println(feiNass(12));
System.out.println(new Date(2, 11, 1));
}
// 兔子繁殖的问题
/**
* 一般而言,兔子在出生两个月后, 就有繁殖能力, 一对兔子每个月能生出一对小兔子来 。如果所有兔子都不死, 那么一年以后可以繁殖多少对兔子?
*/
}
2 构造器和断点调试案例
1.创建Student类
package day04;
import java.sql.Date;
public class Student {
private int age;
private String name;
private Date birth;// 生日
// 默认的构造器
public Student() {
int age;
this.init();
System.out.println("xxxx");
}
public void init() {
System.out.println("xxxxxxxxxxxx");
String str = "xxx";
System.out.println("xxxxxxxxxxxx");
System.out.println("xxxxxxxxxxxx");
System.out.println("xxxxxxxxxxxx");
System.out.println(str.charAt(0));
}
public Student(String name) {
System.out.println(this.name);
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 130) {
this.age = 0;
} else {
this.age = age;
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
}
2.创建测试类
package day04;
public class StudentTest {
public static void main(String[] args) {
/**
* 在Student构造器上打断点.
* 讲解:
* F5 调入
* F6跳过
* F7返回
* Drop to Frame 是返回方法的第一行.
*/
Student student = new Student();
student.setAge(180);
System.out.println(student.getAge());
}
}
3 数组声明、创建、初始化和遍历案例
1.基本数据类型数组的声明、初始化和遍历
package www.csdn.net.array;
public class Demo1 {
public static void main(String[] args) {
int a = 1, b = 2, c = 3, d = 4;
// 数组
/**
* 1.数组的声明
*
* 数据类型[] 变量名; 数据类型 变量名[];
*
* 2.初始化 1.静态初始化
*
* 2.动态初始化
*
*/
// 1.静态初始化
int arr[] = { 1, 2, 3, 4 };
// 2.动态初始化
int arrs[];// 声明
arrs = new int[3];// 创建 new 引用类型
// arrs[0]=2; // length-1
System.out.println(arrs.length);
for (int i = 0; i < arrs.length; i++) {
arrs[i] = i + 1;
}
// 遍历
for (int i = 0; i < arrs.length; i++) {
System.out.println(arrs[i]);
}
}
}
2.引用类型的数组的声明、创建、初始化和遍历。
package www.csdn.net.array;
public class Demo2 {
public static void main(String[] args) {
//1.声明数组
String arrs[] ; //不能够指明长度
//2.创建数组
arrs = new String[10];//必须指明长度
//3.初始化
for(int i=0;i<arrs.length;i++){
arrs[i]="chen"+i;
}
//4.遍历
for(int i=0;i<arrs.length;i++){
System.out.println(arrs[i]);
}
//5.静态初始化
String arr[]={"chen0","chen1"};
}
}
4 数组排序案例案例
1.一维数组的应用(冒泡排序)
package www.csdn.net.array;
public class Demo4 {
public static void main(String[] args) {
int arrs[] = { 9, 8, 5, 12, 4 };
/**
* 9 8 5 12 4
*
*
* 8 5 9 4 12
*
* 5 8 4 9 12
*
* 5 4 8 9 12
*
* 4 5 8 9 12
*
*
*/
for (int i = 0; i < arrs.length; i++) { //循环次数 4
//for循环排序
for (int j = 0; j < arrs.length-i - 1; j++) {
int temp = 0;
if (arrs[j] > arrs[j + 1]) { //arr[1]
temp = arrs[j];
arrs[j] = arrs[j + 1];
arrs[j + 1] = temp;
}
}
System.out.println("--------------"+i);
// 遍历分析效果
for (int k = 0; k < arrs.length; k++) {
System.out.print(arrs[k] + " ");
}
System.out.println();
}
}
}
2.利用工具类进行排序
package www.csdn.net.array;
import java.util.Arrays;
public class Demo5 {
public static void main(String[] args) {
int arrs[] = { 9, 8, 5, 12, 4 };
Arrays.sort(arrs);//排序
for(int ar:arrs){
System.out.println(ar);
}
//foreach循环
String str="abcd786543zspa";
//把字符串转换成char的数组
char c[] = str.toCharArray();
//调用util工具的Arrays类的sort方法进行排序
Arrays.sort(c);
//转化成字符串
String temp =new String(c);
System.out.println(temp);
}
}
5 二维数组案例
1.二维数组的声明、创建、初始化等.
package www.csdn.net.array;
public class Demo7 {
public static void main(String[] args) {
//1.声明
int var[][];
//2.创建
var = new int[2][3];
/*
* {
* {1,2,3},
* {1,2,3},
* }
*/
System.out.println(var.length);
//3.初始化
for(int row=0;row<var.length;row++){
for(int col=0;col<3;col++){
var[row][col]=row*col;
}
}
//遍历
for(int[] v:var){
for(int i:v){
System.out.print(i+",");
}
System.out.println();
}
}
}
2.静态初始化二维数组,理解二维数组的长度、理解二维数组的遍历.
package www.csdn.net.array;
public class Demo8 {
public static void main(String[] args) {
//1.静态初始化
int var[][]={
{1,2,3},
{4,5,6,7},
{7,8,9,0,9,9,9}
};
//数组的长度是多少?
System.out.println(var.length);
//数组的列是多少?
for(int row=0;row<var.length;row++){//行
int v[]=var[row];
System.out.println(v.length);
for(int col=0;col<var[row].length;col++){//列
System.out.print(var[row][col]+" ");//i=0;
}
System.out.println();
}
}
}
3.1.1 运算符的案例.
1.~运算符的案例
package day03;
public class BitDemo {
public static void main(String[] args) {
int a = 2;
/**
* 分析
* 1.首先转换成二进制(整数int占4个字节 32位)
* 0000 0000 0000 0000 0000 0000 0000 0010
* 由于前面相同都是0简写成
* 0000 0010
* 2.取反
* 1111 1101 //前面的1都可以理解成符号位
* 3.由于得到的数字是个负数,要求出负数的补码(因为在计算机中是采用补码的方式进行保存数据的)
* 负数的补码=反码+1;(理解负数的绝对值转换成二进制取反得到反码然后再加1)
*
* 0000 00 01 //把符号位变成0即可
* 取反 1111 11 10
* 再加 1
* ------------------------
* 11 符号位为1所以得到的数字为-3
*
*
*
*
*/
System.out.println(~a);
int c = -4;
/**
* 分析
* 1. 本身是负数 要计算出负数在计算机上存储的二进制然后取反即可
*
* 2.由于计算机中采用补码的形式存储,所以要求出补码
*
* -4取绝对值为4 转换成二进制为(这里简写了)
* 0100
* 取反 1011
* 加1 1
* ---------------
* 1100 这样就得到了-4在计算机上的补码 二进制表示
* 然后再取反 0011 得到的结果为3
*
*/
System.out.println(~c);
}
}
3.1.2 instanceof、++、--综合案例
1.instanceof案例
class BitDemo2 {
public static void main(String[] args) {
int a=1;
System.out.println(a++); //1 ;
System.out.println(++a); //3 ;
System.out.println(a--); //3 ;
System.out.println(--a); //1
//三目运算符
//条件部分?真:假
System.out.println(4>7?4:7);
//创建一个User对象 new操作符
//创建一个对象
User u= new User(); //构造器 //类名.方法();
Object o = new Object();
if(o instanceof User){
System.out.println("u is User type");
}
System.out.println("====================");
}
}
class User{
//private修饰
public User(){
System.out.println("构造器执行.............");
}
}
3.1.3 猜数字游戏案例雏形
1.游戏雏形代码片段.
package day03;
import java.util.Random;
import javax.swing.JOptionPane;
public class GuessNumDemo {
/**
* 入口方法
*
* @param args
*/
public static void main(String[] args) {
String source =
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
// 随机产生数字
Random random = new Random();
//根据字符串长度随机获取索引下标值
int index = random.nextInt(source.length());
//根据产生的随机下标,获取指定的字符
char guessChar = source.charAt(index);
//循环5次,让用户输入5次机会
for (int i = 0; i < 5; i++) {
String inputChar = JOptionPane.showInputDialog("请输入你猜的数字和字母");
if (inputChar.equals(guessChar + "")) {
JOptionPane.showMessageDialog(null, "恭喜你中了500万");
} else {
JOptionPane.showMessageDialog(null, "错了");
}
int x = guessChar;
}
}
}
3.1.4 switch语句案例
1.switch案例应用
package day03;
public class SwitchDemo {
static final int a = 1;// 全局变量
public static void main(String[] args) {
String key = "y"; //key的类型可以是int -->byte short char int
//key的类型可以是strings(JDK1.7)
//key的类型可以是enum
switch (key) {
case "x": // case 值 必须是一个常量
break; //
case "y":
System.out.println(2);
break;
case "z":
System.out.println(3);
break;
default:
System.out.println("xxxx");
break;
}
}
}
3.1.5 break与continue语句案例
package demo;
public class BreakDemo {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) { // 外
for (int j = 3; j > 0; j--) { // 内
if (i == j) {
continue; // 把continue换成 break语句 猜测运行结果.
}
System.out.println("j=" + j);
}
System.out.println("i=" + i);
}
}
}
3.1.6 创建类的案例
package www.csdn.net.cls;
public class Person { //类中定义的属性和方法都归对象所拥有.
public static final int FLAG=3;
public String name;//名字
public String sex;//性别
public int age;//年龄
//默认的不可见
/**
* 方法声明语法格式
* 修饰符 限定符 返回值类型 方法名(参数列表){}
*/
public void study(String subject){
System.out.println("这个人正在学习"+subject);
}
public static void main(String[] args) {
Person p= new Person();//默认构造函数
p.name=new String("张三");
p.sex="男";
p.age=18;
p.study("Java");
Person p1 = new Person();
p1.name=new String("张三");
p1.sex="男";
p1.age=18;
p1.study("Java");
//System.out.println(p.age==p1.age);
// p=p1;
System.out.println(p.name==p1.name); //字符串
System.out.println(p.name.equals(p1.name));
/*
String a="hello";
String b="hello";
String c = new String("hello");
System.out.println(a==b);
System.out.println(a==c);*/
}
}
3.1.7 ==与equals的区别案例
1.先重写equlas方法
package www.csdn.net.dengyu;
public class Student {
public String cardId;
@Override
public boolean equals(Object obj) {
// 1.先判断是否为null
if (obj == null) {
return false;
}
// 2.判断obj是否是当前类的类型
if (obj instanceof Student) {
// 3.强制造型
Student stu = (Student) obj;
// 4.改变比较条件
if (this.cardId.equals(stu.cardId)) {
return true;
}
}
return false;
}
}
2.测试看结果根据代码分析
package www.csdn.net.dengyu;
import java.util.HashSet;
import java.util.Set;
public class TestEquals {
public static void main(String[] args) {
//why? //answer
Student s1 = new Student();
s1.cardId="xxxx01";
Student s2 = new Student();
s2.cardId="xxxx01";
System.out.println(s1==s2);// hashCode;
System.out.println(s1.equals(s2));//true
//set不允许重复值
Set<Student> stus = new HashSet<Student>();
stus.add(s1);
stus.add(s2);
System.out.println(stus.size());
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1==str2);
System.out.println(str1.equals(str2));//true
}
}
3.1.7 基本数据类型传递值案例
package www.csdn.net.cls.demo01;
public class User {
// a与b的值互换
public static void change(int a, int b) {
int temp; // 中间变量
temp = a;// 把a赋值给temp
a = b;// 把b赋值给a
b = temp;// tmp赋值给b
System.out.println(a+"xxxx"+b);
}
public static void main(String[] args) {
int a=4;
int b=5;
User.change(a, b);//值传递过去了
System.out.println(a+"xxxxxx"+b);
}
}
3.1.8 引用类型传递值的案例
package www.csdn.net.cls.demo01;
public class Employee {
private int salary;//薪水
private int comm;//奖金
public Employee(int salary,int comm) {
this.salary=salary;
this.comm=comm;
}
//把薪水和奖金互换
public static void change(Employee emp){
int temp;
temp=emp.salary;//记录薪水
emp.salary=emp.comm;//把奖金付给薪水
emp.comm=temp;//把记录的薪水 赋值给奖金.
System.out.println(emp.salary+"-----"+emp.comm);
}
public static void main(String[] args) {
Employee employee = new Employee(10000,2000);
Employee.change(employee); //引用地址
System.out.println(employee.salary+"-----"+employee.comm);
}
}
3.1.1 运算符的案例.
1.算术运算的案例
package day02;
public class NumDemo {
public static void main(String[] args) {
//
int num=78631;
//13687
int wanWei = num/10000;
int qianWei = num%10000/1000;
int baiWei = num%1000/100;
int shiWei = num%100/10;
int geWei=num%10;
System.out.println(wanWei);
System.out.println(qianWei);
System.out.println(baiWei);
System.out.println(shiWei);
System.out.println(geWei);
/*不采用.
* String str = num+"";
StringBuffer sb = new StringBuffer(str);
StringBuffer rsb = sb.reverse();
System.out.println(rsb);*/
}
}
3.1.2 if语句和运算符的综合案例
1.if语句和综合案例
package day02;
import javax.swing.JOptionPane;
public class ReleDemo {
//主线程
public static void main(String args[]){
//关系运算符 > < >= <= == !=
//==与equals的区别
//Integer类 它是int的封装类
//接受输入的数字
String num = JOptionPane.showInputDialog("请输入年龄"); //String-->Object
//1.if语句形式1
if(num!=null){
int age=Integer.parseInt(num);
System.out.println("用户的年龄"+age);
//2.if语句形式2
if(age<0){
JOptionPane.showMessageDialog(null, "不存在这样的年龄");
}else{
//3.if语句形式3 当有一个条件满足时,后边的就不再执行了
if(age<10){
System.out.println("小屁孩一个");
}else if(age>20&& age<30){
System.out.println("青年一个");
}else if(age>=30&&age<40){
System.out.println("三十而立");
}else if(age>=40&&age<50){
System.out.println("不惑之年");
}else if(age>=50&&age<128){
System.out.println("知道自己的寿命了");
}else{
System.out.println("老年人,需要照顾.");
}
}
}
//条件语句
//1. if(boolean值){}
//2. if(boolean值){}else{}
//3. if(boolean值){}else if(){}...{}else{}
//4.嵌套
//线程的区别
String oper="请输入数字";
if(oper instanceof Object){
System.out.println("属于它的类型");
}
}
}
3.1.3 for循环与continue的案例
1.求出1-100之内的偶数.
package day02;
public class ModeDemo {
int i = 100;// 全局变量
public static void main(String[] args) {
int a = 111 % 7;
System.out.println("取余数:" + a);
// 输出1-100之内的偶数
// 偶数 --1
// ; //局部变量
for (int i = 100; i >= 1; i--) {
//
if (i % 2 == 1) {
continue;
}
// why? 跳出本次循环 终止本次循环
System.out.println("偶数----" + i);
}
/**
* 循环语句: 反复执行. for(初始化部分;判断部分;自增部分){ 循环体部分; }
*
* 初始化部分; for(;循环条件部分;迭代部分){ 循环体部分; }
*/
// 死循环的写法一定要掌握
/*
* for(;;){ System.out.println("----------------"); }
*/
int c = 1000;
c = 1;
// 输出的结果
for (int j = 1; j < 3; j++) {
System.out.println("-----" + j);
}
}
}
3.1.4 验证码案例答案
1.验证码
package day01.zuoye;
import java.util.Random;
public class RandomNum {
// 写方法
public static String randomCheckCode(String str) {
// 声明返回值
String temp = "";
// 验证码
// 1-9,a-z A-Z ctrl+shift+X
System.out.println("字符串的长度:" + str.length()); // 62
Random random = new Random();
for (int i = 0; i < 4; i++) {
// 随机获取 0-61 数字 4次 charAt(num);
int num = random.nextInt(str.length());
char c1 = str.charAt(num); // 索引从0开始 到61
temp += c1;
}
return temp;
}
public static void main(String[] args) {
String str =
"军哥网0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
String checkCode = RandomNum.randomCheckCode(str);
System.out.println(checkCode);
String temp="1edl;kfjaw;dfjawd;lkfjaldwk;fja;wdljfalwkejrfq";
}
}
1.3 Java语言基础涉及到的2个案例
1.整型与浮点型案例
package day01;
public class DataDemo {
/**
* 程序的入口方法
* @param args
*/
public static void main(String[] args) {
/**
* 数据类型 :整型 byte short int long 1 2 4 8 8 16 32 64
* 浮点型 float double 4 8
* 字符型 char 2 能不能存储一个汉字
*/
byte a = 0;
// 变量的声明语法格式
// 数据类型 变量名=[缺省值];
// 数据类型 变量名;
// 变量名=[缺省值]
float f = 0.1f;
double d = 0.1;
/**
* 重点思考:面试题分析,强制类型转换的错误 short s=1; s=s+2;
*/
short s = 1;
s += 2;
System.out.println("f=" + f);
char c = '陈';
}
}
2.字符类型案例
package day01;
public class CharTest {
// 方法完成作业
public static void getNum() {
int A = 'A';
int Z = 'Z';
System.out.println(A + "到" + Z);
}
public static void main(String[] args) {
// 字符
char a = 'a';// 字符 2个字节
int c;// 整型 4个字节
c = a; // 字符型a转换成整型 c //38472 32418 20891
System.out.println("a==" + c);
int z = 'z';
System.out.println("z===" + z);
// a-z 97 122
// A-Z的取值范围 作业?
// CharTest.getNum();
getNum();
}
}
3.boolean类型案例
package day01;
public class BooleanDemo {
static float x = 10; // 作用域
public static void main(String[] args) {
// 案例1
boolean flag;
flag = 3 > 8; // flag可以为true 或者false 或者 表达式 最终结果 true false
if (flag) {
System.out.println("flag为真");
} else {
System.out.println("flag为假");
}
// 案例2 &和&&的区别 & 位运算 1&0 0 1&1 1 && 逻辑符号
if (8 < 3 && 9 < 7) { // false
// && 说明:短路 前面有错,后面忽略
}
if (8 < 3 & 9 > 7) {// false
// 求生两边,然后再& 看结果
}
// 重要
// 强制类型转换
int x = 10;
// byte by=(byte)x;
System.out.println(BooleanDemo.x);
int C = 2;
System.out.println(C);
int c = 0; // 局部变量 在使用之前必须初始化值
System.out.println(c);
}
}
1.理解局部变量使用的注意事项.
3.1.4 常量的应用案例
1.常量案例
package day01;
public class FinalVarDemo {// 类体
// 成员变量
// 1.实例变量
// 2.类变量
int age = 10;// 实例变量
final double salary = 100;// =10; //常量 必须初始化值
// 1.赋值 final double salary=100;
static int x;// 类变量 //理解 静态变量与实例变量的区别?
static {// 语句块 被分配了内存 什么时候执行了 //思考 去掉static修饰 看效果是什么样子
// 理解 静态块与 {}的区别
int c = 0;// 局部变量
System.out.println("c=" + c);
x = 100;// 类的静态块 访问的成员变量 只能类变量
}
/*
* 2 赋值.{ salary=100; }
*/
// 3.构造器 给常量赋值
/*
* public FinalVarDemo() { salary=100; }
*/
static final double saly; // static final 静态最终的常量
// 1. static final double saly=100
/**
* 2.static{ saly=100; }
*/
static {
saly = 100;
}
public void test() {
int number;// 局部变量
}
public static void main(String[] args) {
// 创建对象
FinalVarDemo f1 = new FinalVarDemo();
f1.age = 100;
f1.x = 100;
System.out.println(f1.x + "age=" + f1.age);
FinalVarDemo f2 = new FinalVarDemo();
System.out.println(f2.x + "age=" + f2.age);
FinalVarDemo f3 = new FinalVarDemo();
f3.x = 30;
f3.age = 10;
System.out.println(f3.x + "age=" + f3.age);
FinalVarDemo f4 = new FinalVarDemo();
System.out.println(f4.x);
System.out.println("测试了");
}
}