Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))

Java基础复习资料

  • jdk安装
  • 运行记事本程序
  • 变量/常量
  • 程序结构
  • 八大基本数据类型
  • 对象
    • 属性
    • 方法
      • 1.构造方法
      • 2.重载方法
      • 3.重写方法
      • 其他函数方法
        • this
        • super
    • 继承 extends
    • 接口 implements / interface
    • 多态(考)
    • 包装类
    • 抽象类 abstract
  • 数据封装
    • set / get 方法
  • 异常
  • 多线程
  • 常用工具类
  • 集合框架
    • Iterator 迭代器(遍历) 父接口
    • 泛型 e / E
    • 栈与队列
  • 文件操作
  • 文件操作输入输出流 (考)
  • 待续、更新中

jdk安装

内容过多,请看往期链接: jdk/idea/环境变量配置

运行记事本程序

内容过多,请看往期链接: java编译运行记事本文件

变量/常量

变量:

成员变量( 类里 ): 
又叫 全局变量
成员变量是在类中声明的变量,它们属于对象的一部分成员变量的
作用域:  整个类,在类中的任何方法、构造函数或代码块中都可以访问

局部变量 ( 方法里):
局部变量是在方法、构造函数或代码块内部声明的变量
作用域:  只在声明它的作用域内可见

常量:

常量用final 修饰, 且常量名大写
final String STU_NAME=“zs”;

程序结构

顺序

所有程序都按从前往后的顺序执行

条件

if -else
if else if else if …else 多重
嵌套if

switch

循环

for 循环

代码:

public class Hello
{
    public static void main(String[] args)
    {
        Scanner input=new Scanner(System.in);

        System.out.println("输入字符: ");
        String a=input.nextLine();

        System.out.println("输出: "+a);

			//  数据类型[] 数组名 = new 数据类型[大小] ;
        int [] shu=new int[3];

        // 数组输入
        for( int i=0;  i<shu.length;  i++ )
        {
            System.out.println(" 输入提示信息: ");
            shu[i] = input.nextInt(); //字符 ; 整型 input.nextInt()

        }
        // 数组输出
        for( int i=0;  i<shu.length;  i++ )
        {
           System.out.println("输出: "+ shu[i]);  //字符 ; 整型 input.nextInt()

        }


    }


}

八大基本数据类型

基本数据类型:

整数类型: 字节型byte  / 短整型short /整型int /长整型long
浮点类型: 单精度float /双精度double
字符类型:char
布尔类型: true / false

引用数据类型:

数组
类
接口
字符串

代码:

/**
  声明8个基本数据类型变量,并输出
  */
public class printvalues5 {

    public static void main(String[] args) {
        int intValue = 10;
        long longValue = 1000000L;
        float floatValue = 9.8f;
        double doubleValue = 9.9;
        char charValue = 'l';
        boolean booleanValue = true;
        byte byteValue = 127;
        short shortValue = 6553;

        System.out.println("int值: " + intValue);
        System.out.println("long值: " + longValue);
        System.out.println("float值: " + floatValue);
        System.out.println("double值: " + doubleValue);
        System.out.println("char值: " + charValue);
        System.out.println("boolean值: " + booleanValue);
        System.out.println("byte值: " + byteValue);
        System.out.println("short值: " + shortValue);

    }
}

对象

又称: (实体、实例)
万物皆是对象,描述客观事物的一个实体,由一组属性和方法构成

语法:
类名 对象名= new 类名();

属性

描述对象特点的词(年龄、身高等);变量的声明

例如: 
我这个个体的 身高, 体重, 爱好等

方法

又名: 操作、动作、函数
例如: 购买商品这个动作

语法:
访问修饰符   返回值类型   方法名 ( 参数列表)
{ 方法体 }

 访问修饰符(访问权限):
 public、Protected、Default(  默认的, 什么都不写  )、Private  (权限由公开--------到——私有)

返回值类型:
void  ;  无需return ; 
八中数据类型 ; 其他类型 都需return ; return 值;

return:   
void 无需return ; / 其他类型 都需return ; return 值;
return  只能返回一个值 ; 返回多个值,打包成一个数组或对象 ,进行返回

方法名: 	
格式:  字母 数字  $   _
为动名词词组, 方法名首字母小写 

参数:
带参, 写活
不带参, 写死

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第1张图片

代码:

public void buyshop()
    {
        System.out.println(shopname);
    }

成员方法

成员,都在一个类内:叫成员变量 或 成员方法

1.构造方法

又名
构造方法== 构造函数==构造器	
初始化对象: 类名 对象名=new 类名()

作用:

创建对象的同时对属性赋值(初始化对象), 通过调用当前类的构造方法来实现创造对象操作

语法:

访问修饰符  类名()  {     }

特点:

方法名与类名相同、无返回值类型、同一个类中可有多个构造方法

系统自带构造方法:

public Student()  //系统自带, jvm虚拟机默认提供一个无参数构造方法
 {    }
但,一旦写一个带参构造方法,虚拟机就不在提供系统的构造方法.

一般写法:写个带参构造,同时再写一个无参构造

三个方法区别:

相同:1方法名  2同一个类里面
不同:1参数不同:参数个数不同、参数类型不同、参数顺序不同

代码:
1 带参构造方法
学生老师类:

 // 此时类名为 Student
 //学生类 a,b
public class Student

{
    String name;
    int age;

    public Student(String name, int age) // 带参数的 构造方法
    {
        this.name = name;
        this.age = age;
    }

    //    自己写的如下
    public Student() //  不带参数构造
    {
        name = "nihao";
        age =  12;
    }
    // 系统自带的
     public Student()  
    {
        
    }
}


// 运行
public class Runtest
{
    public static void main(String[] args)
    {
        Student a = new Student("nihao2", 12);
        a.printInfo();
        //一般写法,初始化对象:
//        a.name = "nihao"; 
//        a.age = 12;
//        a.printInfo();

    }
}


2 无参构造/有参构造

public class StrudentCanshu
{
    String name, type, hoppy;
    int age;

    public void printInfo()
    {
        System.out.println(name);
        System.out.println(type);
        System.out.println(hoppy);
        System.out.println(age);
    }


