Java入门4

面向对象2

访问修饰符

private default protected public
当前类 ✔️ ✔️ ✔️ ✔️
同一个包 ✖️ ✔️ ✔️ ✔️
不同包 ✖️ ✖️ ✔️ ✔️
无关类 ✖️ ✖️ ✖️ ✔️

参数传递

基本类型和String类型的参数传递(值传递)

​ 在进行基本类型的参数传递是,传的是参数的值,并不是参数本身!当main方法调用其他方法时,改变的只是被调用的方法的参数,与main方法内的参数无关。当方法执行结束后,所有的参数对象都会被gc自动销毁回收。

引用类型的参数传递(内存地址传递)

​ 引用数据类型非常多,大致包括:
​ 类、 接口类型、 数组类型、 枚举类型、 注解类型

​ 在进行引用类型的参数传递是,传的是引用类型的参数地址!当main方法调用其他方法时,进行操作的是卖弄传进来的地址,当方法执行结束后,并不影响更改后的参数对象。

public class Test01 {
    public static void test(int a, int[] arr){
        a = 3;
        int[] arr1 ={5,4,3,2,1};
        arr[0] = 10;
        arr = arr1;
    }

    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        int a = 0;
        test(a,arr);
        System.out.println(arr[0]);
    }
}
// 输出的结果:
// a = 0;
// arr = {10,2,3,4,5};

final常量

特点

  1. 被final修饰的类不可以被继承
  2. 被final修饰的方法被不可以被重写
  3. 被final修饰的变量不可以更改值
  4. 被final修饰的引用不可以存储其他对象的内存地址

封装

封装的目的

提供一个统一的用来设置对象属性和访问对象属性的入口

封装的要求

  1. 所有成员的变量全部私有
  2. 需要提供公有的set和get方法来提供对象成员变量的访问
  3. 需要提供一个无参构造方法(必须是public所修饰的)用来给外界创建对象

Java Bean

​ 想象一下存在这样一个箱子,其内部被分割成几个格子,每个格子用来存放特定的物品,工人取出或者放入物品后封箱,然后叫了个快递把箱子发出去了。这个箱子就是 Java Bean 啊,取出、放入就是getter、setter,物品就是属性,封箱发出就是序列化和传输。

// 举个栗子
public class Product {
    private int id;
    private String name;
    private double price;
    private double stock;
    public Product(){}

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getStock() {
        return stock;
    }

    public void setStock(double stock) {
        this.stock = stock;
    }
}

继承(Java中只支持单继承)

​ Java种的继承解决的是代码复用的问题(父类:共性抽取。子类:功能表现-功能拓展)

​ 每一个类都只能有一个父类,但是可以有许多子类

继承带来的好处

  1. 提高了代码的复用性,提高了软件开发的效率
  2. 继承的出现让类和类之间产生了关系,提供了多态的前提
// 举个一个栗子
// 新建一个父类Person
public class Person {
    public String name;
    public int age;
    public void eat(){
        System.out.println("Person => eat()");
    }
}
// 新建一个子类Student继承Person
public class Student extends Person{
    public int sno;
    public void study(){
        System.out.println("Student => study()");
    }
}
// 新建一个子类Teacher继承Person
public class Teacher extends Person{
    public int tno;
    public void teach(){
        System.out.println("Teacher => teach()");
    }
}
// 主运行类,Student实例化的对象,拥有Person类里的参数和方法
public static void main(String[] args) {
    Student student1 = new Student();
    student1.name = "student01";
    student1.sno = 10001;
    student1.eat();
    student1.study();
}

继承里的构造方法

当new了子类新对象的时候(即对子类对象进行初始化的时候),父类的构造方法也会执行,且其优先级在子类的构造方法之前,因此父类必须拥有无参构造!

(⭐)对于子类的构造方法而言,不管是子类的是有参构造方法,还是无参构造方法,都是默认调用父类的无参构造方法,所以不管父类的构造方法是否有做对象的初始化,都必须将父类的无参构造方法给显式的定义出来

super 的三种用法

  1. 在子类的构造方法种的第一行,用来访问父类的指定构造函数,如果不写,则默认访问父类的无参构造
  2. 在子类中有和父类名字相同的成员变量时,用于访问父类的指定成员变量(阿里编程规范里不允许使用)
  3. 在子类有和父类完全相同的方法的时候(方法名相同&参数的数量,顺序,类型相同),访问父类的方法

this 的三种用法

  1. 在当前子类的构造方法时,会调用自己的其他构造方法
  2. 访问自己的成员变量
  3. 访问当前类的其他方法
