Java期末根据提纲复习（二）

10）成员变量修饰符（各自的含义）
a. static 标识该成员变量是静态变量
b. public 公有的
c. private 私有的
d. Protected 保护变量
e. final 标识该成员变量是常量

static：
这是我一直想搞懂的一个关键字
（参考：https://www.cnblogs.com/dotgua/p/6354151.html）(讲的真的挺好）
static第一个用法就是修饰成员变量
（这是我之前没有关注的点）
文中说的看似很模糊的一点
static关键字可以修饰成员变量和方法，来让它们变成类的所属，而不是对象的所属
通俗的理解是：当将类中的成员变量用static修饰后，这个变量不再属于创建的对象拥有，而是属于这个类，所以通过这个类创建的新的成员共用这同一个成员变量。
手痒自己敲！
（敲了一下发现自己继承其实还不会）

class Student{
 String name;
 static int age;
 public String toString() {
        return "Name:" + name + ", Age:" + age;
    }
}
  class LowStudent extends Student{
  int score;
  public String toString() {
         return "Name:" + name + ", Age:" + age + ", Score:"+score;
     }
 }
public class Test1 {
 public static void main(String[] args) {
  Student s1=new Student();
  s1.name="hh";
  s1.age=10;
  Student s2=new Student();
  s2.name="hhg";
  s2.age=11;
  System.out.println(s1);
        System.out.println(s2);
        LowStudent s3=new LowStudent();
  s3.name="hhgg";
  s3.age=12;
  s3.score=56;
  System.out.println(s3);
 }
}

输出：

Name:hh, Age:11
Name:hhg, Age:11
Name:hhgg, Age:12, Score:56

s2的确把s1学生的年龄覆盖了，但是继承的子类生成的对象没有产生影响
去掉static,s1的年龄才恢复10；

static的第二个用法就是修饰成员方法
总结起来两句话
static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗
一个static修饰的类中，不能使用非static修饰的成员变量和方法

static第三个用法是静态块
(完完全全没接触过）
看完简单的理解就是static的初始化做的很早
参考文中说：当我们第一次去使用一个类时，就会触发该类的成员初始化。第二个是当我们使用了类方法，完成类的成员的初始化后，再new该类的对象时，static修饰的类成员没有再次初始化，这说明，static修饰的类成员，在程序运行过程中，只需要初始化一次即可，不会进行多次的初始化
（盲猜不考）
static的静态导包也应该不考

public：
感觉public没有static那么多用法，但是非常折磨我！
（一直没懂，当写继承的时候，子类和父类都用public修饰就会出错，可以理解是一个java文件只能有一个public类，但是很多文里说子类和父类的创建都带public关键字不是误导人？？？）
没有找到一个讲public很全面的文耶
不过考public顶多考考文件的命名？

private：
我很习惯这个文里说的，Java中的private与其理解为私有，不如理解为本类中可使用
（参考：https://blog.csdn.net/qq_41563738/article/details/78938631）
子类对父类private的变量和方法的继承。子类会继承所有父类的方法而非只继承对子类公开的方法。只是在子类中无法直接去使用，要去间接地通过getter和setter来使用
而且只要在本类的括号内，还可以用this来指向该私有成员。

Protected：
（接触的蛮少的，我觉得也不会考）
基类的 protected 成员是包内可见的，并且对子类可见；
若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。
（参考：https://www.runoob.com/w3cnote/java-protected-keyword-detailed-explanation.html）

final：
final可以修饰类，修饰变量和修饰方法
（参考：https://www.cnblogs.com/dolphin0520/p/3736238.html）
final修饰类表明该类不可被继承，实用性不大
final修饰方法也不常用，主要是防止继承类使该方法被改动
final修饰变量：
对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
文里给了这样一段代码：

public class Yesy3 {
 public static void main(String[] args) {
    String a = "hello2";  
         final String b = "hello";
         String d = "hello";
         String c = b + 2;  
         String e = d + 2;
         System.out.println(c);
         System.out.println(e);
         System.out.println((a == c));
         System.out.println((a == e));
 }
}

输出是：

hello2
hello2
true
false

这里能体现final的作用，不过我还是联想到有关String判断==和.equals的不同（参考：https://blog.csdn.net/ncuzengxiebo/article/details/82050353）
牵扯到常量池和拷贝的问题，其实不想深究下去了
（参考：https://blog.csdn.net/CYTDCHE/article/details/79191570?utm_medium=distribute.pc_relevant.none-task-blog-baidujs-3）

11）方法的修饰符（各自的含义）
a. public 公有的
b. static 静态
c. protected 保护的
d. private 私有的
e. transient 不参与序列化过程（）
f. abstract 抽象的
g. native 该方法用非java实现（）
h. fianl 此方法不能被重写
i. sysnchronized 同步的
（贴心的老师标了两个*，这是容易考还是不容易考啊？）

transient:
（看了一眼介绍，定性如果考大家都崩溃）
（参考：https://www.cnblogs.com/lanxuezaipiao/p/3369962.html）
java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

abstract：
（参考：https://www.cnblogs.com/ibelieve618/p/6410910.html）
抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类
（这说的其实有点朦胧的感觉。。。）
随便敲一个：

abstract class APerson{
 String name;
 int age;
 public abstract void Shout();//抽象方法不能有方法主体，即{}
 public abstract String toString();
}
class Student extends APerson{
 int grade;
 public void Shout(){
  System.out.println("学生叫"+name);
 }
 public String toString(){
  return "Name:" + name + ", Age:" + age + ", grade:" + grade;
 }
}
class Teacher extends APerson{
 int money;
 public void Shout(){
  System.out.println("老师叫"+name);
 }
 public String toString(){
  return "Name:" + name + ", Age:" + age + ", money:" + money;
 }
}
public class Test4 {
 public static void main(String[] args) {
  Student s1=new Student();
  s1.name="小何";
  s1.age=12;
  s1.grade=6;
  Teacher t1=new Teacher();
  t1.name="何炅";
  t1.age=40;
  t1.money=1000;
  s1.Shout();
  t1.Shout();
  System.out.println(s1);
  System.out.println(t1);
  System.out.println("Hello");
 }
}

学生叫小何
老师叫何炅
Name:小何, Age:12, grade:6
Name:何炅, Age:40, money:1000
Hello

这一句其实我没懂（没有抽象方法还设置成抽象类是为啥呢，只是为了不让实例化？）
抽象类中不一定要包含abstract方法

native：
（不会考！）

sysnchronized：能够保证在同一时刻最多只有一个线程执行该段代码
（参考：https://blog.csdn.net/qq_35580701/article/details/105044495）
与线程有关那就听天由命吧

12）方法的重载和覆盖（重写）的判断标准
a. 重载：
a) 属于同一个类中的多个成员方法
b) 这些方法具有相同的方法名称
c) 方法中的参数个数或类型不同
d) 方法的返回值不能单独作为方法重载的判断条件
b. 覆盖（重写）
a) 只存在于有继承关系的父类和子类中的方法
b) 方法都具有相同的方法名称
c) 方法中的参数个数以及类型相同
d) 方法中的返回值也必须相同