    // 构造方法  -无参
    public StrudentCanshu()
    {
        name = "无参";
        type = "1版1";
        hoppy = "划水";
        age = 101;
    }

    // 构造方法-有参
    public StrudentCanshu(String name, String type, String hoppy, int age)
    {
        this.name = name;  // this表示当前对象; 将该方法的参数name的值赋给当前对象的name属性
        this.type = type;
        this.hoppy = hoppy;
        this.age = age;
    }


}
// 运行
public class RunStudent
{
    public static void main(String[] args)
    {
        StrudentCanshu wo0=new StrudentCanshu(); // 无参构造
        wo0.printInfo(); //普通输出
        System.out.println(); //空行

       StrudentCanshu wo=new StrudentCanshu("你好有参","1班2","摸鱼",211); //有参构造
        wo.printInfo();
    }

}


结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第2张图片

2.重载方法

条件:

同一个类中
有多个方法且方法名相同 ( 可以有返回值类型 )
参数不同;

作用:

根据不同的参数类型和个数来调用不同的方法

区别构造方法:

构造方法自动满足重载,构造方法一定是重载方法,重载方法不一定是构造方法

代码举例:

 //1 构造方法:  
 // 还是上面的例子, 此时类名为 Student,  两者 互为重载方法

public class Student

{
    public Student(String name, int age) // 带参数的 构造方法
    {
        this.name = name;
        this.age = age;
    }

    //   自己写的如下
    public Student() //  不带参数构造
    {
        name = "nihao";
        age =  12;
    }

 // 2 自己写的方法: 
    // 重载方法:
    public void printInfo() // 方法名为printinfo, 不为类名 Student,不满足构造方法
    {
        System.out.println(name);
        System.out.println(age);
    }

    //  重载方法:上下两个互为
    public void printInfo(int num)
    {

    }
}

// 运行

public class Runtest
{
    public static void main(String[] args)
    {
        Student a = new Student("nihao2", 12);
        a.printInfo();


		 Student b=new Student();
        b.printInfo();
    }
}

结果
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第3张图片

3.重写方法

条件:

1.子类继承父类
2.访问修饰符相同 (特例为两者访问权限相同,如都为public)
一般,子类方法的访问权限不能比父类更加严格,即子类方法的访问权限更宽松
3.返回值类型相同
4.方法名相同
5.参数列表相同
6.异常 , 子类方法不能比父类抛出更多的异常

例如:

父类、子类中有相同的方法,这时就为重写. 
重写时,优先调用子类方法

区别于重载:

重载: 方法名相同,但参数不同,实现多个方法的调用(同个类中重载)
重写: 整个方法都相同,特例除过访问修饰符可能不同且有继承(两个类 中重写)

代码举例:

///  父类
public class human //不放父类创建对象,抽象类
{
    private String name;
    private String gender;
    private int age;

    // 父类中重写方法:
    public void print()
    {
        System.out.println(name);
        System.out.println(gender);
        System.out.println(age);
    }


    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public String getGender()
    {
        return gender;
    }

    public void setGender(String gender)
    {
        this.gender = gender;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }
}


// 子类 学生类
public class student extends human
{
   private String xuehao;

    //  子类中 重写方法
    public void print()
    {
// 没有调用父类, 运行优先调用子类, 仅仅输出 xuehao 
// 不输出父类中print的姓名,性别,年龄等 
// 解决方法: 使用 super 调用父类方法
			 super.print(); // super 调用了 父类的print()方法 
        System.out.println(xuehao);

    }

    public String getXuehao()
    {
        return xuehao;
    }

    public void setXuehao(String xuehao)
    {
        this.xuehao = xuehao;
    }


}


// 子类老师
public class teacher extends human
{
   private  String gonghao;

    public String getGonghao()
    {
        return gonghao;
    }

    public void setGonghao(String gonghao)
    {
        this.gonghao = gonghao;
    }

    public void print()
    {
        super.print(); // super 调用了 父类的print()方法 
        System.out.println(gonghao);
    }

}

// 运行

public class TestRun
{
    public static void main(String[] args)
    {
        student  le =new student();
        le.setXuehao("20322341234");
        // 通过set 方法 设置属性 ,使其可以访问private 封装的数据类型
        le.setAge(23);
        le.setGender("男");
        le.setName("xy");
        le.print();
        // 重写,优先调用子类方法, 但在子类中调用了父类的super方法才可访问到公用属性

        System.out.println();
        System.out.println("重写,优先调用子类方法, 但在子类中调用了父类的super方法才可访问到公用属性          ");
        System.out.println();

        teacher yang=new teacher();
        yang.setGonghao("23429878");
        yang.setAge(22);
        yang.setGender("男");
        yang.setName("杨");
        yang.print();
    }
}


结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第4张图片

其他函数方法

this
访问当前类的属性、方法
表示当前对象

this()
用于当前类的构造方法,且用在第一句
super

super .

调用父类的方法
前提:权限够.  用私有private 访问修饰符修饰的方法调用不了

super()

调用父类的构造方法
使用时,出现在子类构造方法的第一句话.

分为:
父类的无参构造
父类的有参构造

代码:

// 子类继承父类
public class student extends human
{
    String xuehao;
    public void print()  //  子类中 重写方法
    {
        super.print();  // super.调用父类human中方法print()
        System.out.println(xuehao);
    }
}

// 父类
public class human //不放父类创建对象,抽象类
{
    private String name;
    private String gender;
    private int age;

    // 父类中重写方法:
    public void print() // 子类中super即调用父类的print()
    {
        System.out.println(name);
        System.out.println(gender);
        System.out.println(age);
    }
}

indexOf() :查找字符串位置 ; 找不到-1 ; 找到返回

lastIndexOf(): -1 ; 从右往左找

subString(): 截取字符串
“abcd”.subString( 0 或 1 ) : 1, 从1开始到字符串结束 , 结果bcd
“abcd”.subString(1,3 ) : 从1开始,3结束不包括3 ; 结果bc

