JAVA 2022.7.13课程总结

  一、插入排序  

public static void main(String[] args) {
        //插入排序
        int[] arr= {12,34,5,7,8,3,32};
        //i代表当前元素的下标
        for(int i=1;i<arr.length;i++) {
            //元素

            int item=arr[i];
   //向前比较，比自身大的元素向后移位，直到找到不大于自身的元素A
            //把自身放到A的后面
            //j代表要比较元素的下标
            int j;
            for(j=i-1;j>=0;j--) {
                if(item<arr[j]) {
                    //比自身大的元素向后移
                    arr[j+1]=arr[j];
                    
                }else {
                    break;
                }
            }
            
                arr[j+1]=item;
            //System.out.println(Arrays.toString(arr));
        }

        System.out.println(Arrays.toString(arr));
    }

例题：对一个数组去重

    //定一个方法，数组去重的结果
    static int[] norepeat(int[] arr) {
        int[] result=new int[arr.length]; 
        //当前元素之后是否有重复，有重复不操作，无重复，保存在新数组中
        //保存位置
        int index=0;
        //代表没有相同的
        boolean flag=false;
        for(int i=0;i<arr.length;i++)    {
            //arr[i]--当前元素
            //查找是否有重复的元素
            for(int j=i+1;j<arr.length;j++) {
                if(arr[i]==arr[j]) {
                    //找到相同
                    flag=true;
                    break;
                    
                }
        }
            if(!flag) {
                result[index]=arr[i];
                index++;
            }
        }
        return result;
        }

跳出多重循环 

        out:for(;;) {
            for(int i=0;i<10;i++) {
                if(i==6) {
                    //跳出多重循环
                    break out;
                }
            }

二、特殊值

        //特殊值0 0.0 -0.0 无穷大 负无穷大 NAN
        int i=0;
        double a1=0.0;
        double a2=-0.0;
        System.out.println(a1);  //0.0
        System.out.println(a2);    //-0.0
        System.out.println(a1==a2);//true
        System.out.println(0==a2);//true
        
        // i=12/0; 整数0为除数，报数学运算异常Arithmetic
        a1=1/0.0;
        System.out.println(a1); //Infinity正无穷大
        System.out.println(1/-0.0);//-Infinity负无穷大
        System.out.println(-1/0.0);//-Infinity负无穷大
        
        System.out.println(0/0.0);//NaN:not a number 是值但是不是数字
        a1=0/0.0;
        System.out.println(a1);//NaN
        

       round是+0.5向下取整

        double d1=Math.ceil(2.3);
        d1=Math.floor(2.4);
        long l1=Math.round(1.8);
        System.out.println(l1);//2
        System.out.println(Math.round(0.5));//1
        System.out.println(Math.round(-0.5));//0
        System.out.println(Math.round(-1.5));//-1
        System.out.println(Math.round(0.4));//0
        System.out.println(Math.round(0.8));//1
        System.out.println(Math.round(-0.4));//0
        System.out.println(Math.round(1/0.0));//long的最大值9223372036854775807
        System.out.println(Long.MAX_VALUE);//long的最大值9223372036854775807
        System.out.println(Math.round(1/-0.0));//long的最小值-9223372036854775808
        System.out.println(Long.MIN_VALUE);//long的最小值-9223372036854775808 

三、方法知识点

1.例题：利用sort排序数组 

//调用

public static void main(String[] args) {
        int[] arr= {12,3,5,1,44,8};
        sort(arr);
        System.out.println(Arrays.toString(arr));

}

//定义排序方法

    //void不需要返回值
    public static void sort(int[] arr) {
        Arrays.sort(arr);
        return;//void方法可以使用return  终结方法
    }

2.可变参数 

    //可变参数
    //数量可变，类型不可以变
    //一个方法中最多有一个可变参数，并且可变参数必须放在参数列表最后

    public static void main(String[] args) {

       method(1,2,3);
    }

//调用
    static void method(int j,double...i ) {
        System.out.println(i.length);
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
    }

四、面向对象

1.定义和使用类

    public static void main(String[] args) {
        //面向对象
        //对象&类
        //类：人类 
        //对象：具体的实例
        //编程中,先定义类，才能实例化对象
        int a=12;
        //实例化一个Person类的对象
        Person per1=new Person();
        //对象属性的赋值
        per1.name="张三";
        per1.eat();
        Person per2=new Person();
        per2.name="李四";
        System.out.println(per1.name);
        System.out.println(per2.name);
        per2.eat();
    }        
}
class Person{
    //声明在类中的变量 叫 全局变量 属性  在整个类中都生效的变量
    String name;
    String sex;
    int age;
    //在本类中可以直接调用类中声明的属性
    void eat() {
        //局部变量 在执行代码块中声明的变量
        int i=0;
        //调用变量就近原则，
        String name="aaa";
        //使用this标注使用属性变量
        System.out.println(this.name+"正在吃饭");
    }

2. 四种访问权限修饰符
    //public protected default private
    //publice 公共的
    //default 本包下的
    //private 私有的 

