Java面向对象

类和对象

类：是具有相同属性和方法的一组对象的集合的抽象化描述；

类是对象的抽象化描述，对象是类的实例化；

创建对象

People p=new People();  //类名  对象名=new 类名();

public void show() { //无参方法
        for(int i=0;i<=4;i++) {
            System.out.println(name+"\n"+"年龄:"+age+"\n"+"班级:"+classr+"\n"+"爱好:"+hobby);    
        }
    }
    public int add(int a,int b) {  //有参方法
        return a+b;
    }

方法

有参方法

public class People{
                    //形参；代替将来会传入的参数；
    public void a(int a,int b){        //有参方法必须传参
        this.a=a;            //this代表本类对象；
    }
    public static void main(String[] args){
        People p=new People();
        p.a(10,10);    //传入的实参；
    }
}

构造方法

//没有返回值类型；修饰符与类的修饰符一致，方法名与类的名一致；
public People(){     //每个类都默认有一个无参的构造方法；

}

方法的重载

public People(){     

}
//在同一个类中，方法名相同,参数列表不同，这样的方法叫-->方法的重载;
public People(int a){     //对应不同的参数列表进行调用；

}
public People(byte b){     

}

成员变量和局部变量

成员变量名与成员变量名不能相同，局部与局部变量名不同；成员变量名和局部变量名可以相同；

变量在哪个方法中声明就可以在哪个方法中使用；

封装

private修改元素的可见性；被private修饰的元素被隐藏；

使用private封装的属性只能在本类中使用；可以写一个公共方法（public），方便其他类调用

//在setter/getter方法中进行条件或流程的合法性判断
public void setAge(int age){  //set设置值方法
    this.age=age;
}
public int getAge(){  //get获取值方法；参数
    return this.age;
}

访问修饰符

修饰符同一个类中同一个包中不同包的子类中任何地方

private 可以不可以不可以不可以

默认修饰符可以可以不可以不可以

protected 可以可以可以不可以

public 可以可以可以可以

修饰符	同一个类中	同一个包中	不同包的子类中	任何地方
private	可以	不可以	不可以	不可以
默认修饰符	可以	可以	不可以	不可以
protected	可以	可以	可以	不可以
public	可以	可以	可以	可以

protected在不同包的子类中使用必须有继承关系；

继承

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

1、子类不能继承父类中的构造方法；子类可以继承父类中没有封装的属性和方法，继承的public（修饰符）方法可以跨包，

2、任何一个类有且只有一个父类；

3、父类中所有未超出修饰范围的属性或方法都会被子类继承；

public Dog(){
    //如果父类没有无参构造方法时，必须显式调用；
    super()/super(参数);//调用父类构造器；只能存在于子类构造器的第一行代码；如果不写也会进行隐式调用；
}
public void setAge(int age){ //子类里的方法
    super.age/super.setAge(); //super.方法名或属性名；调用父类中的属性或方法；
}

方法的重写

//父类方法
public void show(){
    System.out.printin("父类show方法");
}
//子类方法
public void show(){
    System.out.println("子类show方法");
}

1、子类中，方法名，返回值类型，参数列表均与父类保持一致；

2、修饰符不严于父类；

3、子类参数列表不同于父类是重写方法的重载

4、子类的重写方法覆盖父类方法

多态

//判断是否能创建对象，关键是构造器是否运行；
//父类Animal，子类Cat
//1、继承关系的多态（类型转换）
Cat c=new Cat();
Animal a=c;  //子类转换成父类对象可直接转

Animal a=new Cat();
Cat c=(Cat)a;   //父类对象转换成子类对象需要强转

//2、方法的多态（方法重写）
Animal a=new Cat();
a.show();   //父类对象调用的是子类重写的方法；show方法是子类重写的方法；重写的show方法覆盖了父类show方法
a.catshow(); //父类对象不能调用子类特有的方法