split() : 字符串截取
“abcdabc”.split(“d”) : 返回字符串类型的数组 : [abc,abc]
“abcdabc”.split(“c”) : 结果[ab,dab]

toLowerCase(): 转小写
toUpperCase() : 转大写
代码:

String str = "hello, world!";
String lowerStr = str.toLowerCase(); //将字母全部转为小写
String upperStr = str.toUpperCase(); //将字母全部转为大写
System.out.println(lowerStr);
System.out.println(upperStr);

length() : 获取字符串长度
“abc”.length() : 结果3

要求: 首字母大写

描述: 对多个对象的抽象(分类)

例如: 对52个对象学生,进行分类,学生类或人类;

类的设计原则

高内聚:类内部的数据由自身来进行维护,不要由外部进行干涉,隐藏该隐藏的内容(内部隐藏,外部透明)
低耦合:提供公共的拥护访问接口,由用户进行调用

类与对象的区别:

类,范围性概念,范围广;  对象,具体化的.
类是对象的抽象,对象是类的具体 .
例: 人类  	与    我

类与接口:

类 之间可以相互继承
接口 之间可以相互继承
类 实现 接口	

继承 extends

原因:

类中属性,有冗余问题

用类的方法写程序, 而类之间也有关系,大小范围;

例如:
动物类中也分为:水生的、哺乳的、飞行的、陆地的...

解决冗余问题:

父类:
抽出公共的部分,单独形成一个类;(各个类的属性方法出现大量的重复、冗余)

子类:
继承父类的属性方法;但子类中保留了下个性化属性方法

网页中叫引用,程序中叫继承

其他说明:

+ public
-  private

子类——小范围的类  大学生类
父类——大范围的类  人类
两个类不一定继承

继承条件:

关键词:  is 
子类是一个父类, 小范围的类继承大范围的类

例如:
学生是人类
汽车式交通工具类

代码:

// 子类1 狗类
public class Dog extends Pet
{
    private String starin;  //品种

    // 方法输出
    public void printstarin()
    {
        System.out.println("品种:" + starin);
    }
 //  set /get 设置/获取私有属性值
    public String getStarin()
    {
        return starin;
    }

    public void setStarin(String starin)
    {
        this.starin = starin;
    }
    

}

// 子类2 企鹅类
public class Penguin extends Pet
{
    private String sex;

    public void printPenguinsex()
    {
        System.out.println("企鹅性别:"+sex);
    }

    public String getSex()
    {
        return sex;
    }

    public void setSex(String sex)
    {
        this.sex = sex;
    }
}

// 父类  宠物类
// 共性的特征和操作
public class Pet
{
    private String name;
    private int health; // 健康值
    private int love; // 亲密度

    public void printfulei()
    {
        System.out.println("姓名:" + name);
        System.out.println("健康值:" + health);
        System.out.println("宠爱度:" + love);
    }

    //    访问 私有的属性
    public void setName(String name)
    {
        this.name = name;
    }

    public void setHealth(int health)
    {
        this.health = health;
    }

    public void setLove(int love)
    {
        this.love = love;
    }

    public String getName()
    {
        return name;
    }

    public int getLove()
    {
        return love;
    }

    public int getHealth()
    {
        return health;
    }

}


// 运行类
public class PetRun
{
    public static void main(String[] args)
    {
// 狗类
        Dog xiaohuang = new Dog();

        // 原先,没有封装,则为:xiaohuang.strain=“土狗”;

        xiaohuang.setStarin("土狗");   
        xiaohuang.setName("小黄"); //  父类公共属性
        xiaohuang.setHealth(10); //  父类公共属性
        xiaohuang.setLove(9);  // 父类公共属性
//        输出
        xiaohuang.printstarin();
        xiaohuang.printfulei();

        System.out.println();
//企鹅类
        Penguin qie = new Penguin();
        qie.setSex("公"); 
//        输出
        qie.printPenguinsex();

    }
}

结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第5张图片

接口 implements / interface

问题:

继承都为 单继承: 
每个类只能继承一个唯一的父类,  如extends  后面只能出现 一个父类

单继承缺点:
任何一个类,只能单继承, 只能有一个父类; 不能扩展自身的能力

解决:

解决1: 
希望功能越来越强大,往父类中写入越来越多的功能,修改现有的程序来扩展
缺点:导致父类功能越来越复制,容易搞坏本来程序

解决2:
提供接口,附加功能

说明:

继承只能有一个
接口可以有多个

关键字:

interface 接口
相当于类class  ,把class 换为 interface 即为接口形式

方法都默认用  public abstract  修饰的 , 没有方法体
变量都默认用  public static final 修饰的 
不存在构造方法 等


implements 实现   
相当于继承extends , 把extends 换为 implements

注意:
extends 后只能跟一个父类
implements 后面可以跟多个接口, 使用"," 隔开


@Override  重写
接口当中的所有方法 , 默认都是且只允许为:   公共的抽象方法  public abstract 
因而在父类中要重写 @Override 该方法
例:
接口子类---  void joinDevice(); 
父类----
@Override  //重写接口方法
public void joinDevice()
{
    System.out.println("接入了一个鼠标");
}

语法:

public class  computer    implements  erji,  jianpan   (多个接口)
public interface Typec (这时的类就不用class 了,而用interface  )

定义:

一种能力或规范: 
能力:
我会打太极,喝水, 听歌  ;  具有听歌/喝水的能力,这是一种能力
汽车方向盘具有调整方向的能力

规范: 
耳机的插线头与手机的接收口必须一致,才可以听歌,是一种规范
喝水杯子的杯身与杯盖 必须匹配,是一种规范

例如:
符合接口定义:
浏览器扩展:   扩展功能, 实在不行就卸载,浏览器本身功能并不变
Windows系统,更新打补丁
人:附加翅膀,可以飞

反面教材:
电视机有声音小的bug, 自己拆开来修理声音时, 最终没修好,且还开不了机了 
解决方案:
使其原有功能不变, 通过附加新的功能或设备来解决bug. 最差的结果是声音即便没修好,但可以看电视,就是声音小些罢了.

功能:

