禹娜day20

f2020年12月8日

包

什么是包？

包（package）是管理类和接口的，还可以解决类名冲突，类和接口需要定义在包中。

定义包

package 包名;

定义包必须是java源文件的第一行代码，包名必须小写。使用package关键字定义包。例如：package cn.itlaobing.oop

包的使用

使用包就是将包中的类导入到使用的地方，使用import关键字导入包

import java.util.Arrays;

import java.util.Scanner;

import java.util.*;

package com.itlaobing.pack1;

public class Person {
    //定义成员变量
    private String name;
    private int age;
    private String gender;
    
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void say() {
        System.out.println("自我介绍一下，姓名:"+this.name+",性别:"+this.gender+",年龄"+this.age);
    }
}

package com.itlaobing.pack2;

import com.itlaobing.pack1.Person;

public class TestPerson {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("哈哈");
        person.setGender("男 ");
        person.setAge(20);
        person.say();
    }
}

//运行结果:自我介绍一下，姓名:哈哈,性别:男 ,年龄20

系统包

java.lang.* 默认导入 String ，System，Math

java.uitl.* 工具包 Scanner ，Random，Arrays

java.io.*输入输出 File,FileInputStream

java.text.*国际化程序支持包 SimpleDateFormat

访问修饰符

public 都可以访问

protected 不同包非子类不能访问，其他都可以

默认修饰符：不同子包不能访问，其他都可以

private：只有同类才能访问

static关键字

为什么要使用static

一个类可以创建n个对象，如果n个对象中的某些数据需要n个对象共用，就需要使用static关键字修饰这些数据。static 翻译成静态

public class Peraon{
    public static int live=1;//修饰属性
    public static void sayHello(){//修饰方法
    }
    static class Student{
        String name;
    }
    static{//静态块1
    }
    static{//静态块2
    }
}

static和instances的区别

package com.itlaobing.pack1;

public class Person {
    private String name;//实例属性
    private int age;
    private static int live =1;//静态属性
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public static void sayHello() {
        System.out.println("大家好，我是人");
    }
    public static void main(String[] args) {
        Person p1=new Person("哈哈", 11);
        Person p2=new Person("嘎嘎",22);
    }
}

1.静态成员和实例成员分配的时机

静态成员是在类名首次出现时，最先分配内存的。静态属性分配在方法区中。然后调用静态块，多个静态块按照定义的顺序从上到下调用。

实例成员是在实例化时分配内存的，如果没有实例化对象，那么实例成员就没有分配内存。

2.静态成员和实例成员分配内存的次数

静态成员只分配一次内存，因此静态成员只有一份。实例成员的分配内存的次数由实例化的次数决定。每实例化一次分配一次内存。

3.静态成员和实例成员的调用规则

静态成员由类名调用，也可以由对象名调用，但还是不推荐使用对象名调用。实例对象由对象名调用，不能使用类名调用。

这种调用规则是因为：静态属于类成员，因此静态成员也能称为类成员。实例属于对象成员。

静态块的作用

静态属性可以静态初始化，因为类名首次出现时先为静态变量分配内存，然后就调用静态块。

java 中的常量

常量：值不可以更改的变量称为常量。

使用static final修饰的变量是类常量。使用final修饰变量是实例常量。

final是java的关键字。final可以修饰类，属性，方法，。修饰类时不能被继承，修饰方法时不能被子类重写，修饰属性时属性不能改值

public class Book {
    public static final String NAME;//定义类常量
    public final int price ;//定义实例常量
    public Book(int price) {
        this.price = price;//在构造函数中实例常量初始化
    }
    static {
        NAME="thinking in java";//在静态块中类常量初始化
    }
}

继承

继承是面向对象的三大特征之一。

继承可以减少代码冗余，增强扩展性，继承实质上是为了实现多态。

如何实现继承

使用extends关键字实现继承

class Father{
    
}
classs Sub extends Father{
    
}
//子类继承父类后，子类就继承了父类中的成员，导致子类无需从从创建，从而简化了子类的设计

super与this关键字

super表示父类，this表示子类

super的用法1，在子类构造函数中调用父类构造函数

public PersonnelDept(String name, String responsibility, String manager,int count) {
        super(name,responsibility,manager);
        this.count = count;
    }
注意：super调用父类构造函数时，必须写在子类构造函数的第一行

super的用法2：在子类的方法中调用父类的方法

public String toString{
    return sper.toString()+"count="+count;
}

继承中属性的初始化问题

建议谁定义的属性，由谁初始化。

继承中对象实例化的顺序问题

class A{
    int a;
    public A(int a) {
        this.a = a;
    }
}
class B extends A{
    int b;
    public B(int a,int b) {
        super(a);
        this.b = b;
    }
}
class C extends B{
    int c;
    public C(int a,int b,int c) {
        super(a,b);
        this.c = c;
    }
}
public class D {
    public static void main(String[] args) {
        C c = new C(1, 2, 3);
        c.a= 1;
    }
}
问题：main方法中创建对象c时，jvm到底创建了多少个对象？
答：当实例化一个对象时，该对象的所有父类也都被实例化了。
问题：这些被实例化的对象实例化的顺序是什么？
答：实例化顺序是从父类到子类。
问题：继承中构造函数的调用顺序是？
答：从子类到父类调用
问题：继承中构造函数的执行顺序是？
答：从父类到子类