java面向对象

啊啊啊杨

于 2022-10-18 13:03:17 发布

阅读量381

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_46079238/article/details/127386342

版权

一.java面向对象编程

1.常见的五种异常:

NullPointExceptionl空指针异常

算术异常

数组下标越界异常

ClassCastException类型转换异常

非法参数异常

（NumberFormatException数字格式异常）

2.this的作用有

区分成员变量和局部变量（同名的时候）（讲究一个就近原则）

调用成员变量和成员方法，作为方法的返回值

在构造方法的第一行可以使用this（）的方式调用本类中的其他构造方法

3.封装的流程实现？（通常情况下可以在测试类给成员变量赋值一些合法但是不合理的数值，无论是运行还是编译阶段都不会报错或者给出出错提示，此时与现实生活不符）

public string getName（）{
 return name；

public int getId（）{
 return id; 
}
public void setName(String name){
this.name=name;
}
public void setId(int id){
    if(id>0){
        this.id=id;}
}

1.私有化成员变量，使用private关键字修饰

2.提供公共有的get和set方法，并在方法体中进行合理值的判断

3.在构造方法中调用set方法进行合理值的判断

成员变量和成员方法一般都private

public class Studenttset2{
public static void main(Sting[] args){
Scanner sc=new Scanner(System.in);
int num=sc.nextInt();
Student[] arr=new Student[num];//声明一个长度为num的类型为Student的一维数组
for(int i=0;i<num;i++){
system.out.println("请输入第"+（i+1）+"个学生的信息")；
arr[i]=new Student(sc.nestInt(),sc.next())
}
System.out.println

    }
}

4.javaBean是一种Java语言写成的可重用软件，其它Java类可以通过反射机制发现和操作这些JavaBean的属性

JavaBean本质上就是符合以下标准的Java类：

1.类是公共的

2有一个无参的公共构造器

3.有属性，且有对应的get、set方法

//编程实现people类的封装
public class people {
private String name;
private int age;
public people();
public people(String name,int age,String country){
setName(name);
setAge(age);
setCountry(country);
}
private String country;
    public String getName(){
        return name }
    public int getAge(){
        return age;}
     public String getCountry(){
         return country;
     }
    public String setCountry(String country ){
    this.country=country;
        public int  setAge(int age ){
        this.age=age;
        }
        public String setName(String name ){
        this.name=name;
    }
    public void show(){
    System.out.println("我是"+getName()+"今年"+getAge+"岁了"+"来自"+getCountry); 
    }
    
}

使用static关键字修饰的成员变量表示静态的含义，此时所有的成员变量由对象层级提升为类层级，只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。

6. 构造块和静态代码块：当需要在执行构造方法之前做一些准备工作时，则将准备工作的相关代码写在构造快中即可，比如对成员变量进行统一的初始化操作。

每次创建对象都会执行代码块。静态代码块：有static修饰的

先执行静态代码块->构造块->构造方法

静态代码块只执行一次，是随着类的加载而准备就绪，先于代码块执行。例如：数据库的驱动包

父类子类6个顺序？

父类静态代码块-》子类静态代码块-》父类的构造块-》父类的构造方法体-》子类的构造块-》子类的构造方法体

7.要求main（）方法中能得到且只能得到该类的一个对象

private static ywc ywc=new ywc();//static将对象级提升为类级
private ywc(){}
public static ywc getYwc(){
    return ywc;
}

static静态变量是在方法区中

7.1在某种场合中，一个类对外提供且只提供一个对象时，这样的类叫做单例类，而设计单例的流程和思想叫做单例设计模式。

流程：1私有化构造方法，使用private关键字修饰

2.声明本类类型的引用指向本类类型的对象，并使用private sta tic 关键字共同修饰。

3.提供公有的get方法负责将对象返回出去，并使用public static 关键字共同修饰。

恶汉式和懒汉式

private static ywc ywc=new ywc（）；//饿汉式，，，开发中推荐，线程相关
pricate static ywc=null;//调用方法时才创建

8extends扩展表示继承关系

public class Fmq extends Ywc{}

Ywc：超类，父类。基类

FmqL:派生类、子类、孩子类

8.1子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问。

8.2无论使用何总方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法中的第一行增加代码super（）的效果。

第一行super（）//表示调用父类的无参构造方法

，有没有super（）都一样，系统会自动添加

8.3使用继承必须满足逻辑关系：is a

8.4Java语言中只支持单继承不支持多继承，即一个子类只能继承一个父类，但可以有间接子类。

C++支持多继承。

9方法重写（强调父类和子类之间）

9.1从父类中继承下来的方法不满足子类的需求时，就需要在在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，即override

9.2要求方法名相同、参数列表以及返回值类型相同，从Java5开始允许返回子类类型。

9.3要求访问方法的访问权限不能变小，可以相同或者变大。public->private就是错误的

9.4要求方法不能抛出更大的异常.

10IDE集成开发环境(Integrated Development environment)

//ctrl+shift+/ 进行选中内容的多行注释

//ctrl+/ 进行选中内容的单行注释

//alt+insert get,set方法等

//ctrl+d 复制当前行

//alt+shift+方向键可以移动代码

//ctrl +alt+方向键表示回到上一个或者下一个位置

//ctrl+f12来查找指定方法

11.访问控制符

public protected 默认 private

java.lang.System.out

12 Final

本意为最终的不可改变的，可以修饰类，成员方法和成员变量

1.final关键字修饰类体现在该类不能被继承，用于防止滥用继承，如java.lang.System.out

2.final修饰方法，该方法不能被重写，但是可以被继承，主要防止不经意间被重写

3.final关键字修饰成员变量必须被初始化而且不能被改变。可以在构造块中，构造方法体进行初始化，防止不经意间造成改变

13多态的概念

多态主要指同一种事物表现出来的多种形态。

实际意义是屏蔽不同子类的差异性实现通用的变成带来的不同的效果。

多态的语法格式：

父类类型引用变量名=new 子类类型（）；

如 Shape se=new Rect();

在编译阶段调用Shape中的方法，在运行阶段调用Rect类中的方法

多态的特点：

当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。

当父类类型的引用指向子类类型的对象时，父类类型的引用不能直接调用子类独有的方法。//

对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）。

对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。

14引用数据类型之间的转换：自动类型转换和强制类型转换

14.1自动类型转换

Shape sr=new Rect();  //子类到父类的转换，由小到大的转换

14.2强制类型转换

int ib = （Rect（sr））.getLen();//父类到子类的转换，由大到小的转换

14.3强制类型转换必须要求是父子类关系。

14.4 instanceof 的使用

15抽象方法，抽象类

15.1不能具体实现的方法，并且使用abstract关键字修饰，也就是没有方法体

格式；

访问权限 abstract 返回值类型方法名（形参列表）；

public abstract void cry（）；

15.2抽象类主要指不能具体实例化的类并且使用abstract 关键字修饰，也就是不能创建对象。

15.3抽象类中可以有抽象方法也可以没有。吧

15.4拥有抽象方法的必须是抽象类。有抽象方法的抽象类才能是真正的抽象类

15.5抽象类的实际意义不在于创建对象而在于被继承。当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也即是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。

15.6private，static，final 不能和abstract共存

16接口的基本概念

接口就是一种比抽象类还抽象的类，体现在所有方法都是抽象方法。关键字为interface

支持多实现

public interface Interface{ 
    public static final int CNT=1;
}

jdk1.9开始允许接口中出现私有方法

public class Gold implements Metal,Money{

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MC3PiKDW-1666068945026)(C:\Users\17453\AppData\Roaming\Typora\typora-user-images\image-20220712235942830.png)]

17.接口和抽象类的主要区别

17.1定义抽象类的关键字是abstract class ，定义接口的关键字是interface

17.2实现接口的关键字是implements ,继承抽象类的关键字是extends

17.3继承抽象类支持单继承，而实现接口支持多实现

17.4抽象类中可以有构造方法，而接口中不可以有构造方法

17.5抽象类中可以有成员变量，接口中只可以有常量

17.6抽象类中可以有成员方法，接口中只有抽象方法

17.7抽象类中增加方法时子类不用重写，而接口中增加方法是实现类需要重写。（Java8以前的版本）

17.8从Java8之后增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default 关键字修饰。

public default void show（）{
//这里仅仅是接口中的默认功能，实现类可以自由选择是否重写
    Sout("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！")
}

静态方法：

public static void run（）{
    //这里是静态 方法，可以直接通过接口名.的方式调用，省略对象的创建
}

17.9从Java9开始增加新特性，接口中允许出现私有方法（为了实现代码的复用）

18内部类

当一个类的定义出现在另一个类中的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）

类中的内容：成员变量、成员方法、构造方法、静态成员、构造快和静态代码块、内部类

实际作用：当一个类存在的价值仅仅是为某一各类单独服务时，那么就可以将这个类定义为所服务类的内部类，这样就可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员二不再需要提供公有的get和set方法。

内部类的分类：

普通内部类-直接将一个类的定义放在另一个类的类体中

静态内部类-使用static 关键字修饰的内部类，隶属于类层级。

局部内部类-直接将一个类的定义放在方法体的内部时

匿名内部类-就是指没有名字的内部类

18.1普通内部类的格式

访问修饰符 class 外部类的类名{

访问修饰符 class 内部类的类名{

内部类的类体；

}

/**
*编程实现普通内部类的定义和使用  ---文档注释
*/

public class NormalOuter{
    private int cnt=1;
    public class NormalInner{//public final class NormalInner
        private int ia=2;
        public NormalInner(){
            Sout("普通内部类的构造方法执行到了！")
        }
        public void show(){ 
            Sout("外部类数"+cnt);
            Sout("内部类数"+ia)
        }
        
        
    }
}

//测试类
public class NormalOuterTest{
    public class void mian(){
        NormalOuter no=new NormalOuter();
        NormalOuter.NormalInner ni=no.new NormalInner();
        ni.show();
    
    }
}

普通内部类的普通类一样可以定义成员变量、成员方法以构造方法等

普通内部类的普通类一样可以使用final或者abstract关键字修饰

普通内部类还可以使用private或protected关键字进行修饰

普通内部类需要使用外部类对象来创建对象

如果内部类访问外部类与本类本部同名的成员变量或者方法时，需要使用this关键字。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R1eR15PI-1666068945028)(C:\Users\17453\AppData\Roaming\Typora\typora-user-images\image-20220713172628870.png)]