（参考：https://www.cnblogs.com/jiangao/archive/2012/02/22/2363537.html）

class A {
 protected int method1(int a, int b) { return 0; }
}
public class B extends A{ 
 public int method1(int a, int b) { return 0; } //正确，重写父类方法，可以扩大访问权限
 //private int method1(int a, int b) { return 0; } //错误，重写父类方法，不能降低了访问权限
 //private long method1(int a, int b) { return 0; } //错误，重写父类方法，不能改变返回值类型
 public short method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型
 private int method1(int a, long b) { return 0; }//正确，重载自身的方法，可以有不同的访问权限和返回值类型
}

13）public static void main(String [] args)
a. 公共权限静态不需要返回值
b. (String [] args)主函数的参数列表，字符串属性类型的参数
之前一直在纳闷(String [] args)的作用
（其实(String [] args)可以从键盘接收数据，接受的收据默认字符串类型，而且运用了main方法参数的例子，只能在jdk下运行，在Eclipse不行）

public class Test5 {
    public static void main(String[] args) {
     String s1=args[0];
     System.out.println(s1);
     double d1=Double.parseDouble(args[1]);
     System.out.println(d1);
     }
}

14）什么是异常处理Exception, 异常和循环的嵌套关系，e.toString() e.getMessage e.printStackTrace()
a. e.toString()返回当前描述字符串
b. e.getMessage 返回异常详细信息
c. e.printStackTrace()输出异常对象使用堆栈的记录
15）常见的异常种类：
算术异常类：ArithmeticException
空指针异常类：NullPointerException
类型强制转换异常：ClassCastException
数组负下标异常：NegativeArrayException
数组下标越界异常：ArrayIndexOutOfBoundsException
文件已结束异常：EOFException
文件未找到异常：FileNotFoundException
字符串转换为数字异常：NumberFormatException
操作数据库异常：SQLException
输入输出异常：IOException
方法未找到异常：NoSuchMethodException

（参考：https://blog.csdn.net/qq_29229567/article/details/80773970）

16）直接抛出和间接抛出 throw 和 throws的区别
a. 直接：在这种情况下，产生异常的方法直接通过catch语句进行处理，异常的抛出与处理局限在同一个方法的内部，不会与其他方法产生关联；
b. 间接：在由try-catch-finally语句组成的复合语句中，catch捕获由try抛出的异常。在某些情况下，可以把异常往上递交给调用该方法的方法处理，使用throws语句来实现间接抛出异常。

（参考：https://blog.csdn.net/qq_40831381/article/details/90244186）
throw用于抛出具体异常类的对象，一般用于方法体中，也可以用在代码块中，但如果代码块中抛出的异常对象是由检查时异常创建的，则必须使用try-catch或throws进行处理；
当所写的代码因不满足某些条件致使程序无法运行时可以借助throw抛出一个异常对象提醒程序员。
所以throw和throws的区别：
1.抛出的东西不同：throw抛出的是具体的异常对象，而throws抛出的是抽象的异常类；
2.使用位置不同：throw一般用在方法体中，也可用在代码块中，但是如果抛出的是检查时异常类创建的对象，则必须使用try-catch自行处理；throws只能用在方法声明括号后面；

Java期末根据提纲复习（二）

猜你喜欢