多继承,最大程度的去扩展程序的功能
开闭原则(修改关闭,附加扩展开启), 用附加功能来扩展功能

好处:

能力强大了,具有更多的能力;  继承更多的父类来强大自身或扩展了自身的功能

代码举例:

/**
父类
*/

public class Computer implements Use,Typec,MusicLine
{
// 实现接口

    private String brand;
    private String type;

    public Computer(String brand, String type) //带参构造方法
    {
        this.brand = brand;
        this.type = type;
    }

    //一般打印方法
    public void print()
    {
        System.out.println(brand);
        System.out.println(type);
    }

    // 访问数据get/set方法
    public String getBrand()
    {
        return brand;
    }

    public void setBrand(String brand)
    {
        this.brand = brand;
    }

    public String getType()
    {
        return type;
    }

    public void setType(String type)
    {
        this.type = type;
    }

    @Override  //重写接口方法
    public void joinDevice()
    {
        System.out.println("接入了一个鼠标");

    }

    @Override
    public void typeDevice()
    {
        System.out.println("接入了一个typec接口的键盘"); //重写方法,接口默认为abstract 抽象方法
    }

    @Override
    public void musciLine()
    {
        System.out.println("接入了一个耳机");
    }
}



/**
接口 use
*/ 
public interface Use
{
    void joinDevice(); // 抽象方法 ,接口当中的所有方法默认都是,且只允许为公共的抽象方法 public abstract

}

/**
接口  Typec
*/ 
package jiekouinterface;

public interface Typec
{
    void typeDevice();
    // 附加typec 设备
}

/**
接口  MusicLine
*/ 
package jiekouinterface;

public interface MusicLine
{
    void musciLine();

}


/**
运行 类
*/
package jiekouinterface;

/**
 * 电脑 -类
 * 	usb接口 -接口
 * 	接入usb接口的鼠标
 * 	type-c的键盘
 *
 */
public class RunJiekou
{
    public static void main(String[] args)
    {
        Computer computer=new Computer( "华为","mate 10pro");
        computer.print();
        computer.joinDevice();
        computer.typeDevice();
        computer.musciLine();
    }

}



结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第6张图片

多态(考)

特点:

面向对象的特征之一: 多态/封装/继承
面向对象的语言:   c#(sharp 尖锐的)/ java/c++ 等都拥有面向对象的特征

定义:

变态,变化形态; 
1. 做同一件事情,由于环境/条件/过程等等因素各有不同,则会得到不同的结果
2. 程序中,同一个引用类型(父类),使用不同的实例(子类,对象),则产生不同的结果

条件:

1.继承重写
2.父类引用指向子类实例
如: 父类类名 对象名=new 子类类名();
一般为:  类名 对象名=new 类名()

注意:
new 后不能出现 接口/ 抽象类; 不能被实例化

作用:

主要为了实现 多态性

例如:

变色龙:	颜色变了,但本身物种不变
考试: 	同学考试--答题,交卷  ; 	老师--监考,收卷,阅卷
52个同学考试:  都在答题,交卷 ; 	考试成绩不同,52种结果
拍照:  xy拍照, 打印照片;    两种结果: 黑白/彩色
练字:	写的快,字练的丑;写的慢,字练的漂亮

代码:


// 父类people

public abstract  class People
{

    public  abstract void takeExam();


    private  String name;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public String getGender()
    {
        return gender;
    }

    public void setGender(String gender)
    {
        this.gender = gender;
    }

    private  int age;
    private   String gender;


    protected  void  printinfo()
    {
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
    }



}

// 子类学生类
public class Student extends People
{


    @Override
    public void takeExam()
    {
        System.out.println("答题");
        System.out.println("交卷");
        System.out.println();
    }

}


// 子类老师类
public class Teacher extends People
{
    @Override
    public void takeExam()
    {
        System.out.println("监考");
        System.out.println("收卷");
        System.out.println();
    }
}


// 运行
public class Runpolymorphic
{
    public static void main(String[] args)
    {
        People xy= new Student();
        xy.takeExam();

        People  nihao =new Teacher();
        nihao.takeExam();
    }
}


结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第7张图片

包装类

包装类: 将数据类型设计为类, 面向对象的操作

包装类	            对应基本数据类型
Character          char
Integer	    	   int
Byte	   	            byte
Float			        float
Short	            short
Long			        long
Double		        double
Boolbean		    boolbean

装箱: 基本类型转换为 包装类
拆箱: 包装类 转换为 基本类型

代码:

package lei.putonglei.baozhuanglei;

public class PackageBaozhuang
{
    public static void main(String[] args)
    {
        int x = 30;
        Integer i = new Integer(x); //装箱
        int tem = i.intValue();  // 拆箱

        // 自动拆箱装箱
        int xx = 30;
        Integer ii = x;  //自动装箱
        Double aDouble = 3.14;
        double d = aDouble;  // 自动拆箱

        String s1 = "1234";
        String s2 = "12.34";
        int a = Integer.parseInt(s1);  // 将字符串 s1 转换为整型数值并赋值给变量 a
        float b = new Float(s2);  // 使用构造函数将字符串 s2 转换为浮点数并赋值给变量 b
        System.out.println("整数的乘法: " + a + "*" + a + "=" + a * a);
        System.out.println("小数的乘法: " + b + "*" + b + "=" + b * b);

        String fstr = String.valueOf(1.23f);  // 将浮点数值转换为字符串并赋值给变量 fstr
        String dabstr = String.valueOf(2.34);  // 将双精度浮点数值转换为字符串并赋值给变量 dabstr
        String blstr = String.valueOf(true);  // 将布尔值转换为字符串并赋值给变量 blstr
        System.out.println(blstr.toUpperCase()); // 将字符串 blstr 转换为大写并打印出来


    }
}

抽象类 abstract

原因: 父类创建对象,就会丢了好多子类的属性

解决: 让父类不能访问子类;约束不让父类类创建对象

特点:

抽象类不能用new 实例化 ,new 后面不能为 抽象类

对两层或多层关系的父子类或 曾祖、父子类等, 至少让最底层不为abstract 类, 可以创建对象
父类 对 子类抽象,子类 对 对象抽象	

