——- android培训、java培训、期待与您交流! ———-
包:其实就是文件夹。包也是对我们java文件进行分类管理。
格式:
package 包名;
package com;
//这句话的意思就是说,我们的编译之后的class文件在我们 --- 当前java文件所在文件夹/com文件夹 --- 下边
package 一级目录.二级目录.包名;
package cn.itcast;
意思是说:编译之后的class文件,在我们--- 当前java文件所在文件夹/cn文件夹/itcast文件夹 ---下边
window操作系统,使用\来表示路径的层级。
java中的包使用“.”来表示层级关系。
包的定义:
位置:只能放在类的上边,而且是文件有效代码的第一行。
数量:只能有一个。可以没有。
有效代码:指的就是能够编译,或者需要编译的代码都是有效代码。
带包类的编译和运行:
编译:有两种方式。
手动型:
1.正常的编译。
2.根据包名创建文件夹(手动创建文件夹)。
3.把第1步编译之后的class文件放入,我们第2步创建的文件夹中。
自动型:
1.命令:
javac -d . 文件名.java
运行:
运行时要使用类的全名称。
我们要是用命令:“java 包名.类名” 来运行我们的代码
类的全名称:类的全名称指的是:“包名.类名”
包的命名:
百度:www.baidu.com 包名:com.baidu
package cn.itcast;
class PackageDemo {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
带包类的编译:
1.有了包后,即使在同一个文件夹下,也需要先将别的包编译一下,然后才能使用。
不同包之间的相互访问:类必须是公共的public
1.把我们的类名,全都改成类的全名称。
2.把我们需要使用的类,导入到我们本类中。(导包)
导包:使用import关键字。
格式:import 包名.类名; //导入的是一个类,而不是文件夹。
位置:必须方法package下边,但是类的上边。
import com.Demo;
导包的注意事项:
1.导包的语句必须是方法package下边,class的上边。
2.导入包的语句可以有多个。
3.import 包名.*; //这句话会导入“包名”这个文件夹下的所有的类
但是不建议使用。
4.导入的是类,而不是文件夹。
package cn;
import com.Demo;
//import java.util.Scanner;
//import java.util.Random;
import java.util.*;
class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Random r = new Random();
/*
com.Demo d = new com.Demo();
d.method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
new com.Demo().method();
*/
new Demo().method();
new Demo().method();
new Demo().method();
}
}
package com;
class QuanXianTest {
public static void main(String[] args) {
QuanXianDemo qxd = new QuanXianDemo();
//访问公共的
qxd.publicMethod();
//访问默认的
qxd.defaultMethod();
//访问受保护的
qxd.protectedMethod();
//访问私有的
qxd.privateMethod();
}
}
java中的权限修饰符:
public:公共的。
protected:受保护的
默认的:就是什么都不写。
private:私有的
public:同一个类中,同一包不同类没有关系的俩个类,同一包有继承关系的不同类,不同包有继承关系的不同类,不同包没有关系的俩个类
protected:同一个类中,同一包不同类没有关系的俩个类,同一包有继承关系的不同类,不同包有继承关系的不同类,
默认的:同一个类中,同一包不同类没有关系的俩个类,同一包有继承关系的不同类,
private:同一个类中,
public:公共的。任何地方都可以访问。
protected:受保护的。同一包下或者有继承关系就可以访问。
默认的:就是什么都不写。同一包下可以访问。
private:私有的,只有在同一个类中可以访问。
public > protected > 默认 > private
package com;
public class QuanXianDemo {
//公共的
public void publicMethod(){
System.out.println("公共的");
}
//默认
void defaultMethod(){
System.out.println("默认");
}
//受保护的
protected void protectedMethod(){
System.out.println("受保护的");
}
//私有的
private void privateMethod(){
System.out.println("私有的");
}
public static void main(String[] args) {
QuanXianDemo qxd = new QuanXianDemo();
//访问公共的
qxd.publicMethod();
//访问默认的
qxd.defaultMethod();
//访问受保护的
qxd.protectedMethod();
//访问私有的
qxd.privateMethod();
}
}
package com;
class QuanXianTest1 extends QuanXianDemo {
public static void main(String[] args) {
QuanXianTest1 qxd = new QuanXianTest1();
//访问公共的
qxd.publicMethod();
//访问默认的
qxd.defaultMethod();
//访问受保护的
qxd.protectedMethod();
//访问私有的
qxd.privateMethod();
}
}
内部类:就是放在类内部的类。
成员内部类:就是放在类内部,方法外部的类。
局部内部类:放在方法内部的类。
成员内部类:
位置:类内部,方法外部。
使用:怎么创建对象。
1.在外部类的方法中创建成员内部类的对象。
2.在外部去创建内部类的对象:
格式:
Outer.Inner i = new Outer().new Inner();
外部类.内部类 对象名 = new 外部类().new 内部类();
//外部类
class Outer {
public void method(){
//在方法中创建成员内部类的对象。
Inner i = new Inner();
//使用对象来调用方法
i.fun();
}
//成员内部类
class Inner {
public void fun(){
System.out.println("Inner-fun");
}
}
}
//成员内部类测试
class InnerTest {
public static void main(String[] args) {
//Inner i = new Inner();
//创建一个外部类对象
Outer o= new Outer();
o.method();
//Inner 是 Outer的Inner
Outer.Inner i = new Outer().new Inner();
i.fun();
}
}
人类的内部类:
成员内部类可以被private修饰,而且我们一般都把我们成员内部类私有。
一般我们需要通过我们自己的方法来操作我们的成员内部类。
static也可以修饰成员内部类。当静态修饰成员内部类时,该成员内部类有一个特殊的称呼,叫做静态内部类。
静态内部类就是让我们内部类用起来比较方便而已。
Person.Heart ph = new Person.Heart();
静态内部类的创建对象的方法:
格式:
Person.Heart ph = new Person.Heart();
外部类.内部类 对象名 = new 外部类.内部类();
静态内部类权限修饰符一般为public。
class Person {
//医治方法
public void care(){
}
//心脏类
public static class Heart {
}
static int num = 10; //Person.num
}
class PersonDemo {
public static void main(String[] args) {
//创建对象
//Person.Heart ph = new Person().new Heart();
//Person.Heart ph = new Person.Heart();
}
}
//外部类
class Outer {
public int num = 10;
//内部类
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(Outer.this.num); //10
}
}
}
public class OuterTest {
public static void main(String[] args) {
//创建内部类对象
Outer.Inner i = new Outer().new Inner();
i.show();
}
}
局部内部类: 在方法内部。
创建对象:
局部内部类创建对象,只能在方法内部创建。
注意事项:
1.创建对象语句不能在内部类定义的前边。
2.局部内部类在访问局部变量时有限制。
访问:
外部类的成员变量:没问题
内部类的成员变量:没问题
内部类的局部变量: 没问题
外部类的局部变量: 必须是final修饰的变量。(1.7及之前是这样,1.8之后可以访问非final的变量。)
//外部类
class Outer {
//int num = 10;
public void method(){
final int num = 30;
//内部类
class Inner{
//int num = 11;
public void test(){
//int num = 20;
System.out.println("Inner-test"+ num);
}
}
//创建局部内部类对象
Inner i = new Inner();
//调用方法
i.test();
}
}
class JuBuInnerDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
匿名内部类:就是没有名字的内部类
格式:
继承式匿名内部类:new 类名(){ … };
要求,写之前,必须先有一个父类。
接口式匿名内部类: new 接口(){ … };
要求,写之前,必须先有一个接口。
匿名内部类,本质上是一个对象。是我们父类或者父接口的对象。
//外部类
class Outer {
public void method(){
//匿名内部类
Animal a = new Animal(){
//重写Animal的say方法
public void say(){
System.out.println("Animal-say");
}
public void test(){
System.out.println("Inner-test");
}
};
a.say();
}
}
abstract class Animal {
public abstract void say();
}
class NiMingDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
总结:
包:就是文件夹
包的定义:
格式:
package 包名;
package 一级目录.二级目录.包名;
带包类的编译和运行:
自动型编译:
javac -d . 文件名.java
运行:
java 包名.类名;
导包:
格式:
import 包名.类;
注意:
1.导入的是类,而不是文件夹。
2.在包的定义的下边,类的上边,可以有多个。
3.import 包名.*; 导入该文件夹下的所有的类。(不建议使用)
权限修饰符:
public:公共的,所以地方都可以使用。
protected:受保护的,继承的。同一包下或者有继承关系的子类可以访问。
默认:就是什么都不写。同一个包下可以访问。
private:私有的,只有类的内部可以访问。
内部类:
就是放在类内部类的。
成员内部类:放在类中方法之外,就是类的一种特殊的成员,可以看作是特殊的成员变量或成员方法。
1.可以被priavte修饰。还可以被static修饰。
2.可以在外部类的方法中创建内部类的对象。(最常用的做法)
3.可以在外部去创建内部类的对象。
创建对象格式:外部类.内部类 对象名 = new 外部类().new 内部类();
被static修饰的成员内部类叫做:静态内部类。
创建对象格式:外部类.内部类 对象名 = new 外部类.内部类();
局部内部类:
就是放在方法中的内部类。
只能在局部内部类所在的方法中创建对象。
注意:
1.创建对象的代码要放在类的定义的下边。
2.访问外部类的局部变量时,只能访问final修饰的变量(1.8之后已经优化)
匿名内部类:
就是没有名字的局部内部类。
格式:
继承时匿名内部类:new 父类(){ …… }; //本质上匿名内部类是父类或父接口的一个子类对象。
要求,使用之前必须先有一个父类。
接口时匿名内部类: new 接口(){ …… };
要求,使用之前必须先有一个接口。