JavaSE基础05(方法,重载,调用,类和对象,构造器,封装,继承,方法重写,抽象类,接口,异常)-526互联

面向对象

以类的方式组织代码，以对象的组织封装数据;
一个Java文件只能有一个public类,必须和文件名一样;
java文件里也可以没有public类;

方法的定义

方法的使用，修饰符返回值类型方法名（参数类型参数名）{ 方法体 reture 返回值}；参数类型包括: 基本数据类型和引用数据类型(String和创建的所有的类)
return 终止方法
当方法返回一个值的时候，方法调用通常被当作一个值，例如：int larger=max(30,40);
如果方法返回值是void，方法调用一定是一条语句。例如： System.out.println("hello");
return 一个方法只能返回一个对象或一个值;
执行return 这个方法就结束了,return后面的代码不会执行;
没有static 的方法需要创建类对象,通过对象名.方法名调用;
如果返回值类型是void的话,不需要return返回值,其他的需要返回一个该类型的数据;

方法的重载

方法相同，但是只是参数类型或参数个数不同，通过不同的类型调用各自的方法；
可以通过创建类的对象来调用；
也可以用到有参构造方法,重载多个有参构造方法,在创建对象时直接传入参数;
在有参构造前面已经有了this.name=name;时,下面重载的可以直接写this();

可变参数

使用方法：在方法声明中，在指定参数类型后加一个省略号(int... 变量名) 指参数个数可变,类型不可变;
一个方法中能指定一个可变参数，它必须是方法的最后一个参数，任何一个普通参数都必须在它之前声明；

递归

递归就是用A方法调用A方法；
递归结构包括两个部分：递归头：什么时候不调用自身方法，如果没有头将陷入死循环；递归体：什么时候需要调用自身方法。

方法的调用

静态方法static方法调用，跨类调用类名.方法名()。
static修饰的属性和方法可以直接使用类名调用,否则要创建对象调用;static 修饰的方法,可以通过对象调用,但是还是通过静态方式访问的;
对象的没有使用static修饰的,必须由对象调用;
类的使用static定义的属性和方法就是类的,也叫做静态的;
先获取对象的类,然后调用静态的方法;

非静态类，跨类调用时要先实例化

public static void main(String[] args) {
    //调用非静态student类里面的say方法
        Student student =new Student();
        student.say();
    }

静态类是和类一起加载的，非静态类是实例化之后才存在的；

类和对象

类中只有属性和方法；
this可以调用本类的的属性；

类是抽象的需要实例化，类实例化之后会返回一个自己的对象，这个对象就是这个类的具体实例；
```
        Student xh = new Student();
        xh.name = "小明";
        System.out.println(xh.name);
```
构造器

必须和类名相同;
没有返回类型也不能写void；
每个类都会有一个无参构造方法;
使用new关键字，本质是在调用构造器；（作用）
本身用来初始化值；（作用）
一旦定义了有参构造，就必须显示无参(一旦自己写了有参构造,Java就不会赠送无参构造了);

编写构造器的快捷方法，鼠标右击选generate---Constructor

public Student() {
    }
    public Student(String name) {
        this.name = name;
    }

封装

属性私有
get，set方法可以快捷生成鼠标右击选generate---getter and setter；
get方法是获取属性，set方法给这个属性赋值；

调用方法，在main主方法中初始化一个实例，构建出一个新对象，对象.set属性名();

        Student student = new Student();
        student.setName("小苗");//set赋值
        System.out.println(student.getName());//get调用

继承

java类中只有单继承，没有多继承；
ctrl+H可以看到继承树；
继承的作用是简化代码的开发;子类可以对父类进行拓展;
对于父类和子类中重名的属性,用this和super来分辨;
super调用的是父类的，this调用的是本类的，name是方法输入的值；
在main方法运行时,先调用当前类的构造方法,但是子类的构造方法的第一行有隐藏的super()构造方法,所以先执行的还是父类的构造方法;
super在调用父类的时候，必须在构造方法的第一个；(同6)
super在父类有参构造时,super()要传参,就必须要在子类的构造方法中写super(参数)
super只能出现在子类的方法和构造方法中；
super和this不能同时调用方法；

多态

对于不同的类要写同样的方法,为了简化产生了多态;

把不同的数据类型(引用类型,也就是类)进行转型;

        Animal ani1 =new Cat();//可以把猫当成动物来看,把子类的对象赋值给父类的引用(变量)向上转型
        Animal ani2 =new Dog();
        Person1 person1 = new Person1();
        person1.feed(ani1);
        person1.feed(ani2);