抽象方法 abstract

原则:

父类抽象, 子类重写
abstract 	一般对父类进行抽象

特征:

抽象方法没有方法体
抽象方法所在的类一定为抽象类
如果父类出现了抽象abstract方法,那么子类继承后必须重写这个方法
对于一般的方法,可以重写,可以不重写

代码举例:

///  父类
public abstract class PeopleAbstract   // abstract 抽象类/父类
{
    private String name;
    private String gender;
    private int age;

    public abstract void printinfo(); //抽象方法 abstract 没有方法体,  对其运行结果无影响

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public String getGender()
    {
        return gender;
    }

    public void setGender(String gender)
    {
        this.gender = gender;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }


}

 
// 子类: 
public class StudentAbstract extends  PeopleAbstract
{
   private    String  sno;
    public  void  printinfo()  // 重写抽象方法printinfo()
    {
    // 调用父类的方法,但是父类方法为private  ,访问不了
        System.out.println(sno);
        System.out.println(getAge());
        System.out.println(super.getGender());
        System.out.println(super.getName());

    }
    public String getSno()
    {
        return sno;
    }

    public void setSno(String sno)
    {
        this.sno = sno;
    }


}

// 子类: 老师类
public class TeacherAbstarct  extends  PeopleAbstract
{
  
    public void printinfo()  // 重写抽象方法printinfo()
    {
        System.out.println(tgonghao);
        System.out.println(super.getAge());
        System.out.println(super.getGender());
        System.out.println(super.getName());
    }
    public String getTgonghao()
    {
        return tgonghao;
    }

    public void setTgonghao(String tgonghao)
    {
        this.tgonghao = tgonghao;
    }

    private  String  tgonghao;
}
  

数据封装

数据的封装
接口访问,实则set/get方法的调用
他们是公有的,可访问

作用: 访问私有的数据

注意
修饰类时,只能使用默认的或public进行修饰,无法使用其他的修饰符

set / get 方法

右键----generate ----getter and  setter ---全选---确认

set   设置属性
返回值类型void , 带参;  方法体中 参数属性指向当前对象的属性值
public void setName(String name)
{
    this.name = name;
}

get  获取属性值
返回值类型根据返回的数据类型返回, 方法体中return 
public String getName()
{
    return name;
}

异常

定义:

程序运行的不正常现象(按照语法规则写后)

解决的方法:

try{ } 
catch(  ) {   }
 finally{};

三种搭配方式: 
try{ } catch() {} finally{};
try{ } cantch() {} ;
try { } finally{};

try:

try  方法体中跟 可能出现问题的代码 {  }

catch:

Exception:  所有错误类型的父类 

普通捕获一次:
catch (错误类型  e)   {  提示信息  }    
注意: 捕获的错误类型与出现问题的代码一致 
多路捕获:
多个catch 捕获多种异常
多个catch  子类异常在前, 父类异常在后
catch (ArithmeticException ex)   
{ 
 System.out.println("空指针异常 ");  
 }
catch(Exception ex)  
{
 System.out.println("空指针异常 ");  
}

finally

类似:  葱花,蒜苗,盐巴 (做饭)
作用: 资源释放(类似图书馆借书,最终都要还书) 
不管程序正常执行,还是错误执行,finally都要执行


java有垃圾回收机制 
思路: 
1 申请资源,  程序处理
2 程序处理,错误
3 资源释放

关键字:

1 throw   抛出异常
throw new 异常对象
例如:  throw new ArrayIndexOutOfBoundsException(" 数组下标越界");

2 throws   (s声) 声明异常
语法:访问权限  返回类型 方法名() throws  异常类型列表{    }

异常类型列表: 
表示可以出现多个异常 ,父类子类顺序随意 ; 交给上级程序处理
例如:
public static void main(String[] args)   throws ArrayIndexOutOfBoundsException, NullPointerException
 { }

BankException 自定义异常

继承exception 父类
例如: 存钱存正数 ,存负数抛出异常

assert 断言

处理方法:

异常程序 无需set方法

代码1:

/**
多路捕获
*/


public class Duolu
{
    public static void main(String[] args)
    {


        try
        {

            int[] nums = {11, 12, 133};
            System.out.println(nums[3]);

            int n1 = 1;
            int n2 = 0;
            int n3 = n1 / n2;
            System.out.println(n3);

            String name = null;
            System.out.println(name.length());


            int[] numbers = {1, 2, 3};
            int index = 4;
            int result = numbers[index];
            System.out.println("Result结果: " + result);
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            System.out.println("捕获结果: " + e);
        }

        catch (NullPointerException ex)
        {
            System.out.println("null ");
        }

        catch (Exception ex) // 父类
        {
            System.out.println("null ");
        }

    }




}


结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第8张图片

代码2:

// 自定义异常

public class BankExcption extends Exception   //自定义异常类BankExcption 继承父类Exception
{
    String ses; //声明了一个字符串变量 ses,用于存储异常信息

    public BankExcption(int in, int out)   // 带参构造方法 ,in 收入, out 支出, 初始化ses变量
    {
        ses = "收入: " + in + "是负数或支出" + out + "是正数, 不符合要求";
    }

    public String warnMess() // 普通方法 返回ses的值,用于获取自定义异常的方法的提示信息
    {
        return ses;
    }

    public static class Bank //静态 bank类
    {
        private int money;  //  余额

        public int getMoney() //get方法, 获取余额值
        {
            return money;
        }

        public void income(int in, int out) throws BankExcption
        {
            // throws 声明异常 ,income 方法,用于处理收入支出的逻辑,可能会抛出 BankExcption 异常

            int newIncome = in + out;  //   实际收入= 收入和支出综合
            if (in < 0 || out >= 0 || newIncome < 0)
            {
                //  如果收入小于0,支出大于等于0,或者实际收入小于0;  三条件只要满足一个则抛出 BankExcption 异常

                throw new BankExcption(in, out); // 抛出 BankExcption 异常
            }
            System.out.println(" 本次收入  : " + newIncome);
            money = money + newIncome;  // 更新余额
        }

