java中的oop（三）、构造器、javabean、uml类图、this、继承

!! 有get/set方法的情况基本就是说要搞个私有属性，不直接对外开放；

构造器

Person p = new Person(); 
//其中的Person();就是构造器；---造对象；

Constructor–建设者，建造者；

作用

1. 搭配new 创建类的（对象）实例；
2. 创建对象的同时，给对象的相关属性赋值；

使用说明

1. 格式：

修饰符 类名（形参）{
 
}   
-****构造器的方法名和类名一样；*******

2. 如果不写出构造器，会隐式创建和类同样修饰符的空参构造器；见代码Constructor1;
3. 一旦显示定义构造器，隐式的空参构造器将失效（废话）；
4. 构造器可以有多个- -、重载；

构造方法和 方法 没有关系；

public class Constructor1 {
    public static void main(String[] args) {
        Constructor1 c1 = new Constructor1();
        Person p1 = new Person();
        Person p2 = new Person(1);//ctrl+p;可以展示参数；
        Person p3 = new Person(true);
        System.out.println(p3);
    }
    /* 构造器1 */
    public Constructor1() {
        System.out.println(111111);
    }
}

class Person{
    /* 空参构造器 */
    public Person() {
        System.out.println("person构造器被调用！");
    }
    /* 构造器可以重载 */
    public Person(int a) {
        System.out.println("构造器可以重载!" + a);
    }
    public Person(String name) {
        System.out.println(name);
//        return name; //搞不成；搞不了返回值；
    }
    /*   这也搞不成*/
    public Person(boolean c) {
        System.out.println(c);
//        return new Person();
    }
}

匿名对象；

new Person(); //类似这样没有赋值给某个变量；

1. 只能被调用一次；
2. 常常作为实参传给方法

public class Noname {
    public static void main(String[] args) {
        /*实现接口的匿名类*/
        Q q= new Q(){
            public void m1() {
                System.out.println("interface_Q_m1");
            }
        };
        q.m1();
        new Q(){
            public void m1() {
                System.out.println("interface_Q_m1");
            }
        }.m1();

        /* 类的匿名子类 */
        new W() {
            public void m2(){
                System.out.println("class_W_m2");
            }
        }.m2();
        /* 匿名子类 */
        new W(){}.m2();
        /*相当于没有重写方法*/
        W w = new W(){};
        System.out.println(w.getClass());
        System.out.println(w.getClass().getSuperclass());
    }
}

interface Q {
    void m1();
}

class W {
    public void m2(){
        System.out.println("m2");
    }
}

对象的参数赋值顺序；

• 1、默认赋值

• 2、显示赋值； int a = 1;

• 3、构造器赋值(构造器初始化）

• 以上为对象创建过程中；（只能执行一次）

• 4、对象。方法；

• 5、对象。属性；

  JavaBean

一种对象规范？

定义：

是一种java语言写成的可重用组件；

标准：

必须有一个空参构造器；
类是公共的
有属性，且有set/get方法；

public class Bean {
    public static void main(String[] args) {

    }
}
class Customer {
    int id;

    public void setId(int i) {
        id = i;
    }

    public int getId() {
        return id;
    }
}

UML类图

统一建模语言

1、this;
2、继承性
3、super
4、多态：继承性的延续；

This

This：

在这里表示的就是对象；可以调用成员变量和方法；

场景：

• 1、声明set方法时，通过形参给对应的属性赋值；如果形参和类中属性同名；
• 2、构造器内，调用正在构建的类内的数和方法；重载多个构造器内调用封装的方法；

一般情况下会省略this.;
我就是不省略；–为了和js同步；

***** 构造器不能添加修饰符；

This(); 
//可以调用类中的其他构造器；
//必须写在构造器中的首行；
//每个构造器中最多声明一个；

class Person {
int age;
String name;

    public Person() {
        System.out.println(this.age);
        this.setAge(14);
    }
    public Person(String name) {
        this();
        this.name = name;
    }
    public Person(int age) {
        this("lucy");
        this.age = age;
    }

    public void setAge(int age) {
        age = age;
        System.out.println("age:" + age);//13
        System.out.println("this_age:" + this.age);//0
        /* 赋值失败，就近原则。形参给形参赋值，赋了个寂寞 */
    }

}

如果一个类型有多个构造器，那么类中最多有n-1个构造器；
否则会搞出死循环；

继承

• 1、从上而下：extends
• 2、自下而上：
• ruguo发现多个类相似很多，搞一个父类；

***继承都有一个is-a的关系；cat is-a animal；不能为了继承而继承；

格式：

class A{
}
class B extends A{
}
class C extends A{
}

子类获取了父类的所有属性和方法；同时在堆内存中，子类的内存中也有父类的属性和方法；

***虽然继承了，但是父类的私有属性及方法，子类中还是不能用；
Extends 延伸，扩展，延展；子类继承过来之后可以功能更强大；

默认父类;：java.lang.Object;

a.getClass().getSuperclass()
System.out.println(a.getClass().getSuperclass());//class java.lang.Object
//一个父类可以有多个子类；

public class Person {
    int age;
    String name;

    public void sleep() {
        System.out.println("sleep");
    }

    public void eat() {
        System.out.println("person_eat");
    }
    public Person() {
        System.out.println("null");
    }
    public Person(int age) {
        System.out.println("age");
    }
}

public class Student extends Person {
    int age;
    String school;
    public void eat() {
        System.out.println("sutdent_eat");
    }
    public void sleep() {
        System.out.println("student_sleep");
    }
    public void show() {
        super.eat();
        this.eat();
        eat();//省略this；
    }

    public void getAge() {
        System.out.println(age);
        System.out.println(super.age);
        System.out.println(this.age);//省略this；
    }
    public Student () {
        super(3); //null
        System.out.println("student_null");//student_null
    }
    public Student(int age) {
        this();
        System.out.println("student_age"); //father_null;student_age;
    }
}

public static void main(String[] args) {
        Student st1 = new Student();
        st1.show();
        st1.age = 10;
        st1.getAge();
        Student st2 = new Student(1);
    }

重写

Overwirte、override；

子类可以使用父类的方法，但是又不那么合适；可以考虑使用；

定义：

子类对父类继承过来的方法进行覆盖、覆写；

• 调用子类方法时，调用的就是子类重写后的方法；

权限修饰符 返回值类型 方法名（形参）[throw 异常类型] {方法体}
@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
}

