类和对象

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

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

创建对象

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	可以	可以	可以	可以

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" 转换成数字