        public static void main(String[] args)
        {
            Bank b = new Bank(); // 创建 Bank类 对象
            try
            {
                b.income(200, -100); // 执行 income 方法
                b.income(400, -100);
                b.income(600, -100);
                System.out.println(" 银行存款现有:  " + b.getMoney()); // 输出当前余额
                b.income(400, -100);
                b.income(-100, 200);  // -100 小于0, 满足条件
            }
            catch (BankExcption e)
            {// 捕获 BankExcption 异常
                System.out.println(" 出现问题:  " + e.warnMess()); // 输出异常信息
            }

            System.out.println(" 银行最终有存款: " + b.getMoney()); // 输出最终余额
        }
    }

}

结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第9张图片

多线程

定义

两个以上的线程叫多线程

代码:

继承Thread ( 父类 )
或
实现Runable 接口

Thread  // 实现接口
Runnable  // 
public  void run()
{

}
start() ; // 启动线程

需要重写run()方法

三种状态:
就绪 / 运行 / 阻塞
就绪状态多个, 运行状态一个

sleep(1000) ; //线程休眠1s
休眠时间长, 运行次数少;  休眠时间短, 运行次数多; 


设置线程优先级别 :1-10 
setPriority( 1 )  优先级别最低
setPriority( 10 )  优先级别最高

yield() 线程的礼让

 

其他方法:
启动线程: start() 方法
线程优先级:10, 5 ,1 
网络延迟: sleep()方法
中止线程: stop()方法
判断线程是否消亡: isAlive()

礼让线程: yield()方法 
可能得礼让,不是绝对的
A 已经获得了cpu资源,则可以运行
A 出让cpu资源,它自己终止,运行不了,自己到就绪状态

其他问题:

线程不安全:
多个线程并发, 一个cpu回答, 造成混乱现象
解决:谁先拿到黑板擦,cpu就回答

线程池:
创建(2s) 和 销毁线程(3s) 的时间大于运行程序(1s) 的时间
解决: 使用线程池,类似代理
创建线程: 线程池早已经做好线程, 无需创建;
运行程序: 仅仅找到相关的线程( 仅仅消耗该时间), 运行
销毁线程: 线程池自己慢慢的销毁线程

线程同步:
并发: 程序同时运行; 类似多个同学同时问老师问题;    双11秒秒杀
解决:  使用黑板擦,谁拿到黑板擦,就回答谁的问题

临界区

生产者-消费者问题:
生产者: 厨师
消费者: 消费的学生
问题: 
生产者生产了产品,  但没人来吃  或  消费者来了,但饭没做好
解决:
等待 ( 消费者等待 ) -通知( 生产者通知消费者来消费 )
创建一个通知群

死锁
两个资源相互等待的结果
例如: 两人约好了,去玩; 你等我,我等你 ; 以为对方会打电话叫他 ,结果都没打

代码1

/**
实现 Runable 接口
*/
public class Runable implements  Runnable
{

    int pauseTime;
    String name;
    public Runable(int x,String n)  // 构造方法
    {
        pauseTime =x;
        name=n;
    }
    public  void run()  // run方法
    {
        while (true)
        {
            try
            {
                System.out.println(name+":"+new Date(System.currentTimeMillis()));
                Thread.sleep(pauseTime);
            }
            catch (Exception e)
            {
                System.out.println(e);
            }
        }
    }

    public static void main(String[] args)
    {
        Thread t1=new TimePrinter(1000,"fast guy");
        t1.start();
        Thread t2=new TimePrinter(3000,"slow guy");
        t2.start();
    }

}

代码2:

/**
继承Thread 方法

*/

public class TimePrinter extends Thread
{
    int pauseTime;
    String name;
    public TimePrinter(int x,String n)
    {
        pauseTime   =x;
        name=n;
    }
    public  void run()   // Thread类中的run()方法
    {
        while (true)
        {
            try
            {
                System.out.println(name+":"+new Date(System.currentTimeMillis()));
                // 打印出name和当前时间的信息
                // 创建了一个表示当前时间的Date对象
                Thread.sleep(pauseTime);
            }
            catch (Exception e)
            {
                System.out.println(e);
            }
        }
    }

    public static void main(String[] args)
    {
        TimePrinter tp1=new TimePrinter(1000,"fast guy");
        tp1.start(); // 启动了tp1对象
        TimePrinter tp2=new TimePrinter(3000,"slow guy");
        tp2.start();
    }

}

结果:
Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第10张图片

常用工具类

final 修饰的类/方法为 终极类,  不被任何继承/ 重写

包: 
java.lang  包中 String : lang包核心库,该包自动导入
String 对象的创建
String a=new String();
String a="a";
栈和堆 
数据类型
equal方法
"cpu".equal("Gpu"); 
"cpu".equalsIgnoreCase("Gpu"); 


java.io 包: 文件读写
java.util 包: 工具类, 手钳
java.awt  javax.swing 包: 开发小程序 界面 (不成气候 ,不会考这个  )
java.net 包: 网络功能类

System类:
Math类: 


object 为所有类的 父类

进程: 每个进程包含多个线程  

比较值 实则比较地址 --比较 hash表



基本类型包装类
包装类: 
八大基本数据类型, 希望以包装的类型存在 , 对应包 

装箱: 基本类型转换为 包装类
拆箱: 包装类 转换为 基本类型

泛型: 
类似:  算命的话,说的比较笼统


GPU: 显卡,图形处理器


Collection 工具类
Arrays 工具类

集合框架

定义

数组中值都是清一色
集合框架: 任意类型数据都可以存 ( 都是面向接口的 ; 与数据打交道  )

问题:

无序性 , 可重复性 ( 类似书包, 找东西不好找 ;  )
所以使用子接口

特点:

面向接口的编程
接口 对象名= new 接口对应的实现类  ;

数据临时性 ( 程序中数据 == 内存中数据, 重启没有  )

数组确定了大小,不能改变, 清一色的int 或 char等等 ; 连续性
集合框架无视数据类型 / 存储大小

作用:

存放数据

Collection 父接口

定义:
 public interface Collection  extends Iterator{ }