// 举个一个栗子
// 新建一个父类Person
public class Person {
    public String name;
    public int age;
    // 重写无参构造
    public Person(){
        System.out.println("Person => Person()");
    }
    // 重写有参构造
    public Person(String name, int age) {
        System.out.println("Person => Person(name,age)");
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("Person => eat()");
    }
}
// 新建一个子类Student继承Person
public class Student extends Person{
    public int sno;
    // 重写无参构造
    public Student(){
        super(); // 调用父类的无参构造,如果不写默认生成
        System.out.println("Student => Student()");
    }
    // 重写有参构造
    public Student(String name, int age, int sno) {
        super(name, age);// 调用父类的有参构造,如果不写默认调用无参构造,会爆红!!!!!!!
        this.sno = sno;
    }
    public void study(){
        System.out.println("Student => study()");
    }
}
// 主运行类,Student实例化的对象时,先调用父类Person的无参构造,再调用自己的构造方法
public static void main(String[] args) {
    // 通过子类的无参构造,实例化对象(父类无参构造 => 子类无参构造)
    Student student1 = new Student();
    // 通过子类的有参构造,实例化对象(父类有参构造 => 子类有参构造)
    Student student2 = new Student("Robot01",18,10001);
}

@Override注解

  1. 声明当前方法重写了父类方法

  2. 如果被标记的方法没有重写父类方法,编译则无法通过

// 新建一个父类Person
public class Person {
    public String name;
    public int age;
    public void eat(){
        System.out.println("Person => eat()");
    }
}
// 新建一个子类Student继承Person
public class Student extends Person{
    public int sno;
    public void study(){
        System.out.println("Student => study()");
    }
    @Override
    public void eat(){
        System.out.println("Student => eat()");
    }
}

抽象类(abstract)

抽象类的概念

​ 抽象类是用来捕捉子类的通用性的,它不能被实例化,只能用作子类的超类,抽象类是被用来创建子类的模板,如果父类中的方法无法满足所有子类的需求,这个方法就应该是一个抽象方法

抽象类的特点

  1. 抽象类本身不可以使用new 创建对象
  2. 必须通过子类来创建对象
  3. 子类必须覆写父类当中所有的抽象方法
  4. 抽象类中可以定义非抽象方法,用于给子类继承使用,自己无法调用
  5. 抽象类中可以定义成员变量,用于给子类继承使用,自己同样无法调用
  6. 抽象类中可以定义构造方法,用于给子类继承使用,自己同样无法使用
  7. 抽象类中可以不定义抽象方法
  8. 如果一个类继承了抽象类,却没有覆写父类的所有抽象方法,那么这个类,一定也是一个抽象类

抽象类实现

// 新建抽象类Pic,定义抽象方法area()
public abstract class Pic {
    public abstract void area();
}
// 新建类TriAngle,覆写抽象方法area()
public class TriAngle extends Pic {
    @Override
    public void area() {
        System.out.println("TriAngle => area()");
    }
}
// 新建主运行类,测试代码
public static void main(String[] args) {
    TriAngle triAngle = new TriAngle();
    triAngle.area();
}

接口(interface)(变向实现多继承)

接口的概念

​ 接口相比抽象类,抽象的更加彻底,接口只能描述子类所应当具备的方法,但是没有具体的实现,将功能的定义和实现进行分离,给程序解耦

​ 在 JDK1.7 之后接口中可以定义常量,在 JDK1.8 之后接口中可以定义带有方法体的默认方法(default)和静态方法(static),所有版本中都不可以定义普通方法,也不可以定义构造函数,成员变量

接口的特点

  1. 允许多实现(相当于多继承)
  2. 不允许定义成员变量和非抽象方法
  3. 可以定义抽象方法和静态常量
  4. 接口相当于是功能的集合
// 定义接口
public interface Brake {
    void brakeRole();
}
public interface EnvironmentProtect {
    void emission();
}
public interface Safe {
    void safeRule();
}
// 定义类Car继承接口
public class Car implements Brake,EnvironmentProtect,Safe{
    @Override
    public void brakeRole() {
        System.out.println("Brake => breakRole()");
    }

    @Override
    public void emission() {
        System.out.println("EnvironmentProtect => emission()");
    }

    @Override
    public void safeRule() {
        System.out.println("Safe => safeRule()");
    }
}

热门相关:仙城纪   第一神算:纨绔大小姐   致灿烂的你   大神你人设崩了   第一神算:纨绔大小姐