18.2 静态内部类

public class StaticOuter{
    private int cnt=1;
    private static int snt=2；
    public static class StaticInner{//public final class NormalInner
        private int ia=2;
        public StaticInner(){
        private int ia=3；
        private static int snt=4;
            Sout("静态内部类的构造方法执行到了！")
        }
        public void show(){ 
            Sout("ia="+ia);
            Sout("外部类数"+snt )
            Sout("外部类中的cnt"+cnt)//Error 静态上细纹中不能访问非静态的成员，因为此时可能还没有创建对象
        }
        
        
    }
}

//测试类
public class StaticOuter{
     public static void main(String[] args){
     StaticOuter.StaticInner si=new StaticOuter.StaticInner();
     si.show();
     
     }
 }

内部类：美元符号

静态内部类不能直接访问外部类的非静态成员

静态内部类可以直接创建对象

如果静态内部类访问外部类中与本类内同名的成员变量或者方法时，需要使用类名.的方式访问。

18.3局部（方法）内部类的格式

访问修饰符 class 外部类的类名{

访问修饰符返回值类型成员方法名（形参列表）{

class 内部类的类名{

内部类的类体；

}

public class AreaOuter{
    private int cnt=1;
    
    public void show(){
        class AreaInner(){
            private int ia=1;
            public AreaInner(){
                Sout("局部内部类的构造方法！");
            }
            public void test(){
                  Sout(ia);
                  Sout(cnt);
                  }
        }
        
        
        AreaInner ai=new AreaInner(){
        ai.test();
          
        }
    }
}

局部内部类只能在该方法的内部使用

局部内部类可以在方法体内部直接创建对象

局部内部类不能使用访问控制符和static关键字修饰符

局部内部类可以使用外部方法的局部变量,但必须是 final的,由局部内部类和局部变量的声明周期不同所致.

18.4匿名内部类(重点)

接口/父类类型应用变量名 = new 接口/父类类型(){方法的重写};

AnonymousTnterface ait =new AnonymousInterface(){

@override

public void show(){

Sout(“匿名内部类就是这么玩的，虽然很抽象”) ；

}

Java8开始提出新特性Lamda表达式：可以简化上述代码

格式为（参数列表）->{方法体}

AnonymousInterface ait=()-> System.out.println(“匿名内部类就是这么简单。。。。。。。”)

19回调模式的概念

回调模式是指—如果一个方法的参数是接口类型,则在调用该方法时,需要创建并传递一个实现此接口类型的对象;而该方法在运行时会调用到参数对象所实现的方法(接口中定义的)

20枚举的基本概念

在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类型。

使用public static final 表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型

枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final 关键字共同修饰，因此采用枚举类型.的方式调用。

枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的。

public class Direction{
    private final String desc：//用于描述方向字符串的成员变量
    //通过构造方法实现成员变量的初始化
    public Direction(String desc){
       this.desc=desc;
    }
    public String getDesc(){
         return desc;  
}

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pqgnCB90-1666068945035)(C:\Users\17453\AppData\Roaming\Typora\typora-user-images\image-20220713210322644.png)]

public enum DirectionEnum{
    UP("向上")，Down("向下")，LEFT("向左")，RIGHT("向右");//放在首行
    private final sString desc;
    

    
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rFjzVqAl-1666068945035)(C:\Users\17453\AppData\Roaming\Typora\typora-user-images\image-20220713213323524.png)]

21Enum类的概念和方法

所有的枚举类都继承自java.lang.Enum类，常用方法如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M4r5iSvq-1666068945036)(C:\Users\17453\AppData\Roaming\Typora\typora-user-images\image-20220713215701791.png)]

