权限修饰符、接口及try关键字的理解

一.权限修饰符

概括：总是看见有不同的权限修饰符去修饰一些东西，所以近期对权限修饰符做了一些学习。

1.权限修饰符包括：public、protected、默认的、private

2.权限修饰符修饰的方法的使用范围;

	本类	同包下的子类和无关类	不同包下的子类	不同包下无关类
private	可调用	no	no	no
默认修饰符	可调用	可调用	no	no
protected	可调用	可调用	可调用	no
public	可调用	可调用	可调用	可调用

参考于：https://blog.csdn.net/yjh728/article/details/80632391
部分示例如下：

package mm.nn.com;
//这是方法类
public class QuanDemo {
    public QuanDemo Quan;

    private void Quanshow(){
        System.out.println("show");
    }

    void Quanshow2(){
        System.out.println("show2");;
    }

    protected void Quanshow3(){
        System.out.println("show3");
    }

    public void Quanshow4(){
        System.out.println("show4");
    }

    public void AllShow(){
        QuanDemo s=new QuanDemo();
        s.Quanshow();//idea未报错
        s.Quanshow2();//idea未报错
        s.Quanshow3();//idea未报错
        s.Quanshow4();//idea未报错
    }


}

package la;
//这是测试类
import mm.nn.com.QuanDemo;

public class QuanTest extends QuanDemo {
  public static void main(String[] args) {
      QuanTest a=new QuanTest();
      a.Quanshow4();
      a.Quanshow3();
     /* a.Quanshow2();  //idea报错,由默认修饰符修饰
      a.Quanshow();*/  //idea报错，由private修饰
      a.AllShow();

  }
}

二.对接口的学习

1. 接口是一个抽象，无法直接实例化，但可以像抽象类一样使用多态来间接实例化，类使用implements关键字来实现接口

2. 接口中成员变量默认是静态的常量，默认修饰符public static final

3. 接口中成员方法只能是抽象方法，默认修饰符public abstract

4. 接口无构造方法，因为接口不是一个类，构造方法是方法名和类名相同的方法，故接口无构造方法

5. 类与接口可单实现也可多实现，具体类实现接口要重写所有抽象方法，也就是接口的所有方法

package mm.nn.com;

interface Eat{
 /*public eat(); 接口方法名不能与接口名相同 */
    public void eat();//事实上是public abstract void eat();
    public static final int ohhuo=0;
    public  void jump();
}

class EatDemo{
    public void eat(Eat a){
        a.eat();
    }
}

class Cat implements Eat{  //这是具体类实现接口
    @Override
    public void eat() {
        System.out.println("猫大师爱吃鱼");
    }

    @Override
    public void jump() { //必须实现接口所有的方法
        System.out.println("喵喵使用了黑魔法让你跳高去了");
    }
}

abstract class Student implements Eat{  //抽象方法实现接口，感觉好些
    public abstract void eat();
}

public class Interface520 {
    public static void main(String[] args) {
        Eat e=new Cat(); //直接使用多态
        e.eat();
        e.jump();

        EatDemo eatDemo=new EatDemo();
        eatDemo.eat(new Cat());//匿名对象 传过去相当于 Eat a=new Cat();
        // 多说一句，这里的匿名对象用完后就被GC回收了，（GC是垃圾回收器，在疯狂Java讲义第二版学到的）

    }
}

结果是：
猫大师爱吃鱼
喵喵使用了黑魔法让你跳高去了
猫大师爱吃鱼

三.对try关键字的理解

此处以代码为例：

package la;

public class TestTry {
    public static void main(String[] args)  {
        try {
            System.out.println("try");
            int c = 5 / 1;
            System.out.println(c);
            System.out.println("heihei");
        } catch (ArithmeticException a) {
            System.out.println("catch");   //try语句有错就会执行该语句,无错则跳过
        }
        //try语句有错就会执行该语句
        finally {
            System.out.println("finally");//try语句有错无错都会执行该语句
        }

    }
}
/*结果是：
try
5
heihei
finally
*/

package la;

public class TestTry {
    public static void main(String[] args)  {
        try {
            System.out.println("try");
            int c = 5 / 0;     //此处代码是错的，但在try语句中可以存在，但是try代码块中以后的语句将不再执行
            System.out.println(c);
            System.out.println("heihei");
        } catch (ArithmeticException a) {
            System.out.println("catch");   //try语句有错就会执行该语句,无错则跳过
        }
        //try语句有错就会执行该语句
        finally {
            System.out.println("finally");//try语句有错无错都会执行该语句
        }

    }
}
/*结果是：
try
catch
finally
*/

try——catch
try——finally
try——catch——finally
catch和finally语句不能同时省略

补充:
1.对字符串的遍历：使用length（）和charAt()方法

package mm.nn.com;

public class TryDebug {
    public static void main(String[] args) {
        String name="xixixiHA";
        for(int i=0;i<name.length();i++){  //length方法只能在方法体里用应该，因为我在方法体外用报错
            System.out.print(name.charAt(i)+"  .  ");  // 拿到字符串的字符使用charAt()
        }
        System.out.println();
        System.out.println("-----------");
        NiuMa();
    }



    public static void NiuMa(){
        String name="heheiHHA";
        for(int i=0;i<name.length();i++){  //length方法
            System.out.print(name.charAt(i)+"  .  ");
        }
    }

}

输出结果：
x  .  i  .  x  .  i  .  x  .  i  .  H  .  A  .  
-----------
h  .  e  .  h  .  e  .  i  .  H  .  H  .  A  .