java面向对象

面向对象

面向对象编程的本质：以类的方式组织代码，

以对象的组织(封装)数据。

引用传递和值传递

public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println("原始：" + a);
        //值传递
        Demo02.chang1(a);
        Test test=new Test();
        a=test.b;
        System.out.println(a);//0
        Demo02.change(test);
        //引用传递
        System.out.println(test.b);//20

    }
    public static void change(Test test){
        test.b=20;
    }
    public static void chang1(int a){
        a=20;
    }
}
class Test{
    int b;
}

类与对象的创建使用

package oop.demo02;
//一个项目主要有一个主方法
public class Application {
    public static void main(String[] args) {
        Student stu1=new Student();
        Student stu2=new Student();
        stu1.name="姚欢";
        stu2.name="小林";
        stu1.student();
        stu2.student();
    }
}
	-----------------------------------------------
package oop.demo02;

public class Student {
    //属性
    String name;
    int age;
    //方法
    public void student(){
        System.out.println(this.name+"在学习");
    }
}

总而言之呢，类就是一个抽象的图纸一样，比如学生类 里面的学生有名字 年龄等等 这些都是学生共有的 就把这些属性合起来构建了一个抽象的人，而对象呢 通过new出来后呢 就是一个具体的学生 类里面的属性赋值，这样就是一个不一样的学生了 。

语法：类名 对象名 =new 类名()；

---

构造器详解

package oop.demo02;
//一个项目主要有一个主方法
public class Application {
    public static void main(String[] args) {
       
        Person per=new Person();//调用的无参构造函数
        System.out.println(per.age+" "+per.name);//调用的有参构造函数
        Person per1=new Person("小明",18);
        System.out.println((per1.name + " " + per1.age));
    }
}

package oop.demo02;

public class Person {
    //属性
    String name;
    int age;
    //无参构造 系统默认生成
    Person(){}
    //有参构造
    Person(String name1,int age1){
        this.age=age1;
        this.name=name1;
    }
}
/*构造器：
1.和类名相同
2.没有返回值
作用：
1.new的本质是在调用构造函数
2.初始化对象的值
注意点：定义有参构造函数之后，如果想在使用无参构造，必须书写一个无参构造函数
快捷键：Alt+Insert 笔记本要按住Fn+Alt+Insert
鼠标移至java类要放置set和get方法的地方，同时按alt+Insert，
选择Getter和Setter即可。
如果要生成构造方法也是这样，选中Constructor即可。
* */

封装

package oop.demo03;

public class Student {
    //属性
    private String name;
   private int age;
    //方法

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {//age 指的是这个类的初始值
        if (age>120||age<0){this.age=3;}//this.age指的是这个实例化对象的属性
        else{
            this.age = age;
        }

    }
}
package oop.demo03;

public class Application {
    public static void main(String[] args) {
    Student stu=new Student();
    stu.setAge(142);
        System.out.println(stu.getAge());
        stu.setName("丫丫");
        System.out.println(stu.getName());
    }
}

封装的优点：

1. 提高代码的安全性，保护数据
2. 隐藏代码实现细节
3. 统一了接口
4. 系统可维护性增加

继承

关键字 ：extends

语法： 修饰符 class 子类 extends 父类{}

super详解

public class Teacher extends Person{
    String name="小王";
    public void test1(String name){
        //方法调用接收的
        System.out.println(name);//小心
        //类实例化的
        System.out.println(this.name);//小王
        //父类的
        System.out.println(super.name);//大王
    }

    public void print(){
        System.out.println("Teacher");
    }
    public void  tes2(){
        print();//Teacher
        this.print();//Teacher
        super.print();//Person
    }
  public class Person {
    public String name="大王";
    public  int age;
    protected int id;
    public static void say(){
        System.out.println("说了一句话");
    }
    public void print(){
        System.out.println("Person");
    }
}
    public class Application {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.test1("小心");
        teacher.tes2();
    }
}

this与super的区别：

this是指的是本类的对象的属性或方法，而super是调用父类的属性或者方法。

public class Person {
    public Person() {
        System.out.println("父类的无参构造函数执行了");
    }
}
public class Student extends Person {
    public Student() {
        //隐藏代码,调用了父类的构造函数
        //super();手写调用父类的构造器，必须要在子类的构造器的第一行
        System.out.println("子类的无参构造函数执行了");
    }
}
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
    }
}
//执行结果：
/*父类的无参构造函数执行了
子类的无参构造函数执行了*/

结论：在子类对象实例化后 会先调用父类的构造函数，再调用自身的构造函数。

super注意点：

1. super调用父类的构造函数，必须在构造函数的第一个
2. super必须只能出现在子类的方法或者构造函数中
3. super和this不能同时调用构造函数。(因为第一点，构造函数第一个位置只能有一个)

vs this：

代表的对象不同：

​ this：本身调用者这个对象

​ super：代表父类对象的应用

前提：

​ this：没有继承也可以使用

​ super：只能在继承的条件下使用

构造函数：

​ this()；本类的构造

​ super()； 父类的构造

重写

//继承
public class A extends B{
    //Override 重写
    @Override//这个是注解 ：有功能的注释
    public void test() {
       // super.test();
        System.out.println("A==>");
    }

    /*public static void test(){
        System.out.println("A==>");
    }*/
}
//重写都是方法的重写，与属性无关
public class B {
    public void test(){
        System.out.println("B==>");
    }
   /* public static void test(){
        System.out.println("B==>");
    }*/
}
public class Application {
    //静态方法和非静态的方法区别很大
    //非静态：重写
    public static void main(String[] args) {
        //静态方法：方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A  A 执行结果的区别
        //第一遍执行静态方法：父类的引用指向了子类
        B b=new A();//第二遍执行了非静态方法：子类重写了父类的方法
        b.test();//B  A

    }
}

**重写：**需要有继承关系，子类重写父类的方法。

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大，但不可以缩小；public>protected>Default>private
4. 抛出的异常：方位可以缩小，但不能扩大。ClassNotFoundException–>Exception(大)

为什么要需要重写？

1. 父类的功能，子类不一定需要或者不一定满足

重写（override）的快捷键：Alt+Insert 笔记本：Fn+Alt+insert