DirectionEnum[] arr = DirectionEnum.values();

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

Sout(arr[i].toString);

Sout(arr[i].ordinal());

}

22注解的概念

Annotation又叫标注，是从Java5开始增加的一种引用数据类型。

注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理。

22.1注解的语法格式：

访问修饰符 @interface 注解名称{

注解成员；

}

22.2自定义注解自动继承java.lang.annotation.Annotation接口。

public @interface MyAnnotation{//若一个注解中没有任何的注解叫做标记注解/标识注解
    public String value();//声明一个Strig类型的成员变量，名字为value
    public String value2();//給默認值的方式public String value2()default "123";
}

@MyAnnotation(value="hello",value2="world")
public class people{

}

注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方式”来声明，其方法定义了该成员变量的名字，其返回值定义了改成员变量的类型。

如果注解中只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum而类型及Annotation类型。

23元注解的概念

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其他的注解上面。

元注解主要有@Retention（保持）、@Documented、@Target（修饰哪些内容）、@Inherited（注解是否可以被继承）、@Repeatable（是否可以重复）

@Retention

应用到一个注解上用于说明该注解的生命周期，

@Documented

@Target

@Target（ElementType.TYPE，ElenemtType.CONSTRUCTOR）

@MyAnnotation

//表示下边的注解可以用于类型的修饰。