    //public static void main(String[] args) {
    //本包下的类默认可以访问本包下所有的类
    //所有的类默认引入java.lang包
    //在类文件中只能有一个public类，并且这个类的类名必须和文件名一致
    //main方法必须写在public类中
        
        //公共方法
        public void test1() {}
        //私有方法  只能在自身类中才能访问到
        private void test2() {
            String a="sd";
        }        
    }
class Test{
    void test() {
        Easy7 e7=new Easy7();
        e7.test1();
        //e7.test2(); //调用不到
    }
}

调用外包的类：

    //引入com.easy3的所有类
    import com.easy3.*;
    //如果一个类中要使用两个重名的类型，需要使用类的全名来标注
    com.easy1.Easy3 ee=new com.easy1.Easy3();

3.封装

    //封装：将属性私有化，提供公共访问方法

public class Easy {
    public static void main(String[] args) {
    List list=new List();
    list.add(1);
    list.print();
    //list.value[1]=12;
    //System.out.println(list.size);
}
}
class List{
    private int size=0;
    private int[] value=new int[16];
    public int size() {
        return this.size;
    }
    void add(int item) {
        value[size]=item;
        size++;
    }
    public void print() {
        System.out.println(Arrays.toString(value));
    }
}
} 

get()  set()方法   get获取  set设置

public class Easy2 {
    public static void main(String[] args) {
        a aa=new a();
        aa.setAge(15);
        int i=aa.getAge();
        System.out.println(i);
    }
}
class a{
    private String code;
    private String name;
    private int age=1;
    
    
    public String getCode() {
        return this.code;
    }
    public void setCode(String code) {
        this.code=code;
    }
    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;
    }
}

 4.继承

//继承
///java中运行单继承，可以多重继承
//java中所有类的父类是Object
//使用extends标注继承父类
//B子类 A父类
//子类继承父类，子类中就具有父类中可继承的属性和方法
//实现代码的复用 

    public static void main(String[] args) {
        A a=new A();
        a.test();
        System.out.println(a.surname);
        B b=new B();
        b.test();
        System.out.println(b.surname);
    }
}
class A{
    String surname;
    //私有属性
    private int money;
    void test() {    
    }
}
class B extends A{
    void test() {
        System.out.println(surname);
        //System.out.println(money);  //私有属性不继承
    }
}

 构造方法：

public class Demo {
    public static void main(String[] args) {
        Demo a=new Demo("张三");
    }
    String name;
        //构造方法
        //构造方法名和类名一致
        //作用：初始化对象,准备资源
        //每个类，系统会自动提供一个无参构造方法
        //一旦自定义了构造方法，系统提供的默认构造方法就不存在了
        public Demo() {
        }
        public Demo(String name) {
            this.name=name;
        }
}

public class Son extends Parent {
    //super 可以使用super调用父类中的属性
    public String name;
    public Son(String str1,String str2) {
        //子类的构造方法第一行,必须调用父类的构造方法super关键字
        //子类的构造方法默认第一行调用父类的无参构造方法  
        super("");
        this.name=str1;
        super.name=str2;
    }
    void test() {
        System.out.println(code);
        System.out.println(sex);
        System.out.println(super.name);
        System.out.println(name);
    }
    public static void main(String[] args) {
        Son s=new Son("aaa","bbb");
        s.test();
    }
}
 

    //方法的重载
    public String test() {
        return "";
    }
    public String test(int a,double b) {
        return "";
    }
    public String test(double b,int a) {
        return "";
    }
    public void test(int a) {
        
    }

public class Son extends Person{
    //子类对父类中继承过来的方法进行重新定义--方法重写
    //父类中的方法不适应当前业务
    //必须是子类重写父类中的方法
    //方法名必须一样
    //返回值类型必须一样
    //参数列表必须一样
    //访问权限可以可以变大（更开放）
    @Override   //如果重写不报错
    public void test() {
        System.out.println("SON method");
    }
    public void test1() {
        Son s=new Son();
        //向上转型 父类的指针指向子类的对象或实例
        Person p=new Son();
        p=new Son2();
        Object obj=new Son();
    }
    public static void demo(Person p) {
        p.test();
    }
    public static void main(String[] args) {
        Person p=new Person();    
        //多态
        //继承 可以向上转型 重写
        //在程序运行过程中，一个父类的指针执行的方法，可能会出现
    }
}