包 访问修饰词
1.包（package）
- 对类文件进行分类管理。
- 给类提供多层命名空间。包名，类名。
- 写在程序文件的第一行。
- 类名的全称是 包名.类名。
- 包也是一种封装形式。
2.如何定义包呢？
- 包在文件系统中体现就是文件夹。
- 定义项目时，必须要有包，因为会有很多很多很多重名的类，为了区分就产生了包。北京有人民大街，长春也有人民大街，当你想表述哪个人民大街的时候，就会说北京的人民大街或长春的人民大街。
- 定义包通过一个关键字package定义。
- 包名规范：所有字母都小写。
- 有了包以后，在编译的时候，可以指定任意目录，那么就可以完成java源文件和运行文件存储的分离，也是可以定义多级目录。
3.不同包之间的互相访问
- 当一个包中的类访问其他包中的类：
- 使用类的全名称，包，类。
举例：
public class Demo01{
public static void main(String[] args){
day03.Girl g=new day03.Girl();//指访问其他包中的Girl类。
}
- 使用import关键字将类导入，让导入的类对当前类可见。
举例：
import day03.girl
public class Demo01{
public static void main(String[] args){
Girl g=new Girl();
}
}
- 被访问的包中的类权限必须是public的。
- 注意：当类被public修饰，文件名和源文件名必须一致，而且在一个文件写多个类的时候只能有一个类时public修饰的，这个被public修饰的还必须和文件名一致。
- 类中的成员权限；public或者private default protected
- protected是为其他包中的子类提供的一种权限。
4.Java中常用的包（学到再深入了解）
- java.lang:包含一些Java语言的核心类，如String、Math、Integer、System、Thread,提供常用功能。
补充1：java.lang下的包不用导入。
- java.net:包含执行与网络相关的操作的类。
- java.io:包含能提供多种输入/输出功能的类。
- jva.util:包含一些实用工具类，如定义系统特性、使用与日历相关的函数。
5.权限修饰符
| public都可以用 | protected | default同一个包中 | private同一个类中 | |
| 同一个类中 | √ | √ | √ | √ |
| 同一个包不同类 | √ | √ | √ | |
| 不同包中子类 | √ | √ | ||
| 不同包中的类 | √ |
（1）同一个类中 public
package day04;
public class Person{
public int age=10;
Public void test(){
System.out.println(age);
}
}
（2）同一个包中不同类 public
package day04;
public class Demo02{
public static void main(String[] args){
int a =new Person().age;
Syetem.out.println(a);//a=10
}
}
（3）不同包子类 public
package day01;
public class Demo extends Person{
public void test(){
System.out.println(super.age);
}
}
package day01;
public class Demo01{
public static void main(String[] args){
Demo d=new Demo();
System.out.println(d.age);//10
}
}
（4）不同包中的类 public
Package day01;
Import day04.Person;
Public class Demo02{
Public static void main(String[] args){
Int c=new Person().age;
System.out.println(c);
}
}
6.内部类概述
- 将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
- 访问特点：
- 内部类可以直接访问外部类中的成员，包括私有成员。
- 外部类要访问内部类的成员必须建立内部类的对象（内部类静态成员由final修饰）
补充1：一个类里面可有成员变量、成员方法、成员内部类。
补充2：成员内部类怎么访问？即创建对象。
package day04;
public class Person{
public int age=10;
Public void test(){
System.out.println(age);
}
class A{//内部类
}
public void test4(){
class B{//一般情况就是在方法里面创建这个对象
}
new B();
}
}
public class Demo02{
//内部类测试 创建内部类对象
Person p=new Person();第二种内部类创建方法Person.A c=new Person().new A();
Person.A c=p.new A();
}
- 内部类分类
- 成员内部类：可以有访问修饰词 修饰词是任意的
- 局部内部类：定义在方法里面
- 匿名内部类
- 共性：
- 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class，但是前面冠以外部类的类名和$符号。举例：out$inner. Person$A Person$B
- 内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
补充1:匿名内部类
package day04;
public abstract class Animal{
public abstract void t();
}
Public class Demo03{
Public static void main(String[] args){
//匿名内部类
Animal a =new Animal(){// new Animal class A extends Animal
Public void t(){
Sywtem.out.println(“........”);
}
};//匿名内部类特点是现用现创建，只用一次
a.t();
}
}
- Final关键字
- final可以修饰类，方法，变量。
- final修饰的类不可以被继承。
- final修饰的方法不可以被覆盖（重写）。
- final修饰的变量是一个常量，只能被赋值一次。
- 什么时候将变量修饰成final呢？
- 通常在程序中使用一些不会变化的数据。也就是常见的一些常量值，比如3.14.这个数直接使用是可以的，但并不利于阅读，所以一般情况下，都会被该数据起个容易阅读的名字.
- final修饰的常量定义一般都有书写规范，被final修饰的常量名称，所有字母都大写。例如：double PI=3.14;
- 如果由多个单词组成每个单词间用下划线连接MY_NAME
- Final可以修饰 成员变量 不能被修改 只能赋值一次
- Final修饰方法时，不能被重写
- final修饰类
补充1：
Dog类
Package myfinal;
Public final class Dog{//验证1.2后，去掉Final，A类可以继承，接着验证3
public final static int B=10;//这一行报错，必须赋值
Public Dog(){//赋值了则不报错
//This.B=10;
}
final int a=1;//只能被赋值一次,验证4,由final修饰的量是一个常量
Public final void eat(){//验证3，然后去掉final ,验证4
//this.a=20;验证4
}
}
A类
public class A extends Dog{//当Dog类被final修饰，A类无法继承
Public void eat(){};报错//final修饰的方法不可以被重写
}
9.final修饰变量
- Final int NUM=15;
- NUM=20;//这样做不可以，final修饰意味着不可以改变
- Final修饰成员变量，必须初始化，初始化有两种
- 显示初始化 final int NUM=15;
- 构造函数初始化 final int NUM;通过构造函数初始化
- 一般定义把常量定义成final还需要定义成static的，为什么？定义成public static final int NUM=15;//全局常量，其值不能被改变
10.接口概述interface
- 定义：是抽象类和常量值的集合还有静态方法
- 从本质上将，接口是一种特殊的抽象类，这种抽象类中可以有静态方法（有。
方法的实现）和抽象方法和常量。
- 格式： interface 接口名{}
- 接口的出现将多继承通过另一种形式体现出来，即多实现。Implements
11.接口的成员
- 接口中的成员修饰符是固定的
成员变量：public static final
接口里面定义变量全是全局常量，而且上面三个关键字都可以省略，而且只能是public static final
- 成员函数:public static
接口里面定义的方法都是抽象的，而且上面的两个关键字也是可以省略的。
- 接口中的成员都是public的。
补充1：接口是一个特殊的抽象方法，只能有抽象方法 常量和静态方法。接口用interface定义接口。一个接口可以继承多个接口，一个类可以实现多个接口。
补充2：类不能继承一个接口，需要把这个类改成接口，接口可以继承接口，接口可以实现多继承。好处：解决了java单继承的限制。
补充3：一个类实现一个接口，就要实现里面所有方法。
12.继承和实现
- 类和类之间称为继承：因为该类无论是抽象的还是非抽象的，它的内部都可以定义非抽象方法，这个方法可以直接被子类使用，所以子类继承就可以应用了。
- 类与接口是实现的关系：因为接口中的方法都是抽象的，必须由子类实现才可以实例化，所以就用了这个关键字implements
- 接口与接口之间是继承关系：一个接口可以继承另一个接口，并添加新的属性和抽象方法，并且接口可以多继承。
13.单继承和多实现
- 类只能单继承，而接口可以多继承，也可以多继承。
- Java将单继承机制进行改良，通过多实现接口的形式来体现
- 为什么不支持多继承呢？
- 因为继承的多个父类中定义了相同的方法，而方法内容不同，jvm无法判断选择哪个父类的方法，有安全隐患。
- 而多实现就没有这个问题，即使是多个接口中都有相同的方法，但是它们都没有方法体。
- 多实现的好处，一个类继承另一个类的同时可以实现多个接口。
- 接口的出现打破了单继承的局限性。
14.接口的优点
- 接口是对外暴露的规则 规范
- 类与接口的关系是实现implements
- 接口的出现降低出现降低耦合性。（实现了模块化开发，定义好规则，每个人实现自己的木块，大大提高了开发开发效率）。
- 开发的规则尽量高内聚低耦合。
15.接口与抽象类
- 共性：都是不断抽取出来的抽象的概念。
- 区别1：与类的关系。
- 区别2：成员变量、成员方法、构造方法。
271
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