@Inherited

@Repeatable

24常见的预制注解

25 API的使用和常用包的概述

详细见JDK 11API

类Object类是类层次的根类，任何一个类都是该类的根类或者间接根类

equals方法，boolean类型，默认比较俩个参数的地址

public boolean equals(Object o){
    return this==o;
}

//爲了比較倆個對象的内容，需要重寫該方法
@Override
public boolean equals(Object ob){
    if(obj instanceof Student){
    Student ts=(Student)obj; 
     return (this.getId()==ts.getId()); 
    }
    return false;
   
}

hashcode()方法：返回对象的哈希码值重写equals方法时，也需要重写hashcode方法

下面调用Object类中继承下来的hashcode方法，获取调用对象的哈希码值
  int ia=s1.hashcode();
  int ib=s2.hashcode();
  Sout("ia"  +ia+"ib"+ib)//发现结果不同
  
  
  ---------------------------------------------------
  @Override 
  public int hashCode(){
      return getId();//不在代表内存地址的编号了   耍流氓的方式
      
  }
   
   //下面调用Object 类中继承下来的toString 方法，获取调用对象的字符串形式，包名，类名@哈希码值的十六进制
   String str1 =s1.toString();
   Sout(str1);
   Sout(s1);//当打印一个引用变量时，会自动调用toString方法。

str1= com.lagou.task11.Student@55d