把子类的对象赋值给父类的变量-->向上转型; 会屏蔽掉子类特有的(共同的方法,会用子类的)方法;
把父类的变量转化回子类的变量-->向下转型;向下转型有可能有风险,java要求必须要写强制类型转换(转换之后的数据类型)变量
```
Cat cc=(Cat)ani1;//把Animal类型转化为cat
```

方法重写

重写只和非静态有关；
子类对父类中提供的方法进行重写定义;
需要有继承关系，子类重写父类的方法；
父类和子类参数列表必须相同；
多态，父类可以new子类；
快捷方式，鼠标右击generate---->Overrde Methods；

抽象类(abstract)

抽象类是一个约束,靠子类去实现,不能new抽象类,不能创建对象;
抽象方法:使用abstract来修饰,不可以有方法体,直接用分号结束即可;
抽象类中可以写普通方法,但是抽象方法必须写在抽象类中;
子类继承抽象类,必须要先重写抽象类的方法;
非抽象子类必须要实现抽象父类的方法;
类没有多继承,只有单继承,但是接口有多继承;
抽象类存在的意义,通过抽象类可以强制的要求子类中必须有哪些方法,因为有多态性才有的作用;

接口(interface)

普通类:只有具体实现;
抽象类:具体实现(靠子类重写实现)和规范(抽象方法)都有!
接口:只有规范 ;
接口里的所有定义都是抽象的,但是会省略public abstract ;
接口需要实现类,类通过implements来实现接口;

实现了接口的类,就要重写接口的方法;

public class UserServiceImple implements UserService,TimeService {
    @Override
    public void add(String str) {
    }
    @Override
    public void dele(int num) {
    }
}

接口也不能实例化,接口中没有构造方法;

内部类

内部类就是在一个类的内部再定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了;

public class Outer {
    public void out(){
        System.out.println("这是一个外部类");
    }
    public class Inter{
        public void in(){
            System.out.println("这是一个内部类");
        }
    }
}

在另一个类 (有main主方法的类) 中调用这个A类时,要先实例化外部类,再通过外部类实例化内部类;

public static void main(String[] args) {
        Outer outer=new Outer();
        Outer.Inter inter = outer.new Inter();
        outer.out();//外部类调用外部构造的方法
        inter.in();//内部类调用内部构造的方法
    }

内部类的一个作用,内部类B可以调用A中的私有方法;

private int a = 10;//私有定义
    public void out(){
        System.out.println("这是一个外部类");
    }
    public class Inter{
        public void in(){
            System.out.println("这是一个内部类");
        }
        public void getId(){   //在内部类中定义一个方法,获取a,   在main主方法中可以直接用Inter, 调用getId然后获取定义的私有a
            System.out.println(a);
        }
    }

静态类会被先加载;
一个java类中可以有多个class文件,但是只能有一个public class;

局部内部类: 在类中直接定义class 类名{ };

public class New {
        public void method(){
            class Inner{
                public void in(){
                }
            }
        }
    }

匿名对象: 不用把实例保存到变量中

public class Applic {
    public static void main(String[] args) {
        new Apple().apple();
    }
}
class Apple{
    public void apple(){
        System.out.println("你好");
            }
}

异常(exception)
(RuntimeException) 运行时异常包括:

ArrayIndexOutOfBoundsException(数组下标越界);
NullPointerException(空指针异常);
ArithmeticException(算术异常);
MissingResourceException(丢失资源);
ClassNotFoundException(找不到类);

异常处理五个关键字

try: try{ (监控区域看是否有异常) };
catch: catch捕获异常 catch(某个异常(最高是throwable)) 变量){ }
finally(选用): 善后工作,正常捕获异常后回执行 finally{ }中的代码;
throw: 主动抛出异常,把可能出现的异常提前抛出,一般在方法中使用;
throws: 直接在方法上抛出,如果在方法中抛出不了异常,可以在方法上抛出;

捕获异常

快捷键,Ctrl+Alt+t可以自动把选中的代码包裹起来;

        int a=1;
        int b=0;
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            System.out.println("有异常已抛出");
        } finally {
            System.out.println("finally");
        }
    }

try必须和catch一起使用,finally可以用也可以不用;

throw和throws有区别,一个在方法中用,另一个在方法上用;

    public void test(int a,int b ) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();
        }
    }

throw和throws抛出异常需要try和catch捕获;