规则：

• 1、方法名和形参列表必须一致；
• 2、子类重写的权限修饰符不得小于被重写的修饰符；public>protected>default;;
  • (1)特例；如果父类是private，子类则不能重写(子类也看不到了）；
• 3、返回值类型
  • (1)如果父类是void，则子类必须也是void；
  • (2)如果父类的返回值基本数据类型，则子类必须和父类相同；
  • (3)如果父类的返回值是引用类型，则子类可以和父类相同、或者返回父类的引用类型的子类类型；
• 4、子类重写之后抛出的异常，可以和父类相同，也可以是子类的类型；

一般来说子类就和父类保持一致；

Super

理解为父类的。。。；

为什么要用？

• 1、子类重写父类，子类还需要调用父类中被重写的方法；
• 2、子类继承父类以后，子类和父类定义了同名属性；—属性不存在覆盖的说法；

如何使用

super.eat();

Super可以调用的结构：

1、属性、方法、构造器；

例子：

1、方法

This不加super：依次寻找自己-父类-父类。。。。。。。。。；找到Object为止；

2、属性；

public void getAge() {
System.out.println(age);
System.out.println(super.age);
System.out.println(this.age);//省略this；
}

、、、重名尽量避开，可读性太差；

3、构造器：

子类继承父类的时候是不会继承构造器的；

public Student () {
super(); //null
System.out.println("student_null");//student_null
}

****super（）必须写在首行，和this();只能存在一个；

在构造器中：如果什么都没写，父类中默认调this();子类中默认调super();

public Student(int age) {
System.out.println("student_age"); //father_null;student_age;(默认调用父类空参构造器）
}

**如果不写空参构造器，有参构造器会覆盖空参构造器；此时子类构造器会报错；

正因为调用过父类的构造器，所以才会把父类的属性方法加载到子类的内存中供子类使用；

子类实例化的过程；

This

• 可以调用的 结构
• 1、属性、
• 2、方法、
• 3、构造器；
• 1和2中可以理解为当前对象中；
• 3中理解为当前正在创建的对象；可以调用其他重载的构造器；构造其中不声明默认调 super();

继承:

• 继承性、
• 1、好处：减少冗余；提高复用性； 提高扩展性；为多态的使用提供了前提；
• 2、局限性：单继承性。
• 多态性
• 封装性；

重写：override

1、

Super：父类的；

• 1、属性： super.xxx; ===> 子父类有权限且同名参数时使用；
• 2、方法 super.xxx(); ===》子类重写了父类方法后，需要调用父类方法时；
• 3、构造器 super(1); 子类构造器中首行必然super、this二选一；

public static void main(String[] args) {
        Student st1 = new Student();
        st1.show();
        st1.age = 10;
        st1.getAge();
        Student st2 = new Student(1);
    }