//为了返回更有意义的字符串数据，则需要重写该方法
@Override 
public int toString(){
    Sout("--");
}

26.包装类（熟悉）

通常情况下基本数据类型的变量不是对象，为了满足万物皆是对象的理念需要对数据类型的变咯昂进行打包封装处理变成对象，而负责将这些变量申明为变量成员进行对象化处理的相关类，叫做包装类。

Integer类的描述

java.lang.integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类型的转换方法的等。

装箱：从int类型----》integer类型

拆箱：从integer类型----》int类型

//从Java5开始增加了自动装箱和自动拆箱的机制

Integer it5 =Integer .valueof(100);//以前

Integer it5=100；

int ib=it5；

//直接赋值实现

//装箱和拆箱的笔试考点

Integer it6=128；

Integer it7=128；

Integer it8=new Integer（128）；

Integer it9=new Integer（128）；

Integer it6=127；           //true

Integer it7=127；                  //true

Integer it8=new Integer（127）；     //false

Integer it9=new Integer（127）；     //true

裝箱範圍：-128-------127

Integer类的常用方法

//实现静态方法的调用
int ic= Integer.parseInt(200);//zc
int ic= Integer.parseInt(200a);//编译ok，运行发生错误NuberFormatException数字格式异常

Double类的概念和使用

对double类型的包装

Boolean类的概述

Character类的概述

27数学处理类（熟悉）

java.lang.Math提供

27.1 BigDecimal类

27.2BigInteger类

28 String类的概念和使用

java.lang.String 类用于描述字符串，java程序中所有的字符串字面值都可以使用该类的对象加以描述

final修饰内容放在常量池当中

public class stringPoolTest{
//到目前为止，只有String这个特殊类除了new的方式外还可以直接字符串赋值（包装类除外）
    public static void main(String[] args){
                String str1="abc";
                String str2="abc";
                Sout（str1=str2）;//比较地址    true
    }
    
}

常用的构造方法

public static void main(String[] args){
    String str1= new String();//表示字符串对象，有对象只是里面没有内容
    Sout("str1");   //输出结果什么都没有，不是null
}

笔试考点：

//请问下面的代码会创建几个对象？分别存放在什么地方

String str1 =“hello”//一个对象存放在常量池

String str2 =new String(hello);//俩个对象一个在常量池一个在堆区（被指向）

29正则表达式的概念和规则

正则表达式只能对格式进行验证，无法对数据的正确性进行确定。内容的检查需要后台查询数据库。

30.可变字符串类和日期相关类

可变字符串类：

String类型字符串不可以改变，当需要在Java中描述大量类似的字符串时，只能单独申请和存储，会造成空间的浪费。

StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低。

StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，效率比较高。

StringBuilder类常用的构造方法：

String Builder 类常用的方法：

笔试考点：

考点一：既然String Builder类的对象本身可以修改，那么为什么成员方法还有返回值呢？

sb3.reverse（）.append(“1”).insert(“2”).delete(0,1);

//为了连续调用

考点二：如何实现StringBuilder 类型和String类型的相互转换

String str3=sb3.toString（）；

StringBuilder sb5=new StringBuilder（str3）；

考点三：String ，StringBuffer，StringBuilder之间的效率谁高？排列如何？

//String <StringBuffer<StringBuilder

System类的概述

public static void main（String[] args）{
    long msec=System.currentTimeMillis();
    System.out.println("当前系统时间距离1970年1月1日0时0分0秒"+mesc+"毫秒了！");
    //通常用于测试某一段代码的执行效率
}

Date类的概述

主要描述特定的瞬间，也就是年月时分秒，可以精确到毫秒

Date d1=new Date();

System.out.println("d1")；//系统当前时间

Date d2=new Date(1000);

System.out.println("d2")；//1970 1 1 0 0 1

SimpleDateFormat类的概述

Calendar

Instant类

描述瞬间的时间点。

31 集合的概述

collection：

方法：

使用For each结构实现集合和数组中的循环遍历：

32泛型

jAVA7开始的新特性：菱形特性。

List<Double> lt3=new LinkedList<>();

筆試考点：

lt3= lt1; //试图将lt1的值赋值给lt3，也就是赋值给lt3中原来的数值，结果编译错误，集合中支持的类型不同。

