Java基础-5

1.java值传递

Java 中的基本类型，属于值传递。

Java 中的引用类型，属于引用传递。

Java 中的 String 及包装类，属于特殊群体，作为形参时，由于每次赋值都相当于重新创建了对象，因此看起来像值传递，但是其特性已经破坏了，值传递、引用传递的定义。因此他们属于引用传递的定义，却表现为值传递。

String 与其他包装类，在做形参的时候，由于他们在赋不同于实参的值时，改变了形参的地址，因此使引用传递，看起来像值传递，其实本质还是引用传递

2.方法重写

重写:需要有继承关系，子类重写父类的方法 1.方法名相同 2.参数列表相同 3.修饰符: 范围可以扩大 public > protected > Default > private 4.抛出的异常 : 范围可以缩小 ，但是不能扩大 ， ClassNotFoundException --> Exception（大）

重写 :子类的方法和父类必要一致 ：方法体不同

为什么要重写 1.父类的功能不一定能满足，或者需要

3.多态

多态注意事项: 1.多态是方法的多态 2.父类和子类要有联系 3.存在条件: 继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son(); 4.static方法: 属于类，不属于实例

//一个对象的实际类型确定的
//new Student();
//new person();
​
//可以指向的引用类型不确定: 父类的引用指向子类
​
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法####################
Person s2 = new Student();
Object s3 = new Student();
​
//对象能执行哪些方法，只要看对象左边的类型，和右边关系不大
//左边哪个类型就执行哪个类的，如果都有这个方法的话就执行子类的
s1.eat();//子类重写了父类方法，执行子类的方法，son
((Student) s2).eat();

4.instanceof

//instanceof 判断类之间是否相似
//Object > String
//Object > Person > Teacher
//Object > Person > Student
Object object = new Student();
//System.out.println();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false

5.类型转换

package oop.demo04;
​
/**
 * 类型转换
 * 1.父类引用指向子类的对象
 * 2.把子类转换成父类，向上转换
 * 3.把父类转换成子类，向下转换，强制转换
 * 4.方便方法的调用，减少代码量
 */
public class Application {
    public static void main(String[] args) {
        // 高Person        低Student
        Person obj = new Student();
        //obj无法使用子类go()方法;
​
        Student student = (Student) obj;//强制转换高---->低
        student.go();//可以使用子类的go方法
​
        //子类转换成父类可能丢失自己本来的一些方法
        Student student1 = new Student();
        student1.go();
        Person person = student1;
        //person.go
    }
}
​

6.静态代码块

package oop.demo05;
​
public class Person {
    //1.静态代码块只执行一次
    static {
        System.out.println("静态代码块");
    }
    //2.赋初始值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }
​
    public static void main(String[] args) {
​
        Person person = new Person();
        System.out.println("===========");
        Person person1 = new Person();
    }
}

执行结果：

静态代码块
匿名代码块
构造方法
===========
匿名代码块
构造方法

//静态导入包
import static java.lang.Math.random;

7.抽象类

package oop.demo06;
/**
 *abstract抽象类：
 */
public abstract class Action {
​
    //约束——有人帮我们实现~
    //abstract ,抽象方法，只有方法和名字，没有方法实现
    public abstract void doSomething();
​
    //1.不能new这个抽象类，只能靠子类去实现它，约束
    //2.抽象类中可以有普通方法
    //3.抽象方法只能在抽象类中
    //抽象的抽象
    //抽象类？  提高开发效率
​
}

8.接口

package oop.demo07;
​
/**
 * 接口里面的方法都是抽象的 public abstract
 * 1.约束
 * 2.定义一些方法不同人实现
 * 3.接口可以用implements 实现多个接口
 * 4.接口没有构造函数
 */
public interface UserService {
    //常量public static final
    int AGE = 99;
    public void addUser();
    public void deleteUser();
    public void updateUser();
    public void queryUser();
}
​

9.内部类

package oop.demo08;
​
/**
 * 1.内部类
 * 2.一个java类中可以有多个class类，但是只能有一个public class
 */
public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    /* static 如果用static修饰id也需要为static才能访问 */ class  Inter{
        public void inter(){
            System.out.println("这是内部类方法");
        }
        //获取外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
        //局部内部类
        public void method(){
            class in{
​
            }
        }
    }
}

10.异常

package oop.demo09;
​
/**
 * 异常处理
 */
public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //假设要捕获异常，要从小到大！
        try { //监视区域
            //System.out.println(a/b);
            new Test().a();
        } catch (Error error){   //捕获异常,参数是想要捕获的异常类型
            System.out.println("Error");
        } catch (Exception exception){
            System.out.println("Exception");
        } catch (Throwable throwable){ //最大的写在最后
            System.out.println("Throwable");
        } finally {  //处理善后工作，可以不要 ，后续IO操作，需要关闭IO流等
            System.out.println("finally");
        }
​
​
    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
​
​
}

11.继承

package oop.extend;
//学生 is 人  :子类 ,派生类
//子类继承父类,会拥有父类全部方法
/*
super注意点:
     1.super 调用父类的构造方法, 必须放在构造方法第一个
     2.super 必须只能出现在子类的方法或者构造方法中
     3.super和this 不能同时调用构造方法
前提:
     this: 可以在无继承时使用
     super: 必须存在继承条件才可以使用
构造方法:
     this() :本类的构造
     super() :父类的构造
 */
public class Student extends Person {
        //ctrl + H
    private String name = "huishneg";
​
    public Student() {
        //隐藏代码,调用了父类的无参构造
        //super();必须子类构造器第一行
        System.out.println("student无参数执行了");
    }
​
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        //可以用super访问用protected修饰的属性
        System.out.println(super.name);
    }
    public void say(){
        System.out.println("Student说话了");
    }
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}