JAVA笔试基础复习（二）

1. 方法

方法参数传递，引用数据类型（传的地址）：

package com.itheima.demo1;
import java.util.Scanner;
public class demo2 {

    public static void main(String[] args) {
        int cd = add(1,2);
        eat();
        isEcenNumber(1); // 这里的1是实参
        int number = 10;
        isEcenNumber(number); // 这里的number也是实参
     }
     public static void eat(){
        study();
         System.out.println("吃饭");
     }
     public static void study(){
         System.out.println("学习");
     }
     public static void isEcenNumber(int num){ //这里的num是形式参数
        if(num%2 == 0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
     }
     // 方法重载, 同名，参数不同，和返回名无关
    public static int sum(int a, int b){
        return a + b;
    }
    public static int sum(int a, int b, int c){
        return a + b + c;
    }

     public static int add(int a, int b){
        int c = a + b;
        return c;
     }

     
}

2. 二维数据

package com.itheima.demo1;
import java.util.Scanner;
public class demo2 {

    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33};
        int[] arr2 = {44, 55, 66};
        int[] arr3 = {77, 88, 99, 100};

        int[][] arr = new int[3][3];

        arr[0] = arr1;
        arr[1] = arr2;
        arr[2] = arr3;

        System.out.println(arr[1][2]);
        System.out.println(arr[2][3]);

        // 静态初始化
        int[][] arr4 = {{11,22,33}, {44,55,66}};
        int[][] arr5 = {arr1, arr2};
    }
}

3. 封装

package com.itheima.demo2;

/*
private :可以用来修饰成员（变量/方法）
特点：只能在本类中进行方法，外界无法用.访问变量
为什么要用private？
因为我在外界用stu.age写入时，可能会写错，stu.age=-20。
如果我用set方法，里面写判断正误的语句，就不会出现上面的问题。
 */
/*
this的作用：局部变量和成员变量重名时，this可以把局部变量标识为成员变量
this可以调用本类的成员（变量/方法），局部变量和成员变量重名
 */

/*
构造方法:如果没有定义构造方法，系统会给出默认的无参构造方法
如果自己定义了构造方法，例如public Student(int age){}，
系统就不提供无参构造方法了。Student stu = new Student();就会报错。必须自己再写一个无参的

构造方法的作用：用来给对象初始化的。
 */
public class Student {
    String name;
    private int age;

    public Student(){
        System.out.println("这是我自己定义的无参构造方法");
    }
    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("这是我自己定义的有参构造方法");
    }

    public void setName(String name){
      //  name = name; // 为啥要有this,因为没有的this,这里的name都是局部变量。
        this.name = name;
    }

    public void set(int a){
        if(a >=0 && a<=120) {
            age = a;
        }else{
            System.out.println("您的年龄不符合要求");
        }

    }
    public int get(){
        return age;
    }
    public void show(){
        System.out.println(name + "..." + age);
    }
}

package com.itheima.demo2;

public class TestStudent {
    public static void main(String[] args) {
        Student stu = new Student("张三",23);
        stu.name = "张三";
        //stu.age = 23;
        stu.set(23);
        stu.show();
    }
}

IDEA有快捷键：

代码空白处右键Generate：

4. Static关键字：共享，推荐类名调用，优先于对象存在。

静态方法的特定：

 静态随着类的加载而加载，优先于对象存在（既可以用实例来调用，也可以用类名来调用）

非静态需要在创建对象之后，才可以进行使用

1. 静态的方法只能访问静态成员：

static String school;

public static coid method(){

school =  "12"; // 但是使用this.school就会报错

}

2. 非静态方法中，可以使用静态成员，也可以使用非静态成员。

3. 静态方法中，没有this关键字。（this是创建对象后，才能存在。静态存在的时候，对象可能都没创建）

----------------------------

5. 关于继承的构造方法：子类的有参构造和无参构造都会默认先进行父类的无参构造方法(这叫初始化)super()是系统默认加的，就算不写，系统也会加上。。除非手动初始化，例如下面在子类的有参构造里初始化父类的有参构造，这样就不会初始化父类的无参构造了-----------super(myName, myId)

其实我们写的每一个类都继承Object方法。。。

package com.itheima.demo3;

public class Animal {
    public String pub;
    private String name;
    private int id;
    public Animal(){
        System.out.println("无参构造");
    }
    public Animal(String myName, int myid) {
        name = myName;
        id = myid;
        System.out.println("有参构造");
    }
    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() {
        System.out.println("大家好！我是"         + id + "号" + name + ".");
    }
}

package com.itheima.demo3;

public class Mouse extends Animal {
    String pub = super.pub;
    public Mouse(){
        // 其实是默认省略super(); 使用无参构造一定会先父类
        System.out.println("w1");
    }
    public Mouse(String myName, int myid) {
        super(myName, myid);
        super.eat();
    }