lt3= lt1;        //Error

public class SubPerson extends Person{      //擦除
    不指定为Object类型
}

set集合：

TreeSet：底层为红黑树

compareTo方法

自然比较方法：

Map集合：

将map类型键值对或键或值转换为set：

Collections类：

主要提供了对集合操作或者返回集合的静态方法：

33异常机制和File类

异常是不正常的含义，在java语言中主要指程序的发生的不正常情况。

java.lang.Thorwable类是java语言当中错误和异常的超类。

Error类主要用于描述java虚拟机无法解决的严重错误，通常无法通过编码解决，如jvm挂掉了

其中Exception类主要描述因编程错误或者偶然的外在因素导致的轻微错误，如：0作为除数。

自定义异常：

File

主要用于描述文件或者目录的抽象表示信息，可以获取文件或者目录的特征信息，如：大小等，

常用的方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IbggayQL-1666068945128)(C:\Users\17453\AppData\Roaming\Typora\typora-user-images\image-20220726125612968.png)]]()

public class FileTest { 
  public  static void main(String[]  args){
File f1=new File("d:/a.txt");
if (f1.exits()){
    System.out.println("文件的名称是"+f1.getName());
        System.out.println("文件的大小是"+f1.length());
        Date d1=new date(f1.lastModified());
        SimpleDateFormat sdf=new SimpleDateFormate("yyyy-MM-dd HH:mm:ss");
            System.out.println("文件的最后一次修改时间是"+sdf.format(d1));
    System.out.println("文件的绝对路径信息是"+f1.getAbsolutePath());
    
}     else{  
    System.out.println(f1.creatNewFile()?"文件创建成功"："文件创建失败！");
              }
      System.out.println("--------------------------------------------");
      
      //实现对目录的删除和创建
      File f2=new file("d://daoluan");
            File f2=new file("d:/daodan/nicaiwo/nicaiwocaibucai/sigui");
      if(f2.exists()){
          System.out.println(f2.getName());
              System.out.println(f2.delete()?"目录创建成功":"目录创建失败");
          
      }else{
          System.out.println(f2.mkdirs()?"成功":"失败");//创建多层目录
      }
      
      
      File f3=new file("d:/daoluan");
      File[] filesArray=f3.listFiles();
      for(File tf:filesArray){
           String name=tf.getName();
          if(tf.isFile()){
              System.out.println(name);
          }
          if(tf.isDirection()){
              System.out.println("["+name+"]");
          }
      }
}
  }

35IO流：

FileWrite类：

//若文件存在，该流会清空文件中的原有内容

//若文件不存在，该流会自动创建新的文件。

//以追加的方式创建对象去关联文件，不存在则创建新的空文件，若文件存在，则保留原有数据。

FileReader fr=new FileReader("d:/a.txt");
fileWriter fw=new FileWriter("d/b.txt");
int res=0;
while ((res=fr.read()!=-1){
 
Sout.("文件拷贝成功");
}
fw.close();
fr.close();
 


### 打印流和转换流：

## 字符编码：

public static void main(String[] args){

DataOutputStream dos=new DataOutputStream(new FileOutputStream("d:/a.txt"));
int num=66;
dos.write(num);
System.out.println("写入数据成功");
dos.close();

}



# 36多线程

36.1程序和进程的概念（操作系统相关）

## 线程的创建：

## 线程创建的第一种方法：

## 线程创建的第二种方法：


匿名内部类的方式实现：


## 线程的生命周期：


### 继承方式实现管理线程：




### 守护线程：

public class SubThread1 extends Thread{
@Override
public void run(){
for(int i=1;i<100;i+=2){
Sout(i);
}
}
}
public class SubThread2 extends Thread{
@Override
public void run(){
for(int i=2;i<=100;i+=2){
Sout(i);
}
}
}

PUBLC CLASS subthreadTest{
SubThread1 st1=new SubThread();
SubThread2 st2=new SubThread();
st1.start();
st2.start();
Sout(“主线程开始等待”);
try{
st1.join();
st2.join();

}catch(InterruptedException e){
    e.printStackTrace();
}
Sout("主线程等待结束！");

}

pubic class SubRunnable Implements Runnable
``