//3、同一类中的多态（方法的重载）
Cat c=new Cat();
c.show();
c.show(10);

关键字

final关键字

1、被final修饰的变量叫常量；

2、常量被声明时必须赋值，常量的值不可更改；

3、变量名全部大写

4、被final修饰的类称为超类且不能被继承，

5、final修饰方法，则该方法不允许被重写；

static关键字

1、static修饰的属性名或方法名调用时不用创建对象，直接属性名或方法名直接调用

2、static可以修饰代码块，代码块称为静态代码块；如果有多个静态块，按顺序加载；每个静态代码块只会被执行一次

3、静态方法中不能直接调用非静态资源；调用时需要创建对象；本类中的非静态方法可以调用静态属性；

4、final 和static可同时修饰对象；

static int age;
String name;
//静态代码块在类被加载时运行，且只会在首次运行时运行一次；
static {
    System.out.println("这是静态代码块");
}
//Cat c1=new Cat();会运行静态代码块
//Cat c2=new Cat();不会再次运行

抽象类与接口

1、抽象类中可以存在抽象方法和普通方法；但抽象方法必须存在于抽象类中；

2、抽象类不能new自己的构造器创建自己的实例化对象；

3、抽象类中的抽象方法在子类中必须重写（除非子类也是抽象类）；

接口

1、接口中的方法全都是公共的抽象方法，不存在其他方法；

2、接口中的所有方法默认都是：public abstract；不能存在普通方法

3、接口中的变量都是公共的静态的常量（public static final）；

4、接口没有构造方法；

5、实现的必须是接口，一次可以实现多个接口；但继承只能继承一个；

6、接口的方法需要类实现；

public class OneClass extends Father implements Oneinterface,Oneinterface2 {
    //可实现多个接口，但只能继承一个类，可以继承的同时实现接口
}

public interface Oneinterface {

    int a=10;
    String name="小明";
    //功能定义
    void show();
}

public class OneClass implements Oneinterface{
    //实现类，普通类中所有的抽象方法必须重写
    @Override
    public void show() {
        System.out.println("重写的show方法");

    }
}

toUpperCase()//大写
toLowerCase()//小写

异常

捕获异常

1、try{}catch{}finally{}中有return（return可以在try或catch中）会先立刻执行finally，在执行return；

2、终止虚拟机（system.exit(0);）时才会让finally不会被执行；

int i=10;
try {
    return i;    //return执行前会先执行finally但return的值(基本数据类型)始终不会变，如果是引用数据类型则会改变 

        }catch (Exception e) {    

        }finally {    
            i=20;
            System.out.println("始终会被执行");
        }

//try不能单独出现，必须和catch或finally一起出现；
try {
            System.out.println("输入数字");  //出现异常后后面的语句不会继续执行
            int num1=sc.nextInt();
            System.out.println("输入第二个数字");
            int num2=sc.nextInt();
            System.out.println(num1+num2);
        }catch(InputMismatchException e) {        
            System.out.println("请正确输入数字");
        }catch (Exception e) {    //所有异常都可以转化成Exception异常

        }finally {        //finally中的语句不管异常是否被捕获都始终会被执行；
            System.out.println("始终会被执行");
        }
        System.out.println("程序结束");

抛出异常

1、throw是在方法体内抛出一个异常对象；

2、throws是在方法体前抛出任意多个异常类型；

3、类继承自Exception时throw抛出自定义异常时要先用throws抛出；

4、运行时异常（RuntimeException）可以通过throw抛出，非运行时异常必须通过throws抛出；

public void show() shrows InputMismatchException,NullPointerException,···{

}

public void show() { 
    thorw new InputMismatchException();
}

常见的异常类型

异常类型	说明
Exception	异常层次结构的父类
ArithmeticException	算术错误情形，如以零作除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	尝试访问 null 对象成员
ClassNotFoundException	不能加载所需的类
IllegalArgumentException	方法接收到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常，如把 "abc" 转换成数字