    public static void main(String[] args) {
        Mouse ms = new Mouse("ms", 1); // 有参构造默认初始化父类的无参构造，但是我这里手动初始化父类的有参构造了。
        Mouse ms2 = new Mouse(); // 无参构造默认初始化父类的无参构造，

    }
}

 

5. 继承的特点

父类引用指向子类对象-----这是多态后面会说。就是Animal ms = new Mouse();

就近原则(子父类当中，出现了重名的成员变量)

package com.itheima.dem4;

public class Fu {
    int a = 10; // 没有私有化，子类是可以直接用的
}

package com.itheima.dem4;

public class Zi extends Fu{
    int a = 20;
    public void method(){
        int a = 30;
        System.out.println(a); // 会先找局部变量，没有的话再找成员变量，再没有去父类找

        // 需求1：在控制台打印本类成员变量 20
        System.out.println(this.a);

        //需求2：在控制台打印父类成员变量 10
        System.out.println(super.a);
    }
}

package com.itheima.dem4;

public class Test {

    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

super代表父类对象引用，this代表本类对象引用。

方法调用：先在子类里找，子类没有才在父类里找。

方法重写：子类里面有和父类一摸一样的方法声明；在IEAD只需要输入方法名，输个回车，就出来了，默认多个super.show()，可以删掉重写了。@Override是自动检查当前方法是不是一个正确的重写方法。

@Override
public void show() {
    super.show();
}

 方法重写的注意事项：父类中私有方法不能被重写，父类静态方法，子类必须通过静态方法进行重写（会发现@Override报错，因为静态方法不能被重写，只是现象上是重写），非静态用非静态方法重写。子类重写方法，访问权限必须大于等于父类。

 6. 抽象类

当一个父类的方法逻辑描述不清，可以用抽象表现。

抽象方法：当共性的行为（方法）抽取到父类之后，发现该方法的实现逻辑无法在父类中给出

具体明确，该方法就可以定义为抽象方法；

抽象类：如果一个类中存在抽象方法，那么该类必须声明为抽象类。

package com.itheima.demo4;

public abstract class Animal {
    public void drink(){
        System.out.println("喝水");
    }
    public abstract void eat(); // 不知道写啥，不写。前边加个abstract，然后子类必须重写
}
-----------------------------------------------------------------
package com.itheima.demo4;

public class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗吃肉");

    }
}
-------------------------------------------------------------------
package com.itheima.demo4;

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
-----------------------------------------------------------------
package com.itheima.demo4;

public class Test1Animal {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.drink();

        Cat c = new Cat();
        c.eat();
        c.drink();

     // 1. 抽象类无法创建对象   Animal a = new Animal(); X
        // 抽象类中有构造方法（当然有，不然怎么子类构造方法初始化）
        // 抽象类的子类 A：必须重写父类所有的抽象方法
                   // B：可以把自己也变成一个抽象类 （意义不大，知道就可以）
        // 抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类

    }
}

7. final方法

(1). 有时候子类莫名其妙的重写父类的方法，但是父类不希望这个方法被重写，那么我就用final定义。（最终方法，不被重写）

public final void write(){}

(2) final修饰变量，表明该变量是常量，不能被再次赋值。

final int A = 10；只能被赋值一次。

（一般的命名规则。一个单词大写，多个单词，下划线连接并大写）

final int MAX=10;  final int MAX_VALUE=20

 

(3)修饰类，不能被继承。 final class Fu{}

8. 接口：抽象类的进阶

抽象方法都需要在子类中被重写的，不然类会报错的。

当一个类中所有方法都是抽象方法的时候，我们就可以将其定义为接口。

接口也是一种引用数据类型，它比抽象类还要抽象。

接口：规则，程序的扩展性

 

 

 接口的改进：

 实现类中的方法不需要加default了。

 

9. 多态

多态的三个前提条件：（必需）

 所以记起来就是，只看成员变量结果看父类，只看成员方法的结果看子类。

那么为什么要用多态？好处和弊端

 

 如果我就想调用子类特有的方法呢？

可以向下转型：从父类的类型再转换成子类的类型（强制转换）

Fu f = new Zi();

Zi z = (Zi) f;

z.method();

向上转型，反过来。

但是会有风险：

 先用instancaof关键字判断是不是属于这个类型的

10. 接口中的静态方法

 

 11. 接口中的私有方法

接口中不存在继承的概念，都是重写方法。

关于在接口中定义非抽象方法：

（1）.  可以定义为静态方法，但是不存在重写一说。

（2 ）. 可以使用default关键字。

（3）.  JDK9中可以使用private关键字定义为私有方法。

 

关于静态方法在接口和继承的比较：