培训-----java基础学习持续更新----6月份

来源：互联网发布：医学英语翻译软件编辑：程序博客网时间：2024/05/21 17:21

第一天：

记忆的知识点：

关于java文件名和类名

1，一个java文件中可以包含多个类

2，最多有一个公共类而且该公共类的名字需要跟java文件名同名

3，main函数只能存放在公共类中

作业：

要求：so easy

打印图形：

public class test1

{

public static void main(String[] args)

{

System.out.println(" o"+" "+"o");

System.out.println(" \\"+" "+"/");

System.out.println(" _____\\"+"/_______"+" "+"_____");

System.out.println("|"+" ________ "+"|"+" "+"|"+" --|");

System.out.println("|"+" | ^ ^ | ()"+"|"+" "+"|"+"---|");

System.out.println("|"+" | o o | ()"+"|"+" "+"|"+"---|");

System.out.println("|"+" | || | "+"|"+" "+"|"+"---|");

System.out.println("|"+" | _ _ | _ "+"|"+" "+"|"+"- |");

System.out.println("|"+" | |____| ||_|"+"|"+" "+"|"+" |");

System.out.println("|"+" |________| "+"|"+" "+"|"+" |");

System.out.println("|"+"______________"+"|"+" "+"|___|");

}

打印课程表

public class test2

{

public static void main(String[] args)

{

String datStr[]={"星期一","星期二","星期三","星期四","星期五"};

String course[]={"Java","C","C++","C#","数学","语文","体育","英语","音乐", "美术","武术","历史"};

String para[]={"第一节","第二节","第三节","第四节"};

for (int i = 0; i < datStr.length; i++) {

System.out.print("\t"+datStr[i]);

}

System.out.println();

System.out.println(para[0]+"\t"+course[0]+"\t"+course[1]+"\t"+course[2]+"\t"+course[3]+"\t"+course[4]);

System.out.println(para[1]+"\t"+course[5]+"\t"+course[7]+"\t"+course[8]+"\t"+course[6]+"\t"+course[9]);

System.out.println(para[2]+"\t"+course[11]+"\t"+course[10]+"\t"+course[4]+"\t"+course[4]+"\t"+course[4]);

System.out.println(para[3]+"\t"+course[0]+"\t"+course[0]+"\t"+course[0]+"\t"+course[0]+"\t"+course[0]);

}

第二天：

1，数据类型：8种基本数据类型：byte(1字节)short（2）int（4）long（8）float（4）double(8)char(2)boolean

4种引用类型：对象、数组、接口、枚举

2，byte和short运算时，自动提升为int类型

3，a----ascii码 97

A -----65

取值范围0-65535

4，大类型可以强制转换为小类型；

5，自动提升路线 byte、short、char---->int--->long--->float--->double

6,-10%-3----- -1 符号只跟%前面的相同，与后面的符号无关

作业：

1，

打印自己的个人信息：

我的名字叫：张三

今年18岁了!

我的家在：北京市朝阳区....

我最好的朋友叫：李四

我的电话号码是：13278247300 字符串类型

String name="张三";

String age="18";

String address="北京朝阳区";

String bestFriend="李四";

String phonum="184387248578";

System.out.println("我的名字叫"+name);

System.out.println("今年"+age+"岁了");

System.out.println("我的家在："+address);

System.out.println("我最好的朋友叫："+bestFriend);

System.out.println("我的电话号码"+phonum);

2，左手有一个卡片:10

右手有一个卡片:8

交换.....

左手:8

右手:10

int left=10;

int right=8;

System.out.println("交换前左手卡片："+left);

System.out.println("交换前右手卡片："+right);

int temp;

temp=left;

left=right;

right=temp;

System.out.println("交换后左手卡片："+left);

System.out.println("交换后右手卡片："+right);

3，有一4位数的会员卡号，

求各个位的数字之和。

int cardNum=7954;

int sum;

sum=cardNum%10+cardNum/10%10+cardNum/100%10+cardNum/1000;

System.out.println(cardNum+"的各个位数求和："+sum);

第三天

1，<< >> <<<

2,位运算符& | ^异或相同为假

3，~取反

4，switch 表达式条件必须能自动转换为int的类型 byte short int char 通常使用int类型

作业：

1.出去旅游： 3~10旺季，其它为淡季

旺季机票9折，淡季5折

如果乘坐商务舱不再打折，经济舱再打8折

机票原价5000，输入出行的月份和乘坐的舱种获得票价

// 1.出去旅游： 3~10旺季，其它为淡季

// 旺季机票9折，淡季5折

// 如果乘坐商务舱不再打折，经济舱再打8折

// 机票原价5000，输入出行的月份和乘坐的舱种获得票价

Scanner scanner=new Scanner(System.in);

System.out.println("请输入出行月份:");

int m=scanner.nextInt();

System.out.println("请输入舱种:");

String sitType=scanner.next();

double price=5000;

if (m>=3&&m<=10) {

price=price*0.9;

}else {

price=price*0.5;

}

if (sitType.equals("经济舱")) {

price=price*0.8 ;

}

System.out.println("机票价格是:"+price);

2.输入一个四位会员卡号，如果卡号各个位之和为25则为中奖！

// 输入一个四位会员卡号，如果卡号各个位之和为25则为中奖！

Scanner scanner=new Scanner(System.in);

System.out.println("请输入四位会员卡号：");

int cardNum=scanner.nextInt();

int sum=cardNum%10+cardNum/10%10+cardNum/100%10+cardNum/1000;

if (sum==25) {

System.out.println("恭喜中奖");

3.输入成绩，求等级。 switch

90以上 A

80~89 B

70~79 C

60~69 D

0~59 E

// 输入成绩，求等级。 switch

// 90以上 A

// 80~89 B

// 70~79 C

// 60~69 D

// 0~59 E

Scanner scanner=new Scanner(System.in);

System.out.println("请输入成绩：");

int score=scanner.nextInt();

char grade;

switch (score/10) {

case 9: grade='A';

break;

case 8: grade='B';

break;

case 7: grade='C';

break;

case 6: grade='D';

break;

default: grade='E';

break;

}

System.out.println("成绩等级："+grade);

第四天

1，递归画图理解？？

System.out.println(method(5));

}

public static int method(int n){

if (n==1) {

return 1;

}else {

return n*method(n-1);

}

2，异常：运行期出现的错误

重要：错误的名字和行号

e.printStackTrace()打印错误

e.getMessage();

Finally统一管理程序最后的状态

自定义异常：继承Exeption

重写方法需要抛出与原方法完全一样的异常或者不抛异常public class HelloWorld {

public static void main(String[] args)

{

try {

throw new selfException();

} catch (selfException e) {

// TODO Auto-generated catch block

e.printStackTrace();

e.getMessage();

}

class selfException extends Exception{

public selfException() {

// TODO Auto-generated constructor stub

System.out.println("into selfException");

}

打印结果：

selfException

at HelloWorld.main(HelloWorld.java:17)

into selfException

3，override相关知识点

子类方法不能缩小父类方法的访问权限：影响多态性，例如一个父类的对象，用子类实例化，调用覆写的方法。。。；

子类方法不能抛出比父类更多的异常；

父类的静态方法不能被子类覆盖为非静态方法，编译出错；

子类可以定义与父类静态方法同名的静态方法，子类隐藏父类的静态方法跟子类覆盖父类的实例方法区别在于：运行时，java虚拟机把静态方法跟所属的类绑定，实例方法和所属的实例绑定。例如：

public class Test {

public static void main(String args[]){

Base base1=new Sub();

base1.print();

base1.printStatic();

}

class Base {

void print(){

System.out.println("打印父类的动态函数");

}

static void printStatic(){

System.out.println("打印父类静态函数");

}

class Sub extends Base {

void print(){

System.out.println("打印子类的动态函数");

}

static void printStatic(){

System.out.println("打印子类静态函数");

}

结果：

打印子类的动态函数

打印父类静态函数

父类的非静态方法不能被覆盖为静态方法，编译出错

父类的非抽象方法可以被覆盖为抽象方法

作业：

1.for

避七游戏

// 打印1~100之间除了7的倍数或者带7的数字

public static void main(String args[]){

for (int i = 1; i <= 100; i++) {

if (i%7!=0&&i%10!=7&&i/10%7!=0) {

System.out.println(i);

}

2.// 用while做

// 请输入一个数字(按0退出):

// 78

// 请输入一个数字(按0退出):

// 12

// 请输入一个数字(按0退出):

// 99

// 请输入一个数字(按0退出):

// 0

// 最大值为：99

// 最小值为：12

public static void main(String args[]){

Scanner scanner=new Scanner(System.in);

int input;

int i=0;

int max=Integer.MIN_VALUE;

int min=Integer.MAX_VALUE;

int temp;

while (i<10000) {

System.out.println("请输入一个数字(按0退出):");

input=scanner.nextInt();

if (input==0) {

break;

}

if (input>max) {

max=input;

}

if (input<min) {

min=input;

}

i++;

}

System.out.println("最大值："+max);

System.out.println("最小值："+min);

}

3.// 求100~999之间的水仙花数：

// 水仙花数：各个位的立方和等于他本身称为水仙花数。

// 153: 1 + 125 + 27 = 153

public static void main(String args[]){

int sum=0;

for (int i = 100; i < 1000; i++) {

sum=(i%10)*(i%10)*(i%10)+(i/10%10)*(i/10%10)*(i/10%10)+(i/100)*(i/100)*(i/100);

if (sum==i) {

System.out.println(i);

}

4.// 求1~1000之间的完数：

// 完数：除了自己本身以外的因数和等于他本身

// 10: 1+2+ 5=8 不是完数

// 6:1+2+ 3 = 6 是完数

public static void main(String args[]){

for (int i = 1; i <=1000; i++) {

int sum=0;

for (int j = 1; j < i; j++) {

if (i%j==0) {

sum=sum+j;

}

if (sum==i) {

System.out.println(i);

}

5.// 在控制台打印九九乘法表:被乘数*乘数=积

// 1*1=1

// 1*2=2 2*2=4

// 1*3=3 2*3=6 3*3=9

// ......

// 1*9=9 2*9=18 ... 9*9=81

public static void main(String args[]){

for (int i = 1;i < 10; i++) {

for (int j = 1; j < i+1; j++) {

System.out.print(j+"*"+i+"="+i*j+" ");

if (j==i) {

System.out.println("\n");

}

// ****

public static void main(String args[]){

for (int i = 0; i < 4; i++) {

for (int j= 0; j < 4; j++) {

System.out.print("*");

if (j==3) {

System.out.println("\n");

}

}7.

// *

// **

// ***

// ****

public static void main(String args[]){

for (int i = 0; i < 4; i++) {

for (int j= 0; j < i+1; j++) {

System.out.print("*");

if (j==i) {

System.out.println("\n");

}

// ****

// ***

// **

// *

public static void main(String args[]){

for (int i = 4; i >=0; i--) {

for (int j= 0; j < i+1; j++) {

System.out.print("*");

if (j==i) {

System.out.println("\n");

}

// ****

// ***

// **

// *

public static void main(String args[]){

for (int i = 4; i >=0; i--) {

for (int j2 = i; j2 <4; j2++) {

System.out.print(" ");

}

for (int j= 0; j < i+1; j++) {

System.out.print("*");

if (j==i) {

System.out.println("\n");

}

10.

//****

// ***

// **

// *

public static void main(String args[]){

for (int i = 4; i >=0; i--) {

for (int j2 = i; j2 <4; j2++) {

System.out.print(" ");

}

for (int j= 0; j < i+1; j++) {

System.out.print("*");

if (j==i) {

System.out.println("\n");

}

11.

// *

// ***

// *****

// *******

public static void main(String args[]){

int i=1;

while(i<8) {

for (int j = 1; j <4-i/2; j++) {

System.out.print(" ");

}

for (int j = 1; j <=i; j++) {

System.out.print("*");

if (j==i) {

System.out.print("\n");

}

i=i+2;

}

12.

//*******

// *****

// ***

// *

public static void main(String args[]){

int i=7;

while(i>=1) {

for (int j = 1; j <4-i/2; j++) {

System.out.print(" ");

}

for (int j = 1; j <=i; j++) {

System.out.print("*");

if (j==i) {

System.out.print("\n");

}

i=i-2;

}

13.

// *

// ***

// *****

// *******

// *****

// ***

// *

public static void main(String args[]){

int i=1;

while(i<6) {

for (int j = 1; j <4-i/2; j++) {

System.out.print(" ");

}

for (int j = 1; j <=i; j++) {

System.out.print("*");

if (j==i) {

System.out.print("\n");

}

i=i+2;

}

int k=7;

while(k>=1) {

for (int j = 1; j <4-k/2; j++) {

System.out.print(" ");

}

for (int j = 1; j <=k; j++) {

System.out.print("*");

if (j==k) {

System.out.print("\n");

}

k=k-2;

}

14.

// *

// * *

// *

public static void main(String args[]){

int i=1;

while(i<6) {

for (int j = 1; j <4-i/2; j++) {

System.out.print(" ");

}

for (int j = 1; j <=i; j++) {

if (j==1||j==i) {

System.out.print("*");

}else {

System.out.print(" ");

}

if (j==i) {

System.out.print("\n");

}

i=i+2;

}

int k=7;

while(k>=1) {

for (int j = 1; j <4-k/2; j++) {

System.out.print(" ");

}

for (int j = 1; j <=k; j++) {

if (j==1||j==k) {

System.out.print("*");

}else {

System.out.print(" ");

}

if (j==k) {

System.out.print("\n");

}

k=k-2;

}

第五天：

1，加了final：类不能被继承；方法不能被覆盖；变量取值为常量

2，接口中默认是 public abstract方法和 public static final的变量

5,try...catch....finally

Finnally代码块在return语句之前被执行，但是在finally代码块中不能通过重新给变量赋值的方式，改变return语句中的变量返回值；

不要在finnally中使用return

第六天

1，常用的类：

字符串相关的类String：不可变的字符序列 charAt indexOf equalsIgnoreCase startsWith trim toUpperCase toLowerCase endsWith substring valueOf split

StringBuffer:可变的字符序列 append delete indexOf reverse

基本数据类型包装类：Integer Boolean Character Double Float Long

例：float1.intValue（）把float转换为int ；Float.parseFloat("6.55") 把字符串转换为float数字；Float.valueOf("33.4")把字符串转换为Double对象

Math类:abs。。。。

File类：File.separator file.isDirectory()

枚举类

2，JVM

寄存器：cpu使用

本地方法区：操作系统的

方法区：主要用于加载。包括常量池和静态域（共享区）

栈区：函数运行在栈内存

堆：变量有默认值

整型 0

浮点 0.0

Boolean false

Char 空字符

引用类型 null

Str[i]==null null表示一个空指向，用==

3，创建一个二维数组，确定一维数组的个数，但是没有给元素的一维数组分配内存空间，需要手动分配

例如：int array[][]=new int[3][];

Array[0]=new int[4];

创建一个二维数组，给元素的一维数组分配空间，不需要手动分配

例如：int array[][]=new int[3][4];

创建二维数组并且赋值

Int array[][]=new int[][]{{1,2,4},{24,4,2},{6,67,5}};

Int array[][]={{1,2,4},{24,4,2},{6,67,5}};

作业：

1.反转数组元素

//1.反转数组元素

String arry[]={"ee","42","97","rw"};

String arry1[]=new String[arry.length];

System.out.println("反转之前");

for (int i = 0; i < arry.length; i++) {

arry1[arry.length-i-1]=arry[i];

System.out.print(arry[i]+" ");

}

System.out.println();

System.out.println("反转之后");

for (int i = 0; i < arry1.length; i++) {

System.out.print(arry1[i]+" ");

}

2.public static void main(String args[]){

// 2.数组a：1,2,3

// 数组b：4,5,6

// 创建数组c合并两个数组

int []a={1,2,3};

int []b={4,5,6};

int []c=new int[a.length+b.length];

for (int i = 0; i < a.length; i++) {

c[i]=a[i];

}

for (int i = 0; i < b.length; i++) {

c[i+a.length]=b[i];

}

for (int i = 0; i < c.length; i++) {

System.out.print(c[i]+" ");

}

3.public static void main(String args[]){

// 3.第一个班级同学成绩为： 78 98 65

// 第二个班级同学成绩为：45,69,99,48

// 第三个班级同学成绩为：77,88,99,100,60

// 创建二维数组存储学生成绩，并求出每个班级的成绩和

int arr[][]={{78,98,65},{45,69,99,48},{77,88,99,100,60}};

for (int i = 0; i < arr.length; i++) {

int sum=0;

for (int j = 0; j < arr[i].length; j++) {

sum=sum+arr[i][j];

}

System.out.println("第"+(i+1)+"个班级的成绩是："+sum);

}

第七天：

1，文件例子

//递归打印目录

File file=new File("c:"+File.separator+"a");

System.out.println(file.getName());

tree(file,0);

}

static void tree(File f,int level){

String preString=" ";

for (int i = 0; i <level; i++) {

preString+=" ";

}

File []childs=f.listFiles();

for (int i = 0; i < childs.length; i++) {

System.out.println(preString+childs[i].getName());

if (childs[i].isDirectory()) {

tree(childs[i],level+1);

}

打印结果：

g.txt

e.txt

f.txt

c.txt

2，容器

Set：没有顺序，不能重复

List：有顺序，可以重复

Map

结构：

Collection

Set list Map

HashSet LinkList ArrayList HashMap

2,图书馆借还书

System.out.println("欢迎使用DVD管理器");

System.out.println("-------------------");

System.out.println("1. 新增 DVD");

System.out.println("2. 查看 DVD");

System.out.println("3. 删除 DVD");

System.out.println("4. 借出 DVD");

System.out.println("5. 归还 DVD");

System.out.println("6. 退出");

System.out.println("-------------------");

System.out.println("----->请选择：");

最多可以容纳6个dvd

创建4个数组：状态、名称、日期、次数

序号状态名称借出日期借出次数

1 已借出罗马假日 1 15

2 可借风声鹤唳 12

3 可借浪漫满屋 30

public class Test {

public static void main(String[] args) {

System.out.println("欢迎使用DVD管理器");

System.out.println("-------------------");

System.out.println("1.新增 DVD");

System.out.println("2.查看 DVD");

System.out.println("3.删除 DVD");

System.out.println("4.借出 DVD");

System.out.println("5.归还 DVD");

System.out.println("-------------------");

System.out.println("----->请选择：");

Scanner scanner = new Scanner(System.in);

int input = scanner.nextInt();

// 创建4个数组：状态、名称、日期、次数

int state[] =new int[6];// 0可借1不可借

String name[] = new String[6];

int date[] =new int[6];

int count[] =new int[6];

// 初始化

state[0] = 1;

name[0] = "罗马假日";

date[0] = 1;

count[0] = 15;

name[1] = "风声鹤唳";

count[1] = 12;

name[2] = "浪漫满屋";

count[2] = 30;

do {

switch (input) {

case 1:

System.out.println("请输入新增DVD名称：");

String nStr=scanner.next();

for (int i = 0; i < 6; i++) {

if (name[i]==null) {

name[i]=nStr;

System.out.println("添加"+nStr+"成功");

System.out.println("按0返回：");

break;

}

break;

case 2:

System.out.println("序号\t状态\t名称\t\t借出日期\t借出次数");

for (int i = 0; i < 6; i++) {

if (state[i]==1) {

System.out.println((i + 1) +"\t" + "已借出"+"\t"

+ name[i] + "\t\t" + date[i] +"\t" + count[i]);

}

if (state[i]==0) {

System.out.println((i + 1) +"\t" + "可借" +"\t"

+ name[i] + "\t\t" +"\t" + count[i]);

}

if(name[i+1]==null){

break;

}

System.out.println("按0返回：");

break;

case 3:

System.out.println("请输入删除DVD名称：");

System.out.println();

String s=scanner.next();

for (int i = 0; i < 6; i++) {

if (s.equals(name[i])) {

for (int j = i; j <5; j++) {

state[j] = state[j+1];

name[j] = name[j+1];

date[j] = date[j+1];

count[j] = count[j+1];

}

System.out.println("删除"+s+"成功");

System.out.println("按0返回：");

break;

}

break;

case 4:

System.out.println("请输入借出书籍名字：");

System.out.println();

String n=scanner.next();

for (int i = 0; i < 6; i++) {

if (name[i].equals(n)) {

if (state[i]==1) {

System.out.println(n+"已借出");

System.out.println("按0返回：");

break;

}

if (state[i]==0) {

System.out.println("请输入借出日期");

int d=scanner.nextInt();

date[i]=d;

state[i]=1;

count[i]++;

System.out.println("书籍成功借出");

System.out.println("按0返回：");

break;

}

break;

case 5:

System.out.println("要归还的书籍：");

String reString=scanner.next();

for (int i = 0; i <6; i++) {

if (name[i].equals(reString)) {

state[i]=0;

System.out.println("书籍成功归还");

System.out.println("按0返回：");

break;

}

break;

}

if (scanner.nextInt()==0) {

System.out.println("欢迎使用DVD管理器");

System.out.println("-------------------");

System.out.println("1.新增 DVD");

System.out.println("2.查看 DVD");

System.out.println("3.删除 DVD");

System.out.println("4.借出 DVD");

System.out.println("5.归还 DVD");

System.out.println("-------------------");

System.out.println("----->请选择：");

input=scanner.nextInt();

}

} while (input!=0);

}

第八天：

学习目标：理解面向对象思想，学会使用常用的类

1，容器类对象调用remove，contains方法会比较对象是否相等，涉及equals和hashCode方法，自定义类需要重写这两个方法。

相等的对象，hashcode相等

2，isEmpty clear contains add remove shuffle

iterator 迭代器（hasNext next remove）:游标，remove是在迭代过程中删除元素唯一安全的方法，是iterator中的remove

3，增强的for循环 for（Object o；c）{system。。。o}

只能看不能改，简单遍历是唯一的好处

4，List接口：get set add remove indexOf

Collections提供静态方法实现基于List的常用算法: sort shuffle reverse fill copy binarySearch

5，Comparable接口：compareTo方法复写

6，array读快改慢；linked改快读慢；hash两者之间

7，map：HashMap TreeMap

第九天

1，匿名对象,只用一次的时候，节省命名资源，通常跟属性无关

New Student().study();

2，如果写了构造方法，不会默认分配无参构造，需要手动分配一个无参构造

构造方法可以相互调用，对构造方法的调用必须在第一句，只能有一个

避免递归构造器

可以使用return；只作为结束方法，通常不用

This不可以在静态方法中使用

3，工具类：私有化构造方法，属性方法用static修饰，类名调用，Math.PI

3, 代码块：定义在方法中{}

4，构造代码块：{}定义在类中。在调用构造器之前执行。类似于对构造器的补充说明，构造器的第一句。

创建对象之前被执行的时候，使用构造代码块。

5,静态代码块，定义在类中。Static{}

只被加载一次。创建对象之前优先执行。

6，23种设计模式。

单例模式：保证该类型所有变量指向同一个地址。

避免new---私有化构造方法

如果需要让多个对象地址唯一，可以创建single类型的变量作为静态变量。

可以满足需求，但是不满足封装

使用方法获得该属性

懒汉式：

饿汉式：

public class Single {

private Single(){} -----私有化构造函数

//饿汉式

//private static Single s=new Single(); -----赋值

//public static Single getInstance () {

//return s;

//}

//懒汉式

private static Single s=null;-------------不赋值

public static Single getInstance(){

if (s==null) {

s=new Single();

}

return s;

}

7，自动打包，解包

第九天：

1，泛型 List<String> c=new ArrayList<String>();

增强可读性

2，io

字节流　　　　　字符流

输入流 InputStream Reader

输出流OutputStream Writer

InputStream:FileInputStream,PipeInputStream,FilterInputStream,ByteArrayInputStream,...

基本方法：read（byte[]buffer）一个一个读取损伤硬盘，读到buffer中

OutputStream：write close flush

第十天

1，文件流fileInput fileOutput

public static void main(String[] args) {

try {

FileInputStream fInputStream=new FileInputStream("c:\\intouch\\in.txt");

FileOutputStream fOutputStream=new FileOutputStream("c:\\intouch\\out.txt");

try {

byte b;

while((b=(byte) fInputStream.read())!=-1){

fOutputStream.write(b);

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

2，bufferedInputStream:处理流

//文本

//12345jowuqopjnlsggpw;jlgpjgqjpo

public static void main(String[] args) throws IOException {

FileInputStream fInputStream=new FileInputStream("c:\\intouch\\in.txt");

BufferedInputStream bfin=new BufferedInputStream(fInputStream);

System.out.println((char)bfin.read());

char c;

bfin.mark(6);

for (int i = 0; i < 10&&(c=(char) bfin.read())!=-1; i++) {

System.out.print(c+" ");

}

System.out.println();

bfin.reset();

for (int i = 0; i < 10&&(c=(char) bfin.read())!=-1; i++) {

System.out.print(c+" - ");

}

bfin.close();

}

3 4 5 j o w u q o p

3 - 4 - 5 - j - o - w - u - q - o - p -

3，阻塞式方法

Readline 等着同步方法

4，A instanceof B A是否可以转换为B类型

第十一天：

1，重写(覆盖)：Override

1.在父子类中

2.方法名相同

3.参数列表相同

4.返回值相同或者子类返回值是父类返回值的子类。

5.访问权限相同或者子类高于父类的访问权限。

(子类更大方)

6.子类不能抛出比父类更多的异常。

重载：Overload

1.在同一类中

2.方法名相同

3.参数列表不同

4.与返回值无关

2，每一个构造方法在第一句一定会调用一个其他构造方法(本类的|父类的)，

在一个类中至少有一个构造方法是调用父类构造方法的。否则

会出现递归构造器。

当父类没有无参构造方法的时候，子类在构造器中没有特别的声明

会编译报错，所以为了安全，会在父类中声明一个无参的构造方法。

3，---->静态方法

1.当父类有一个静态方法，子类没有，用子类对象调用该方法，

调用的是父类的。

2.当父类有一个静态方法，子类也有，用子类对象调用该方法，

调用的是子类的。(就近原则)

静态方法不存在覆盖！！

3.调用静态方法，通常使用类名调用。

多态:

事物的多种表现形态。

方法的重载和重写都是多态性的体现。

父类类型指向子类对象。

父类名对象名 = new 子类();--->向上转型。

向上转型：无法调用子类特有的内容。

--->属性

1.如果父类有一个属性，子类没有，调用该属性调用是父类的。

2.如果父类有一个属性，子类也有，调用该属性调用是父类的。

3.如果父类没有属性，子类有一个，调用该属性编译报错！！！

--->方法

1.如果父类有一个方法，子类没有，调用该方法调用的是父类的。

2.如果父类有一个方法，子类也有，调用该方法调用的是子类的。

方法覆盖！

3.如果父类没有方法，子类有一个方法，调用该方法，编译报错！！！

--->静态方法

1.如果父类有一个静态方法，子类没有，调用该方法调用的是父类的。

2.如果父类有一个静态方法，子类也有，调用该方法调用的是父类的。

静态方法不存在覆盖！

调用静态方法的时候使用类名去调用。

3.如果父类没有静态方法，子类有，调用该方法编译报错！！！

向下转型是在向上转型的基础上的。

子类类型对象 = (子类类型)父类类型对象;

instanceof--->运算符结果为布尔

对象名 instanceof 类型-->判断对象是否可以转换成该类型。

4，Printstream

DataInputStream DataOutputStream:存取java的原始数据类型

5，标记性的接口 serializable 接口，序列化，把对象序列化为字节流

ObjectInputStream

Transient,透明的，声明不能序列化的属性

Externalizable接口，可以自己控制序列化过程，可读，可写，不建议

6，总结常用的流

InputStream/OutputStream

Reader/Writer

FileInputStream/FileOutputStream

FileReader/FileWriter

BufferedInputStream/BufferedOutputStream

BytearrayinputStream/BytearrayOutputStream

InputStreamReader/OutputStreamWriter

DataInpuStream/out

PrintStream/PrintWriter

ObjectInputStream/out

7,抽象父类：

Employee(员工)

属性：姓名、年龄、工号、底薪

计算工资的方法--->抽象方法

子类：

经理(EP):底薪+奖金

销售(Saler):底薪+200*个数

工人(Worker):底薪

创建数组存储员工，遍历出员工的信息

姓名年龄工号总工资

public abstract class Employee

{

private String name;

private int age;

private int num;

private int basicMoney;

public Employee(){}

public Employee(String name,int age,int num,int basicMoney){

this.name=name;

this.age=age;

this.num=num;

this.basicMoney=basicMoney;

}

public void setName(String name){

this.name=name;

}

public String getName(){

return name;

}

public void setAge(int age){

this.age=age;

}

public int getAge(){

return age;

}

public void setNum(int num){

this.num=num;

}

public int getNum(){

return num;

}

public void setBasicMoney(int basicMoney){

this.basicMoney=basicMoney;

}

public int getBasicMoney(){

return basicMoney;

}

public abstract int moneyCount();

}

class Worker extends Employee

{

//工人

public Worker (){}

public Worker (String name,int age,int num,int basicMoney){

super(name,age,num,basicMoney);

}

public int moneyCount(){

return super.getBasicMoney();

}

class Saler extends Employee

{

//销售

private int count;

public Saler(){}

public Saler(String name,int age,int num,int basicMoney,int count){

super(name,age,num,basicMoney);

this.count=count;

}

public void setCount(int count){

this.count=count;

}

public int getCount(){

return count;

}

public int moneyCount(){

return (super.getBasicMoney()+count*200);

}

class EP extends Employee

{

//经理

private int bonus;

public EP(){}

public EP(String name,int age,int num,int basicMoney,int bonus){

super(name,age,num,basicMoney);

this.bonus=bonus;

}

public int moneyCount(){

return (bonus+super.getBasicMoney());

}

public int getBonus(){

return bonus;

}

public void setBonus(int bonus){

this.bonus=bonus;

}

class Run

{

public static void main(String[] args)

{

EP ep=new EP("王经理",27,3242,3000,5000);

Saler sl=new Saler("销售甲",32,4456,2000,7);

Worker w=new Worker("小刘",22,5532,4000);

Employee em[]={ep,sl,w};

System.out.println("姓名"+"\t"+"年龄"+"\t"+"工号"+"\t"+"总工资");

for(int i=0;i<em.length;i++){

System.out.println(em[i].getName()+"\t"+em[i].getAge()+"\t"+em[i].getNum()+"\t"+em[i].moneyCount());

}

第十二天

1，线程

一个程序的执行路径

每一个分支都是线程，main方法是主线程

线程是进程里的不同执行路径

进程和线程的区别：

每个进程：有独立的代码空间和数据空间，进程间切换开销大

线程：轻量级的进程，同一类线程共享代码和数据空间，有独立的运行栈和程序计数器，切换开销小

多进程：操作系统中同时运行多个任务

多线程：同一个应用程序中有多个顺序流同时执行

实现方法：

Tread类中 run start

Runnable 接口

第一种：实现Runnable接口

public class Test {

public static void main(String[] args) throws IOException {

testRun testRun=new testRun();

testRun.run();

//Thread thread=new Thread(testRun);

//thread.start();

for (int i = 0; i < 1000; i++) {

System.out.println("test main"+i);

}

class testRunimplements Runnable{

@Override

public void run() {

// TODO Auto-generated method stub

for (int i = 0; i <1000 ; i++) {

System.out.println("test Run"+i);

}

第二种，继承thread类

public class Test {

public static void main(String[] args) throws IOException {

testRun testRun=new testRun();

testRun.start();

//Thread thread=new Thread(testRun);

//thread.start();

for (int i = 0; i < 1000; i++) {

System.out.println("test main"+i);

}

class testRunextends Thread{

@Override

public void run() {

// TODO Auto-generated method stub

for (int i = 0; i <1000 ; i++) {

System.out.println("test Run"+i);

}

选择实现接口的方式！！

2，线程的状态

Start()就绪

isAlive()

getPriority() setPriority()

Thread.sleep()

Join

Yield

Wait

Notify

notifyAll

3，线程同步

synchronized

4,作业

import java.util.Scanner;

public class Test

{

public static void main(String args[]){

int control=0;

do{

Cat c= new Cat();

Duck d= new Duck();

Dolphin dol= new Dolphin();

Animal a[]={c,d,dol};

Scanner s=new Scanner(System.in);

System.out.println("请输入小猫的名字：");

String cName=s.next();

c.setName(cName);

System.out.println("请输入小猫的腿个数：");

int l1=s.nextInt();

if(l1!=4){

try {

throw new Exception();

} catch (Exception e) {

// TODO Auto-generated catch block

System.out.println("小猫只能有4条腿");

}

continue;

}

c.setLeg(l1);

System.out.println("请输入鸭子的名字：");

String dName=s.next();

d.setName(dName);

System.out.println("请输入鸭子的：腿个数");

int l2=s.nextInt();

if(l2!=2){

try{

throw new Exception();

}

catch(Exception e){

System.out.println("鸭子只能有2条腿");

}

continue;

}

d.setLeg(l2);

System.out.println("请输入海豚的名字：");

String dolName=s.next();

dol.setName(dolName);

System.out.println("名字"+"\t"+"腿的个数"+"\t"+"叫声");

for(int i=0;i<a.length;i++){

System.out.println(a[i].getName()+"\t"+a[i].getLeg()+"\t\t"+a[i].voice());

}

System.out.println("按0修改信息，按其他任意数字键退出：");

control=s.nextInt();

System.out.println(control);

if(control !=0){

break;

}

}while(control ==0);

}

abstract class Animal

{

private String name;

private int leg;

Animal(){}

Animal(String name,int leg){

this.name=name;

this.leg=leg;

}

public int getLeg(){

return this.leg;

}

public void setLeg(int leg){

this.leg=leg;

}

public String getName(){

return this.name;

}

public void setName(String name){

this.name=name;

}

public abstract String voice();

}

class Cat extends Animal

{

Cat(){}

Cat(String name,int leg){

super(name,leg);

}

public String voice(){

return "喵喵喵";

}

class Duck extends Animal

{

Duck(){}

Duck(String name,int leg){

super(name,leg);

}

public String voice(){

return "嘎嘎嘎";

}

class Dolphin extends Animal

{

Dolphin(){}

Dolphin(String name,int leg){

super(name,leg);

}

public String voice(){

return "海豚音";

}

第十三天：

1,同步

import java.io.IOException;

public class Testimplements Runnable{

int a=100;

public void m2() {

System.out.println(a);

}

synchronized public void m1(){

a=1000;

try {

Thread.sleep(1000);

} catch (Exception e) {

// TODO: handle exception

}

@Override

public void run() {

// TODO Auto-generated method stub

m1();

}

public static void main(String[] args) throws IOException {

Test test=new Test();

Thread thread=new Thread(test);

thread.run();

test.m2();

}

2，生产者和消费者

import java.io.IOException;

public class Testimplements Runnable{

int a=100;

public void m2() {

System.out.println(a);

}

synchronized public void m1(){

a=1000;

try {

Thread.sleep(1000);

} catch (Exception e) {

// TODO: handle exception

}

@Override

public void run() {

// TODO Auto-generated method stub

m1();

}

public static void main(String[] args) throws IOException {

Test test=new Test();

Thread thread=new Thread(test);

thread.run();

test.m2();

3，wait别的线程可以访问锁，调用wait方法的时候必须锁定对象

Sleep时，别的线程也不能访问锁定对象

}

第十三天

1，网络编程

import java.io.DataOutput;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.net.Socket;

import java.net.UnknownHostException;

public class TCPClient {

public static void main(String args[]) throws IOException{

Socket socket=new Socket("127.0.0.1",6666);

//客户端输出

OutputStream oStream=socket.getOutputStream();

DataOutputStream dos=new DataOutputStream(oStream);

dos.writeUTF("Hello Server");

dos.flush();

dos.close();

socket.close();

}

import java.io.DataInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.net.*;

public class TCPServer {

//1，客户端端口

//2，服务器端建立访问

//3，客户端输出信息给服务器端

//4服务器输出信息

public static void main(String args[]) throws IOException{

//端口号6666的端口建立监听

ServerSocket serverSocket=new ServerSocket(6666);

//建立一个socket

while(true){

Socket socket=serverSocket.accept();

System.out.println("访问server");

//服务器端访问到的是客户端输出的信息

DataInputStream inputStream=new DataInputStream(socket.getInputStream());

System.out.println(inputStream.readUTF());

}

2，UDP

public class UDPServer {

public static void main(String args[]) throws IOException{

byte buf[]=new byte[1024];

DatagramPacket dPacket=new DatagramPacket(buf, buf.length);

DatagramSocket dSocket=new DatagramSocket(5678);

while(true){

dSocket.receive(dPacket);

System.out.println(new String(buf,0,dPacket.getLength()));

}

public class UDPClient {

public static void main(String args[]) throws IOException{

byte []but=(new String("Hello")).getBytes();

DatagramPacket dPacket=new DatagramPacket(but, but.length,new InetSocketAddress("127.0.0.1",5678));

DatagramSocket dSocket=new DatagramSocket(9999);

dSocket.send(dPacket);

dSocket.close();

}

3，jdk里面的classloader

Bootstrap class loder 最顶层

最核心的类被这个classloder load进来

使用c++等操作系统本地语言编写，没有名字，无法使用

System.out.println(String.class.getClassLoader());

Extension class loader:被Bootstrap load进来

扩展内容,class from jre/lib/ext

Appication class loader:

System.out.println(A.class.getClass().getName());

我们自己写的类的classloader

Other classloader:secure url

第十四天

1，classLoader的层次关系，不是继承关系

App class loader---->Ext class loader--->Boogstrap class loader

2,反射，便于把各种类名归类到一个文件里面

Class c=Class.forName(“A”);把一个类转载到内存

c.newInstance();

public class Reflection {

public static void main(String args[]) throws Exception{

String str="A";

//加载类到内存内存

Class c=Class.forName(str);

//实例化

c.newInstance();

Method []methods=c.getMethods();

for (int i = 0; i < methods.length; i++) {

System.out.println(methods[i].getName());

if (methods[i].getName().equals("print")) {

methods[i].invoke(c.newInstance(),13,434);

Class pClass[]=methods[i].getParameterTypes();

for (int j = 0; j < pClass.length; j++) {

System.out.println(pClass[i].getName());

}

Class retClass=methods[i].getReturnType();

System.out.println("returnType:"+retClass.getName());

}

class A{

static{

System.out.println("加载到内存");

}

int i;

String s ;

public A(){

System.out.println("实例化");

}

public void print(int i,int j){

this.i=i;

System.out.println("A.print()参数"+i+","+j);

}

public void print2(){

System.out.println("A.print2()");

}

结果：

加载到内存

实例化

A.print()参数13,434

int

returnType:void

print2

wait

hashCode

getClass

equals

toString

notify

notifyAll

3，正则表达式

. 任意字符

* + ?

X{n} X{n,} X{n,m} X出现最少n次，最多m次

[0-3]范围

[abc]abc中的一个

[^abc]不是abc中的

[a-zA-Z]或者

[A-Z]|[a-z]或者

[A-Z[a-z]]或者

[A-Z&&[RGF]]

\d [0-9]

\D [^0-9]

\s [ \t\n\x0B\f\r] backspace 制表符回车

\w [a-zA-Z0-9]

Unix

\p{lower} [a-z]

^h.* 开头结尾边界处理

第十五天

1,快捷方式

Alt+/

syso

Ctrl+shif+o 自动导入包，去掉多余的包

Ctrl+d 删除一行

Alt+上下箭头上下移动

生成java文档：project菜单下

2,Object

Clone() equals finalize getClass

hashCode notify notifyAll

toString wait

3,被final修饰的方法可以被重载不能被重写

4，Pattern pattern=Pattern.compile("\\d{3,5}");

Matcher matcher=pattern.matcher("23-453-223-553-2-23-2");

matcher.reset(); ？？？？？？？？

p(matcher.matches());

p(matcher.find());

p(matcher.start()+"-"+matcher.end());

p(matcher.find());

p(matcher.start()+"-"+matcher.end());

p(matcher.find());

p(matcher.start()+"-"+matcher.end());

p(matcher.lookingAt()); ？？？？？？？？

p(matcher.lookingAt());

5，正则表达式的分组

Pattern pattern=Pattern.compile("(\\d{3,5})([a-z]{2})");

Matcher matcher=pattern.matcher("23wr-453weoiu-223uuu-553oek-2-23-2");

while (matcher.find()) {

p(matcher.group(1));

p(matcher.group(2));

}

打印：

453

223

553

6，API,常见的内置类

Object源码中的equals方法比较的是地址，所以要比较一个对象时，需要重写equals方法。

Equals覆写方法原则？？套路！！！死记硬背

哈希：根据属性值来重写hashcode方法

重写toString

String的8个构造方法掌握！！

7，作业：

package exercise;

import java.util.Scanner;

/**

* 1.在控制台上输入一个字符串：

hello

请输入一个字符：

l在hello中出现了2次

求某字符在字符串中出现的次数。

2.输入一个字符串：

abcccdecccegfccc

出现次数最多的字符为c，次数为9次

public class Test0628 {

public static void main(String[] args) {

Scanner scanner=new Scanner(System.in);

System.out.println("请输入Hello：");

String str=scanner.next();

char c[]=str.toCharArray();

int count=0;

for (int i = 0; i < c.length; i++) {

if (c[i]=='l') {

count++;

}

System.out.println("l共出现"+count+"次");

String string="abcccdecccegfccc";

char array[]=string.toCharArray();

int cNum[]=new int[array.length];

int k=0;

int m=0;

for (int i = 0; i < array.length; i++) {

for (int j = 0; j < array.length; j++) {

if (array[j]==array[i]) {

k++;

}

cNum[i]=k;

k=0;

}

int index=0;

int max=Integer.MIN_VALUE;

for (int i = 0; i < cNum.length; i++) {

if (cNum[i]>max) {

max=cNum[i];

index=i;

}

System.out.println("出现最多的字符是："+array[index]+"共"+max+"次");

}

第十五天

1，重写Object中的equal，hashcode，tostring方法

hashCode

* 重写Object中的hashCode方法。

* 需要根据属性值来重写。

public int hashCode(){

//return name.hashCode() + age;

/* zs 100 20

* ls 90 30

final int prime = 31;

int result = 1;

result = result * prime + age;

result = result * prime + (name == null ? 0 : name.hashCode());

return result;

}

* 重写Object中的equals方法

* 比较两个对象的内容是否相同

* this vs obj

public boolean equals(Object obj){

if(this == obj){//如果两个对象相同

return true;

}

if(obj == null){//如果参数对象为null，内容一定不相同

return false;

}

//判断obj是否为Student类型

/*if(!(obj instanceof Student)){

//如果参数对象不是Student类型，直接return false

return false;

}*/

if(getClass() != obj.getClass()){

//如果两个字节码文件对象不同直接return false

return false;

}

Student stu = (Student)obj;//强转

//this vs stu ---->比较两个对象的属性值是否相同

if(age != stu.age){

//如果两个对象的年龄不同，直接返回false

return false;

}

if(name == null){

if(stu.name != null){

//this.name为null,而stu的name不为空，直接返回false

return false;

}????

}else if(!name.equals(stu.name)){

//this.name不为空，而且和stu的名字不同，直接返回false

return false;

}

return true;

}

//重写Object中的toString方法

public String toString(){

return "Student [name=" + name + ", age=" + age + "]";

}

第十六天

1，Integer i=33；

Integer j=33;

Syso(i==j); true

自动装箱的情况下，一个字节之内，共享内存空间

如果大于等于128，就是false

比较的还是地址

package exercise;

import java.io.IOException;

//* 1.new StringBuffer():

//* 2.new StringBuffer(String str)

//append

//* insert(int offset,所有类型)

//* delete(int start,int end):

//deleteCharAt(int index):删除下标为index的字符

//reverse

//* replace(int start,int end,Stringstr):

//* setCharAt(int index,charch)

//sb2.setLength(5);

//* 5.new String(byte[] bytes,int offset,int length)

//codePointAt

//public int hashCode(){

//public boolean equals(Object obj){

public class Test {

public static void main(String[] args) throws Exception {

String str="djiwofwjfie";

char array[]={3,2};

StringBuffer stringBuffer=new StringBuffer("jwoiabpwutabwpoeo");

StringBuilder stringBuilder=new StringBuilder();

System.out.println(stringBuffer.append(4).append("wof").append('e'));

int i=Integer.parseInt("333");

int j=Integer.valueOf("333");

System.out.println(String.valueOf(444));

System.out.println(Integer.toString(898));

System.out.println(stringBuffer+"---"+stringBuffer.delete(2, 5));

System.out.println(stringBuffer+"---"+stringBuffer.deleteCharAt(0));

System.out.println(stringBuffer+"---"+stringBuffer.reverse());

System.out.println(stringBuffer+"---"+stringBuffer.replace(3, 5,"mmm"));

stringBuffer.setCharAt(0, 'd');

System.out.println(stringBuffer);

stringBuffer.setLength(2);

System.out.println(stringBuffer);

byte []a={'e','m','c'};

String string=new String(a, 1, 2);

System.out.println(string);

//System.out.println(stringBuffer+"---"+);

Integer integer=90;

Integer k=90;

System.out.println(integer==k);

Integer m=128;

Integer n=128;

System.out.println(m==n);

System.out.println(stringBuffer.codePointAt(0));

StringBuffer s2=new StringBuffer("mababjoweuabowiua");

System.out.println(s2.indexOf("ab"));

String s3="jfiwo";

System.out.println(s3.compareTo("jfijwi"));

//正常退出 0非正常退出其他非零

//System.exit(0);

//System.out.println("exit");

//System.out.println(System.currentTimeMillis());

//Runtime runtime=Runtime.getRuntime();

//runtime.exec("mspaint");

//Process process=runtime.exec("mspaint");

//Thread.sleep(4000);

//process.destroy();

}

第十七天

1，常用的sql函数

lower(ename)小写

substr(ename,2,3) 截取3个字符，2开始

Chr（65）A

Ascii(’a’)

Round(33.4)

Round(3.344,2)

To_char（sal,$99,999,9999）转换成字符串

To_date(’1989-2-20 12:34:45’,’YYYY-MM-DD HH24:MI:SS’)转换成日期

To_number(’$1,234,33’,’$9,999,99’)转换成数字

Nvl(comm,0)如果是空就是0，如果不是空就是comm的值

组函数：

Avg（sal），sum（sal），Count（*）min（sal） max（sal）

Having 与group by一起用，对groupby进行限制，group by使用的时候，select列表里面需要组函数

固定语句：

Select...

From...

Where ...

Group by...

Having ...

Order by ..

子查询，可以出现在where中，from中

Select .. From emp

Join(select ..from)

On(..=..)

自连接，起别名

Left join 包括左边多余的部分

Right Outer join；right join

Full join 包括两边多余的部分

2，View：

Creat view v$_mm as

Select ...

3,insert

Update

Delete

Rownum默认列只有< <=

3,Html

Style link

bgcolor

阅读全文

0 0