第五天：
1、package：
1)避免类的命名冲突，同包类中的类不能同名
2)类的全称：包名.类名
3)包名常常有层次结构
4)建议：包名所有字母都小写
建议： 域名反写 . 项目名称 . 模块名称 . 类名
cn.tedu . aproject . stumanager .
cn.tedu . aproject . teachmanager .
import：
1) 同包中的类可以直接访问，
不同包中的类不能直接访问，若想访问：
1.1)先import声明类 再访问类----建议
1.2)类的全称------------------太繁琐、不建议
package java.util;
class Scanner{
Scanner(Stream s){ //构造方法带参
}
int nextInt(){ // nextInt方法
}
double nextDouble(){ // nextDouble方法
}
}
import java.util.Scanner; //1.声明Scanner这个类(首字母大写为类)
Scanner scan = new Scanner(System.in) //2.创建了Scanner对象 数据类型 引用 指向 new了一个对象
构造方法带了个参数
System.out.println(“请输入年龄：”);
int age = scan.nextInt(); //3. Scanner这个类中有个nextInt方法，想访问类里的方法通过引用去点.
无参有返回值，返回值为int类型
System.out.println(“请输入价格：”);
double price = scan.nextDouble();
2、访问控制修饰符：---------------保护数据的安全
1)public：公开的，任何类都可以访问public成员
2)private：私有的，只能本类用
3)protected：受保护的，本类、派生类、同包类可以用
4)默认的：什么也不写，本类、同包类可以用 --------------java特别不建议默认权限
说明：
1)类的访问权限 只能是 public 或 默认的
2)类中成员的访问权限 如上四种都可以
数据(成员变量)私有化(private)
行为(方法)公开化(public)
总结：
数据：私有(派生类的)、受保护(超类的)
行为：公开
class Card{
private String cardId; //卡号
private String cardPwd; //密码
private double balance; //余额
public boolean payMoney(double money){ //支付金额
if(balance>=money){
balance-=money;
return true;
}else{
return false;
}
}
public boolean checkPwd(String pwd){ //验证密码
if(pwd和cardPwd相同){
return true;
}else{
return false;
}
}
------------------------------------------------
package oo.day05;
//访问控制修饰符的演示
public class Aoo {
public int a; //任何类
protected int b; //本类、派生类、同包类
int c; //本类、同包类
private int d; //本类
void show(){
a = 1;
b = 2;
c = 3;
d = 4;
}
}
class Boo{ //-------------演示private
void show(){
Aoo o = new Aoo();
o.a = 1;
o.b = 2;
o.c = 3;
//o.d = 4; //编译错误
}
}
--------------------------------------------------
package oo.day05_vis;
import oo.day05.Aoo; // 声明Aoo类（因为不在同一个包中，new Aoo对象那）
public class Coo { //------------演示同包的
void show(){
Aoo o = new Aoo();
o.a = 1;
//o.b = 2; //编译错误
//o.c = 3; //编译错误
//o.d = 4; //编译错误
}
}
class Doo extends Aoo{ //跨包继承----------演示protected
（Aoo在day05包中，Doo在day05_vis包中）
void show(){
a = 1;
b = 2;
//c = 3; //编译错误
//d = 4; //编译错误
}
}
3、final： 最终的、不可改变的-------应用率极低
1)修饰变量：变量不能被改变
2)修饰方法：方法不能被重写
3)修饰类：类不能被继承
package oo.day05;
//final的演示
public class FinalDemo {
}
//演示final修饰变量
class Eoo{
final int a = 5;
void test(){
//a = 55; //编译错误，final的变量不能被改变
}
//演示final修饰方法
class Foo{
final void show(){}
void test(){}
}
class Goo extends Foo{
//void show(){} //编译错误，final的方法不能被重写
void test(){}
}
//演示final修饰类
final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final的类不能被继承
class Joo{}
final class Koo extends Joo{} //正确，不能当老爸，但能当儿子
}
4、static： 静态的 只要是静态的，都是 类名点
1)静态变量：
1.1)由static修饰
1.2)属于类，存储在方法区中，只有一份
1.3)常常通过 类名点 来访问
1.4)何时用：所有对象所共享的数据(图片、音频、视频等)
package oo.day05;
//static的演示
public class StaticDemo {
public static void main(String[] args) {
Loo o1 = new Loo();
o1.show();
Loo o2 = new Loo();
o2.show();
Loo o3 = new Loo();
o3.show();
System.out.println(Loo.b); //常常通过 类名点 来访问
}
}
class Loo{ //演示静态变量
int a; //实例变量
static int b; //静态变量
Loo(){
a++;
b++;
}
void show(){
System.out.println("a="+a+"，b="+b);
}
}
2)静态方法： 应用率不高
2.1)由static修饰
2.2)属于类，存储在方法区中，只有一份
2.3)常常通过 类名点 来访问
2.4)静态方法中没有隐式this传递，在静态方法中不能直接访问实例成员
换言之：静态方法只能访问静态成员
2.5)何时用：方法的操作 仅与参数相关而 与对象无关
class Moo{ //演示静态方法
int a; //实例变量(对象点来访问)
static int b; //静态变量(类名点来访问)
void show(){ //普通方法 有隐式this
System.out.println(this.a);
System.out.println(Moo.b);
}
static void test(){ //没有隐式this
//静态方法没有隐式this传递，
//没有this就意味着没有对象，（this代表一个对象）
//而实例变量a是必须通过对象点来访问的，
//所以如下语句编译错误
//System.out.println(a); //编译错误
System.out.println(Moo.b); //静态变量不依赖对象，是类名点访问，没有对象，无所谓
Moo m = new Moo(); //静态方法里要调其他方法要先new对象，通过对象点调
m.show(); //本来是一个文件 类下的，没有static，可以直接调
System.out.println(m.a);//静态方法里通过对象点 来访问类中的实例变量
}
class Noo{ //演示静态方法
String name;
void show(){ //与对象有关(需要操作对象的数据)
System.out.println(name);
}
static int plus(int num1,int num2){ //与对象无关(没有操作对象的数据)
return num1+num2;
}
}
3)静态块：
3.1)由static修饰
3.2)属于类，在类被加载时自动执行，
一个类只被加载一次，所以静态块也只执行一次
执行时期：下面的 加载Loo类 到 方法区的过程中，系统会自动走 静态块
然后才new对象，才走构造方法 （静态块 发生时期 早于 构造方法）
3.3)何时用：初始化/加载静态资源(图片、音频、视频等)
图片、音频、视频---------------静态变量
给图片、音频、视频赋值---------静态块
public class StaticDemo {
public static void main(String[] args) {
Ooo o4 = new Ooo();//输出顺序：先静态块，再构造方法
Ooo o5 = new Ooo();//第二次就只走构造方法，不走静态块，因为 一个类只被加载一次
}
}
class Ooo{ //演示静态块
static {
System.out.println("静态块");
}
Ooo(){
System.out.println("构造方法"); //构造方法在new的时候 被执行
}
}
举例：
① 成员变量分两种：
实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
通过 对象点 来访问
静态变量：有static修饰，属于类的，存储在方法区中，只有一份
通过 类名点 来访问
class Aoo{
int a; //实例变量 a属于Aoo的对象的
static int b; //静态变量 b属于Aoo类的
}
②内存管理： 由JVM来管理
1)堆：new出来的对象(包括实例变量)
2)栈：局部变量(包括方法的参数)
3)方法区： .class字节码文件(包括静态变量、方法)
堆：new出来的Aoo对象，包括a
栈：c和d 方法区：Aoo.class，包括b,show()方法
class Aoo{
int a; static
int b;
void show(int c){
int d = 5;
}
}
class Loo{ //演示静态变量
int a; //实例变量
static int b; //静态变量
Loo(){
a++;
b++;
}
void show(){
System.out.println("a="+a+"，b="+b);
}
③
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
double b = scan.nextDouble(); //---------实例方法
double c = Math.random(); -----首字母大写的都是类
int[] b = Arrays.copyOf(a,6);
Arrays.sort(arr); //---------静态方法
对象点. 的都是实例方法，类名点. 的都是静态方法
600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