方法:
集合当中有没有包含集合: containsAll();
判断集合是否存放数据: isEmpty()
判断集合中是否存在某个对象: contains ()
转换集合对象为迭代器: iterator()
将集合转换为数组: toArray()
 T[] ToArray( @NotNull T[] a )
add ()  向集合添加一个元素
remove ()  删除指定元素
size ()  返回元素个数
get()  

public class CollectionDemo
{
    public static void main(String[] args)
    {
        Collection c=new ArrayList(); // Collection 父接口, 利用子接口list 的实现类,创建对象
        c.add("java"); //添加数据
        c.add("c#");
        c.add(100);
        System.out.println("c中包含"+ c.size()+"个元素");
        Collection s=new HashSet(); //  Collection 父接口, 利用子接口 set 的实现类,创建对象
        s.add("javascript");
        s.add("java");
        System.out.println("c中是否完全包含s集合中的元素: "+c.containsAll(s)); // c集合中有没有包含s集合的元素
        s.removeAll(c); // s 集合中去除c集合中元素
        System.out.println("s 集合中的元素: "+s);


    }

}

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第11张图片

子接口

Set集合-子接口:

特点:
无序的 , 不可重复; 唯一值 ;  
定义:
public  interface Set  extends Collection {}
实现类:
HashSet  继承 AbstractSet 
TreeSet  继承 AbstractSet  实现 SortedSet 
方法:
添加: add(object o)
删除: remove(object o)
遍历: iterator() ; 把set集合数据转移 返回迭代器对象

public class HashSetDemo
{
    public static void main(String[] args)
    {
        Set<String> s=new HashSet<String>(); // Set 创建它的  实现类 Hashset
        s.add("A");
        s.add("b");
        s.add("b");
        s.add("b");
        System.out.println(s); // 结果不允许冗余 b只能有一个

    }
}

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第12张图片

Queue(队列) 子接口:
特点: 排队; 先排到队头先处理


List列表 -子接口 
特点: 
有序, 可重复; 类似数组
方法:
按指定位置删除元素  :  remove( index i) 
根据下标找到对应的值并返回值 :  get( index i ) ,类似数据下标
在指定位置添加元素:  add(int  index , object o)  将o数据添加到下标为index 中的位置
在指定位置增加一组元素:  addAll();
	List list = new ArrayLIst();
	list.add(1);  //添加数字1
	list.add("");  // 添加双引号
	list.add(new Student());  //添加对象
实现类: 
Arraylist  子接口; 特点:  相当于线性表;   -->继承abstractlist-->实现了list
// 代码
public class ArrayListDemo
{
    public static void main(String[] args)
    {
// 创建Arraylist ,限定类型为String
        ArrayList<String> alist=new ArrayList<String >();  //  创建类的对象,只能用arraylist 的方法,不能调用list 方法
        // add 方法添加元素
        alist.add("ABC");
        ArrayList<String> alist2 =new ArrayList<String>();  // new 正常创建类的对象2, 不能调用父接口List 方法
        alist2.add("Hello");
        alist2.add("world");

        alist.addAll(0,alist2);  // 向alist 集合的 0的位置,添加一个集合alist2
        System.out.println(alist);
        //remove  删除元素
        alist.remove(2); //2号下标对应的值删除
        alist.remove("ABC");
        // toArray  方法  转为数组,遍历输出
        String str[]=alist.toArray(new String[]{});
        System.out.println("数组类型: ");
        for( int i=0; i<str.length ; i++)
        {
            System.out.println(str[i]);
        }
    }
}

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第13张图片

LinkedList 子接口  ;  特点: 类似(线性链表, 如自行车链子截断后的线条 )
定义:
 public  interface List  extends Collection { }
方法:
addFirst() 链表开头添加元素
addLast() 链表结尾增加元素
removeFirst()
removeLast()

public class LinkList
{
    public static void main(String[] args)
    {
// 类似自行车链 ,链表

        LinkedList<String> qu = new LinkedList<String>();  // 创建类的对象
        qu.add("A");  // add 方法添加元素
        qu.add("B");
        qu.add("C");
        System.out.println(qu);
        qu.addFirst("头部");  // 链表头部添加头元素
        qu.addLast("尾部");  // 链表尾部添加尾部元素
        System.out.println(qu);
        for (int i = 1; i < 6; i++)
        {
            System.out.println("第" + i + "个元素是: ");
            System.out.println(qu.poll());  //  poll方法作用:  获取并移除元素
        }

    }
}

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第14张图片

Map映射-键值对(父接口)

特点:
k-v键值对,需要先配对 ; key 配对values 值 ;只要找到key 就能找到values 
定义:
public  interface Map  
实现类:
SortedMap 类 ------ TreeMap (孙子类)
方法: 
put(k,v): 添加数据
remove(  key ) :删除数据:  根据指定的key 匹配到对应的方法删除
 get( key)  根据key取得valuse值
keyset() ; 把Map所有的key组合
values(); 对值进行集合
 hashCode()  判断当前集合中的哈希编码 
size() : 返回集合长度
clear() :  把集合当中的元素清理掉:  

public class MapDemo
{
    public static void main(String[] args)
    {
        Map<String,Integer> hm=new HashMap<String,Integer>();  // map 创建了一个实现类
        hm.put("1", 100);
        hm.put("2", 90);
        hm.put("3", 98);
        System.out.println(hm);
        System.out.println("hm中共有"+hm.size()+"个元素");
        Set<String> set=hm.keySet(); // map中的 key值的集合  集合到set 框架中的set 对象中
        System.out.println(" key 集合: "+ set);
        System.out.println("key值为1 的value的值为: "+ hm.get("1"));

    }
}

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第15张图片

Iterator 迭代器(遍历) 父接口

作用:

迭代输出接口

定义:
    Iterator 对象名 =Collection 接口对象名.iterator(); 
方法:
hasNext(): 判断是否有下一个值

