java学业帮扶--讲义

java

1.考试结构

1. 判断

2. 选择

3. 程序解答题—

4. uml图—

5. 多态接口程序设计 –

6. javaswing程序设计 —

7. 数据库连接 -

8. 连等equal

9. 一位数组转二维数组的定义方法

10. random的int float

    备注：下面是Java.util.Random()方法摘要：

    protected int next(int bits)：生成下一个伪随机数。
    boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值。
    void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。
    double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
    float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
    double nextGaussian()：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的double值，其平均值是0.0标准差是1.0。
    int nextInt()：返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
    int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。
    long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
    void setSeed(long seed)：使用单个 long 种子设置此随机数生成器的种子。

    ---

    版权声明：本文为CSDN博主「NPException」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    原文链接：https://blog.csdn.net/qq_36850813/article/details/90900744

11. 对象数组

jvm

javac——把.java—–.class——-编译

java——把在已经有。class文件的情况下直接运行该类——-运行

javadoc——生成文档

数据类型

什么时候要去强转

当精度高转低时

怎么样去强转

强转时候有什么问题呢

数组

Lesson2

1. 精度加减问题

2. 位运算效率

3. instanceof

4. charAt(int index)

5. File

6. 重载和覆盖/重写

   总结：

   override（重写）

   1、方法名、参数、返回值相同。

   2、子类方法不能缩小父类方法的访问权限。

   3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

   4、存在于父类和子类之间。

   5、方法被定义为final不能被重写。

   overload（重载）

   1、参数类型、个数、顺序至少有一个不相同。

   2、不能重载只有返回值不同的方法名。

   3、存在于父类和子类、同类中。

   版权声明：本文为CSDN博主「哥兜兜里有泡泡糖」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
   原文链接：https://blog.csdn.net/weixin_44512194/article/details/101152975

   

7. 上转型

   Human h=new Human();
   h.eat();//人类
   Animal a=new Animal();
   a.eat();//动物
   //父类-Human,子类-Animal,a-父类引用，new Human()-子类对象
   Animal a=new Human();//向上转型

   • 向上转型后的变化

   1. 关于方法：a可以调用子类和父类公用的方法（如果子类重写了父类的方法，则调用子类的方法），子类特有的方法无法调用。
   2. 关于属性: a可以调用父类的属性，不可以调用子类的属性。

   • 向上转型的作用

   1. 减少一些重复的代码
   2. 对象实例化的时候可以根据不同需求实例化不同的对象

8. 向下转型

   Father f=new Son() //先向上转型
   Son s=(Son) f;//再进行向下转型，进行强制转换，子类引用s,父类引用f

   • **向下转型的条件：**先向上转型，再向下转型。没有经过向上转型，会提示编译错误。
   • 向下转型后 的变化

   1. 关于方法：可以调用子类的所有方法，和属性，类型转为子类
   2. 关于属性：调用 的属性为子类 的属性。

   • 向下转型的作用

   1. 向上转型时 ，会遗失子类对象独有的其他方法；可以通过向下转型在重新转回。

9. 如何实现多态

10. 继承的一些问题—this， super

11. abstract、final、匿名类、内部类、 //实例变量
    static int y; //类变量————背背背

12. 类变量（static修饰的变量）和实例变量

13. 类方法

    使用方式

    实例方法可以直接访问实例变量，调用实例方法；
    实例方法可以直接访问类变量，调用类方法。但不推荐这么做，原因是不清晰，容易把类变量误认为是实例变量，把类方法误认为是实例方法（借助IDE，它会给出警告信息）；
    类方法可以直接调用类变量和类方法；
    类方法不能直接调用实例变量和实例方法；

    类方法里面不能使用“this”关键字，因为没有实例存在，“this”不知道引用哪个实例。

    版权声明：本文为CSDN博主「stepMoreForever」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    原文链接：https://blog.csdn.net/qq_33704186/article/details/90311296

14. 

15. 类方法中不能引用对象变量
    在类方法中不能使用super,this关键字
    类方法不能调用对象方法

16. 反射构造方法———

17. 组合复用依赖

18. enum Color {
      红,蓝,绿,黄,黑
    }
    public class Example3_9 {
       public static void main(String args[]) {
          for(Color a:Color.values()) {
             for(Color b:Color.values()) {
                for(Color c:Color.values()) {
                   if(a!=b&&a!=c&&b!=c) {
                      System.out.print(a+","+b+","+c+" |");
                   }
                }
             }
          }
        }
    } 
    
    

总结：

1. for(int n=0;n<b.length;n++){ //传统方式
           System.out.println(b[n]);
       }
       for(int i:a) {             //循环变量i依次取数组a的每一个元素的值（改进方式）
           System.out.println(i);
       } 
   

2. 成员变量可以没有初始值———他有默认值

3. 局部 变量必须要有初始值———他没有默认值

day4

1. (1)子类能够继承父类中声明的所有成员变量,不能直接使用private类型的成员变量.

   子类父类调用方法问题

2. class A {
       Object get() {
          return null; //返回一个空对象
       }
   }
   class B extends A {
       Integer get() {
          return new Integer(100);//返回一个Integer对象
       }
   }
   public class Example5_6 {
       public static void main(String args[]) {
          B b=new B();
          Integer t=b.get();
          System.out.println(t.intValue());   
       } 
   }
   
   
   
   

3. 子类父类重写成员变量值的问题
   class People {
       int height = 166;
       public int getHeight() {
                 return height;
       }
   }
   class ChinaPeople extends People {
       int height=180;
       public int getHeight() {
                 return height;
       }
   }
   public class TestHide1{
     public static void main(String args[]) {
         ChinaPeople zhangSan = new ChinaPeople();
         System.out.println("Height的值:"+zhangSan.getHeight());
     }
   }
   
   

4. 子类父类成员变量值的问题
   class People {
       int height = 166;
       public int getHeight() {
                 return height;
       }
   }
   class ChinaPeople extends People {
        int height=180;
   }
   public class TestHide {
     public static void main(String args[]) {
         ChinaPeople zhangSan = new ChinaPeople();
         System.out.println("Height的值:"+zhangSan.getHeight());
     }
   }
   
   

5. 权限问题以及上转型之后的权限问题
   public class Test Animal {
     public static void main (String[] args) { 
       //Animal h = new Horse(); 
       //这样定义，编译通不过，why? 
       Horse h = new Horse();   
       h.eat();//"Horse is eating."   
     }
     }
   class Animal { 
     private void eat(){  
       System.out.println ("Animal is eating.");  
     } }
   class Horse extends Animal{  
     public void eat(){    
       System.out.println ("Horse is eating.");
     }
   }
   
   

6. 上下转型变量值问题 
   上转型：本质上是父类，转型时会丢失子类的方法和属性，但是会将子类重写的方法归为自己
   上转型之后下转型：本质上是子类，进行下转型会恢复子类的方法和属性