java2-类的重载与共享参数,getattr和setattr, 继承,抽象和接口,异常检测,文件操作

类的重载与共享参数

，同一类名不同的实例化传形参的方式

public class create_class {
    String color="黑色";
    int speed=60;
    public  create_class(String color){   //使用public加上类名来自定义传类的时候需要加上的形参
        this.color=color;
    }
    public  create_class(int speed){   //使用public加上类名来自定义传类的时候需要加上的形参
        this.speed=speed;
    }
    public void run() {   //十分要注意，这里类里面定义的不能加static
        System.out.println("最高时速为"+this.speed+"De"+this.color+"的车开车了");
    }
        public static void main(String[] args) {
            create_class c1=new create_class("黄色");  //将类进行实例化
            c1.run();
            create_class c2=new create_class(30);  //将类进行实例化
            c2.run();
        }
    }

参数共享，比如a和b两个实例化的人都属于s国，s国是个公用属性，改的时候不需要将每个实例化的人的国家进行修改，只需要改一次共享的属性就行了

public class create_class {
     static String color="黑色";
     int speed;

    public  create_class(int speed){   //使用public加上类名来自定义传类的时候需要加上的形参
        this.speed=speed;
    }
    public void run() {   //十分要注意，这里类里面定义的不能加static
        System.out.println("最高时速为"+this.speed+"De"+create_class.color+"的车开车了");
    }
        public static void main(String[] args) {
            create_class c1=new create_class(50);  //将类进行实例化
            c1.run();
            create_class c2=new create_class(30);  //将类进行实例化
            c2.run();
            create_class.color="黄色";
            c1.run();
            c2.run();
        }
    }

#static静态的东西优先于类产生

导包

总目录是src下的目录

 

比如day2的程序下面首先就要写package com.day2;    而day1下面的程序需要首先写package com.day1;      day2导入day1包里面的zqhop程序就写import com.day1.zqh_op;

package com.day2;
import com.day1.zqh_op;
public class main_win {
    public String s1="公有的";   //所有人可以访问
    private String s2="私有的";  //只有自己的程序里可以访问
    String s3="默认";            //在自己的包里面可以访问
    public static void main(String[] args) {
        zqh_op ss=new zqh_op();
        System.out.println(ss.s1);
    }
}

getattr和setattr

使得类里面的参数是private的，在其他的java程序不能直接访问的，要通过设定的set的api来修改，修改的过程中也可以加入逻辑。获取private的参数的值也需要通过给定的getattr的接口

package com.day1;
public class person {
    private int age;
    private String name;

    public void set_age(int age){
        if(age>0){
            this.age=age;
        }
        else{
            System.out.println("age wrong");
        }
    }
    public void set_name(String name){
            this.name=name;
        }
    public void get_name(){
        System.out.println(this.name);
    }
    }

package com.day2;
import com.day1.person;

public class main_win {
    public static void main(String[] args) {
        person p1=new person();
        p1.set_age(10);
        p1.set_name("sad");
        p1.get_name();
    }
}

 继承

继承父类里面的所有参数和方法，但是私有的不会被继承。

写法：public 类 extend 父类{}

 

调用参数时this用自己的super用父类的，同名内容

 对类里面的方法的重写

package com.day1;
public class liyuan {
    public void makecountry(){
        System.out.println("李渊要建国");
    }
}

package com.day1;
public class lishimin extends liyuan{
    public void makecountry(){
        System.out.println("李世民要建国");
    }
    public void orinmakecountry(){
        super.makecountry();
    }
public static void main(String[] args) {
    lishimin sd=new lishimin();
    sd.makecountry();  //调用子类的重写的
   sd.orinmakecountry(); //重写后调用父类的
}
}

final

在变量前面加上final，final将无法被修改，直接被定死。

被final修改的方法也无法被重写

被final修饰的类不能被继承

抽象和接口

函数的中间加abstract结尾不加{执行体}，直接用;收尾。    比如public abstract void eat();   注意如果出现了抽象方法的话，类也需要加上abstract。

package com.day1;
public abstract class person {
    public abstract void name();
    }