public class IteratorDemo
{
    public static void main(String[] args)
    {
        List<String> list=new ArrayList<String>();  // List 调用了实现类  ArrayList
        list.add("A");

        list.add("E");
        list.add("B");
        list.add("C");
        list.add("D");
        System.out.println(list);  //  按敲的顺序显示

        Iterator<String > iter=list.iterator();
        while(iter.hasNext())  //  hasNest()方法 作用 : 判断是否有下一个值
        {
            System.out.println(iter.next()+" ");
            // next()方法的作用:  取出当前元素
        }
    }
}

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第16张图片

泛型 e / E

定义

约束存放数据类型只能为 某个类型, 如Student对象,无需判断数据类型, 有利于遍历

代码


public class GenericDemo
{
    public static void main(String[] args)
    {
        A<Integer> p1 = new A<Integer>();
        A<String> p2 = new A<String>();
        p1.setX(100);
        p2.setX("abc");
        System.out.println(p1.getX() + p2.getX());

    }
}

class A<T> //T为定义的泛型
{
    private T x;

    public void setX(T x)
    {
        this.x = x;
    }

    public T getX()
    {
        return x;
    }
}

Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))_第17张图片

栈与队列

特点: 先进后出
方法:
返回第一个元素并将该元素pop出栈: pop() 

队列

特点: 先进先出

其他

@NotNull  为注解	

文件操作

文件操作输入输出流 (考)

基础

父类----Object  基类
子类---Inputstream/Outputstream/Reader/Writer 且为抽象类

内存区: 程序中运行的程序

数据流入: 从外存到内存, 入; 读文件 ( 读入数据 ,显示出来)
数据流出: 从内存到外存, 出;写文件 ( 写出数据,  )

注意: 
类/包名:  读入,写出的文件名不能和类名Reader / Writer 一致, 否则报错
路径: 	/ 写一个;  \\ 写两个

字符流(处理文本数据)

Reader  读  /  Writer   写; 抽象基类  ;  
读写完成null判断
Unicode 编码: 1个汉字, 两个字节, 16位
使用其孙子类:  
FileWriter   ;  FileReader 
Writer out=new FileWriter("文件目录");
// 写出文件
public class Write
{
    public static void main(String[] args) throws IOException
    {
        Writer out=new FileWriter("D:\\A_temporaryd\\nihao\\Java\\output.txt");
        String str="this is the test of writer and reader 等等等,,时间如,";
        out.write(str);
        out.close();
      /*
      写出文件 ,到    output.txt文件
       */
    }
}


/**
 * 读入文件
 * 数据流
 */
public class ReaderExample
{
    public static void main(String[] args) throws IOException
    {
        Reader in=new FileReader("D:\\A_temporaryd\\甘政法\\Java\\output.txt");
        char c[]=new char[1024];
        int len=in.read(c);
        in.close();
        System.out.println("内容为: "+new String(c,0,len));
/*
读入文件
在这段代码中,`new String(c, 0, len)
c: 转换为字符
0: 表示从字符数组`c`的索引0开始,
len: 表示要转换的字符数。这样的操作会创建一个新的String对象,其内容为从字符数组`c`中索引0开始的`len`个字符。这种用法可以实现
将字符数组转换为字符串,并且只包含数组中指定范围内的字符。

 */

    }
}

字节流( 二进制 / 图片 / 文本文件 )

父类: InputStream  读 / OutputStream 写 ; 
读写完成-1判断

子类:
创建对象,操作文件:   FileInputStream  /   FIleOutputStrean
例如:
FileInputStream  in =new FileInputStream (" 文件路径,及其文件名 ") 
FIleOutputStrean out =new FIleOutputStrean( " 文件路径,及其文件名 " )    
或
FileInputStream  in =new FileInputStream  ( new FIle( " 文件路径,及其文件名 " ) )   

孙子类(接上in / out ):
DataInputStream   /  DataOutputStream  
DataInputStream  dataln= new DataInputStream( in ) ;
DataOutputStream   dataOut=new DataOutputStream  (out);

/**
 * 图片输出流
 *
 */

public class DataINputStream
{
    public static void main(String[] args) throws FileNotFoundException, IOException
    {
        DataInputStream in = new DataInputStream(new FileInputStream("D:\\A_temporaryd\\nihao\\Java\\duotai.jpg"));
        DataOutputStream out = new DataOutputStream(new FileOutputStream("D:\\A_temporaryd\\nihao\\Java\\duotai111.jpg"));
        byte b[] = new byte[1024];
        int a = 0;
        while ((a = in.read(b)) != -1) //  循环, 判断是否为-1:  判断文件是否读取完毕
        {
            out.write(b);
        }
        in.close(); //关闭流
    }
}

结果: 复制输出图片duotai111.jpg

追加不覆盖true

原本文件内容:abc  
现将 def 写入到abc文件中
一种, 覆盖掉abc 为:  def 
另一种, 不覆盖, 跟到abc后面 为:  abcdef
FileWriter    fw =new FileWriter  (" " , true ) ;  // true 判断覆盖还是不覆盖 ; true 表示追加,不覆盖 
FileReader fw =new FileReader (" " , true ) ;  

/**
 * 不覆盖文件,追加true
 */
public class filew
{
    public static void main(String[] args) throws IOException
    {
        FileWriter fw=new FileWriter("D:\\A_temporaryd\\甘政法\\Java\\output.txt", true);
       String str=" 追加文件 zhuijia file ";
       fw.write(str);
       fw.close();
    }
}


//  读入显示文件
public class filer
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("D:\\A_temporaryd\\甘政法\\Java\\output.txt");
        char c[] = new char[1024];
        int len = fr.read(c);
        // 使用FileReader的read()方法将文件的内容读取到 数组'c'中
        // 获取文件中字符长度并 存储在 len 中
     
        fr.close();  
        System.out.println("内容为: " + new String(c, 0, len));
        // 使用从文件中读取的字符('c'数组)创建一个新的字符串,从索引0开始到'len'结束,并在打印之前将其与字符串"内容为: "连接起来。

    }
}

待续、更新中

 
 
—————————————————————
以上就是今日博客的全部内容了
创作不易,若对您有帮助,可否点赞、关注一二呢,感谢支持.

你可能感兴趣的:(java程序设计语言,java,开发语言,intellij-idea,后端)