Java案例

最新推荐文章于 2023-06-18 13:47:25 发布

闫梅

最新推荐文章于 2023-06-18 13:47:25 发布

阅读量1.2k

点赞数

本文链接：https://blog.csdn.net/yantingmei/article/details/11778915

版权

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("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(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(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},

* }

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("测试了");

}

闫梅

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java案例

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)
复制链接

扫一扫