使用抽象类的目的：

抽象类的子类必须重写父类的方法，可以强制子类里面必须写哪些方法。

 

继承只能继承一个父类，但是一个子类可以接多个接口

package com.day1;
public interface lazy_one {
    String name="er";
    void pump();
}

package com.day1;
public interface eat_one {
    String name="ab";
    void eat();
}

package com.day1;
public class person implements eat_one,lazy_one {
    @Override
    public void eat() {
        System.out.println("吃翔");
    }
    @Override
    public void pump() {
        System.out.println("拉翔");
    }
    public static void main(String[] args) {
        person sd=new person();
        eat_one sd1=new person();
        lazy_one sd2=new person();
        sd1.eat();
        sd2.pump();
        System.out.println(sd1.name);
    }
}

equals比较的是内容，==比较的是内存地址。

字符串的判断必须用equals，平常判断用户名和密码都要用equals

 instanceof判断实例是不是属于某个父类

package com.day1;
public class person {
    String name;
    public  person(String name){
        this.name=name;
    }
    public static void main(String[] args) {
        person m1=new person("ab");
        person m2=new person("ab");
        if (m1 instanceof person){
            System.out.println("m1是人");
        }
        else{
            System.out.println("m1不是人");
        }
    }
}

异常检测

public class test {
    public static void main(String[] args) {
        try{
            String b=String.valueOf(10/0);
        }
        catch (Exception e){
            System.out.println("系统出错");
        }
        finally {
            System.out.println("一般做收尾工作");
        }
    }
}

 用throw抛出

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class test {
    public static void main(String[] args) throws Exception {
        byte[] data={1,2,3,4};
        File file=new File("ab.txt");
//        file.createNewFile();  //在该
    }
}

文件

文件的定义生成删除，判别存在

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class test {
    public static void main(String[] args) throws Exception {
        byte[] data={1,2,3,4};
        File file=new File("D:"+File.separator+"study tool"+File.separator+"ab.txt");
        file.createNewFile();  //创建该文件
        file.delete(); //删除该文件
        System.out.println(file.exists());  //判断文件是否存在
    }
}

路径分隔符尽量使用file.separator(为了跨平台通用)

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class test {
    public static void main(String[] args) throws Exception {
        byte[] data={1,2,3,4};
        File file=new File("D:"+File.separator+"study tool"+File.separator+"ab.txt");
        file.createNewFile();  //创建该文件
    }
}

文件夹操作

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class test {
    public static void main(String[] args) throws Exception {
        byte[] data={1,2,3,4};
        File file=new File("D:"+File.separator+"javatest"+File.separator+"ab.txt");
        System.out.println(file.getParentFile().exists());    //file.getParentFile().exists()是判断父路径是否存在
        if(file.getParentFile().exists()==false){
            file.getParentFile().mkdir();       //就创建父目录
//            file.getParentFile().delete();    //删除目录
        }
        System.out.println(file.canExecute()); //判断是否可执行
        System.out.println(file.canRead()); //判断是否可读
        System.out.println(file.canWrite()); //判断是否写
        System.out.println(file.getAbsoluteFile()); //得到绝对路径
        System.out.println(file.isDirectory()); //判断是否是目录，比如D:/study tool/java15
        System.out.println(file.isFile()); //判断是否是文件   比如d:/study tool/java15/py.txt
        System.out.println(file.getName()); //获取文件或者目录的名称
        System.out.println(file.length()); //判断文件的大小
    }
}

 outputstream字节流

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.util.Arrays;
public class test {
    public static void main(String[] args) throws Exception {
        byte[] data={1,2,3,4};
        File newfile=new File("sb.txt");
        OutputStream outputStream=new FileOutputStream(newfile);
        outputStream.write("shisbba".getBytes());  //使用getbytes可以把字符串转换成bytes
        outputStream.close();

        File newfile1=new File("sb.txt");
        OutputStream outputStream1=new FileOutputStream(newfile1,true);  //把追加位改成true成追加
        outputStream1.write("\r\nniganma".getBytes());  //使用getbytes可以把字符串转换成bytes,可以设置写入的起始终结点
        outputStream1.close();
    }
}

 inputstream字节流

