包 访问修饰词
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:成员变量、成员方法、构造方法。