java面向对象小结

面向对象

1.方法的调用

• 使用static修饰的方法，和类 一起加载的
• 未使用static修饰的方法，类实例化之后才存在
• 因此不能在使用static修饰的方法内调用另一个未使用static修饰的方法

2.构造器

形式

1. 和类名相同
2. 没有返回值

作用

1. 使用new关键字，本质是在调用构造器
2. 用来初始化对象的值

注意点

• 有参构造：一旦定义了，无参构造必须显示定义

3.封装

属性私有，get/set方法

4.继承

• 子类继承了父类，就会拥有父类的所有方法和属性

• public>protected[不同包、同一包、类]>default[同一包、类]>private

• 只有单继承，没有多继承

• super注意点：

  1.super调用父类的构造方法，必须在构造方法的第一个

  2.super必须只能出现在子类的方法或者构造方法中

  3.super和this不能同时调用构造方法

• this注意点

this:本身调用这个对象；super:代表父类对象的引用

this:没有继承也可以使用；super只能在继承条件下才可以使用

this();本类的构造；super();父类的构造

重写：需要有继承关系，子类重写父类的方法

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大但不能缩小public>protected>default>private

   4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException---->Exception(大)

   5.重写，子类的方法和父类必须要一致，方法体不同

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

5.静态方法和非静态方法区别很大！！！

非静态方法可以调用静态方法，静态方法不可以调用非静态方法。

静态方法：方法的调用只和左边定义的数据类型有关

public class B {
    public static void test(){
        System.out.println("B-->test()");
    }
}
public class A extends B{
    public static void test(){
        System.out.println("A-->test()");
    }
}
//测试类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();//A-->test()
        //父类的引用指向了子类
        B b = new A();
        b.test();//B-->test()
    }
}

非静态方法：重写

public class B {
    public void test(){
        System.out.println("B-->test()");
    }
}
public class A extends B{
    public void test(){
        System.out.println("A-->test()");
    }
}
//测试类
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();//A-->test()
        //子类重写了父类的方法就调用子类，没有重写就调用父类
        B b = new A();
        b.test();//A-->test()
    }
}

6.多态

• 对象执行那些方法，主要看对象左边的类型，和右边关系不大
• 父类可以指向子类，但是不能调用子类独有的方法
• 子类可以调用自己的或者继承父类的
• 多态是方法的多态，属性没有多态

7.多态存在的条件

• 有继承关系
• 子类重写父类
• 父类引用指向子类对象

A instanceof B判断B是否是A的子类,是结果为true,否则为false

Static

• 加载一个类时，先执行静态代码块–>匿名代码块–>构造方法
• 静态代码块只执行一次，在第一次加载类时

8.抽象类

• 不能new这个抽象类，只能靠子类去实现它
• 抽象类中可以写普通方法
• 抽象方法必须在抽象类中

9.接口(interface)

• 不能被实例化，接口中没有构造方法
• 所有定义的方法都是抽象的，public,abstract；属性都是常量，public static final
• 接口中只有方法的定义，都需要有实现类，可以实现多继承
• 类可以实现接口，implements,实现了接口的类就需要重写接口中的方法

10.final

• final修饰的类不能被继承
• final修饰的方法不能被子类重写
• final修饰的变量(成员变量和局部变量)，是常量，只能赋值一次，且用final修饰成员变量时，需要在定义变量的同时赋予一个初值

11.内部类

成员内部类

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println(id);
        }
    }
}

//测试类
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();//这是内部类的方法
        inner.getID();//10
    }
}

静态内部类

静态内部类不能直接访问非静态的属性

局部内部类

public class Outer{
    //局部内部类
    public void method(){
    	class Inner{
        	public void in(){
            
        	}
   		}        
    }
}

匿名内部类

public class Test{
    public static void main(String[] args){
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        UserService userService = new UserService(){
            @Override
            public void hello(){
                
            } 
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface userService{
    void hello(){
        
    }
}

12.异常处理机制

public static void main(String[] args){
    int a=1;
    int b=0;
    //假设要捕获多个异常：从小到大
    try{//try监控区域
        System.out.println(a/b);
    }catch(Error e){//catch(想要捕获的异常类型)捕获异常
     System.out.println("Error");   
    }catch(Exception e){
     System.out.println("Exception");   
    }catch(Throwable e){
     System.out.println("Throwable");   
    }finally{//处理善后工作，可以不要，常用于关闭IO，资源
      System.out.println("finally");  
    }
}

13.自定义异常

//自定义异常类
public class MyException extends Exception{
    //传递数字>10;
    private int detail;
    public MyException(int a){
        this.detail=a;
    }
    //to String
    @Override
    public String toString(){
        reeturn "MyException{"+detail+'}';
    }
}
//测试类
public class Test{
    //可能存在的异常
    static void test(int a)throws MyException{
        System.out.println("传递的参数为："+a);
        if(a>10){
            throws new MyException(a);//抛出
        }
        System.out.println("OK");
    }
    public static void main(String[] args){
        try{
            test(5);//传递的参数为：5    OK
          //test(11);//传递的参数为：11    MyException=>MyException{11}  
        }catch(MyExcepton){
            System.out.println("MyException=>"+e);
        }
    }
}