import java.io.*;
import java.lang.reflect.Array;
import java.util.Arrays;
public class test {
    public static void main(String[] args) throws Exception {
        File newfile=new File("sb.txt");
        InputStream input=new FileInputStream(newfile);
        int total_bit=input.available();
        System.out.println(input.available()); //获取文件总共能读取多少个字节
        byte[] data=new byte[total_bit];   //创造字节大小的data来存放
        OutputStream outputStream1=new FileOutputStream(newfile,true);  //把追加位改成true成追加
        int len=input.read(data);  //把文件的内容读出来到data
        System.out.println(new String(data)); //把读出来的数组转换成字符串
        input.close();
    }
}

 writer字符流

import java.io.*;
import java.lang.reflect.Array;
import java.util.Arrays;
public class test {
    public static void main(String[] args) throws Exception {
        File newfile=new File("sb.txt");
        Writer wd=new FileWriter(newfile);   //定义writer字符流
        wd.write("你好");   //直接写字符
        wd.append("我拉了");   //追加操作
        wd.close();
    }
}

reader字符流

import java.io.*;
import java.lang.reflect.Array;
import java.util.Arrays;
public class test {
    public static void main(String[] args) throws Exception {
        File newfile=new File("sb.txt");
        Reader rd=new FileReader(newfile);   //定义reader字符流
        char data[]=new char[1024];
        int len =rd.read(data);   //读取进data并获取其长度
        System.out.println(new String(data,0,len));
        rd.close();
    }
}

字符流是要用到缓冲区的，如果不用close关掉字符流的reader和writer的话，会导致缓冲区没有写入，造成文档没有写入，用flush()清空缓冲区也可以全部写入完毕

 复制文件

import java.io.*;
import java.lang.reflect.Array;
import java.util.Arrays;
public class test {
    public void Copy_op(String Str1,String Str2) throws Exception {
        File srcFile= new File(Str1);  //源文件路径
        File desFile=new File(Str2);  //目标文件路径

        boolean target=false;   //一开始不是追加模式，直接覆盖
        InputStream inputStream=new FileInputStream(srcFile); //定义输入流
        OutputStream outputStream=new FileOutputStream(desFile,target); //定义输出流
        int tortal_len=inputStream.available(); //文件的总大小
        byte[] trans_data=new byte[1024];  //定义传输数据存放数组
        int len=inputStream.read(trans_data);  //读取二进制数据进传输数据存放数据，并获取数据的长度
        target=true;  //开启追加模式
        while (true){
            if (len!=-1){         //如果读出来的内容不为空，如果没读出内容len是-1
                byte[] write_data=trans_data;
                byte[] trans_data1=new byte[1024];//定义1号传输数据存放数组
                outputStream.write(write_data);  //写入二进制数据
                len=inputStream.read(trans_data);  //再读
            }
            else{
                break;   //一旦读完了，读出数据为空跳出
            }
        }
        inputStream.close();
        outputStream.close();
        }


    public static void main(String[] args) throws Exception {
        test tx=new test();
        tx.Copy_op("1.rar","2.rar");
    }
}

 编码解码的统一

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Array;
import java.util.Arrays;
public class test {
    public static void main(String[] args) throws Exception {
        byte[] data={1,2,3,4};
        File newfile=new File("sb.txt");
        OutputStream outputStream=new FileOutputStream(newfile);
        outputStream.write("shisbba".getBytes("unicode"));  //使用getbytes可以把字符串转换成bytes
        outputStream.close();


        File newfile1=new File("sb.txt");
        InputStream input=new FileInputStream(newfile1);
        int total_bit=input.available();
        System.out.println(input.available()); //获取文件总共能读取多少个字节
        byte[] data1=new byte[total_bit];   //创造字节大小的data来存放
        int len=input.read(data1);  //把文件的内容读出来到data
        System.out.println(new String(data1,"unicode")); //把读出来的数组转换成字符串
        input.close();
    }
}

inputstream时可以用readallbytes()来把文件的所有内容读取到内存中