java学习第六天

复制去Google翻译翻译结果

一．Java访问权限修饰符：

访问级别

访问控制修饰符

同类

同包

子类

不同包

公开

Public

√

√

√

√

受保护

Protected

√

√

√

╳

默认

无修饰符

√

√

╳

╳

私有

Private

√

╳

╳

╳

 

1、Class类的访问权限：
public：可以供所有的类访问。
默认：默认可以称为friendly但是，java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++。默认的访问权限是包级访问权限。
即如果写了一个类没有写访问权限修饰符，那么就是默认的访问权限，同一个包下的类都可以访问到，即使可以实例化该类
（当然如果这个类不具有实例化的能力除外，比如该类没有提供public的构造函数）。

说明：
1、每个编译单元（类文件）都仅能有一个public class
2、public class的名称（包含大小写）必须和其类文件同名。
3、一个类文件(*.java)中可以不存在publicclass。
这种形式的存在的场景：如果我们在某个包内撰写一个class，仅仅是为了配合同包内的其他类工作，而且
我们不想再为了撰写说明文档给客户（不一定是现实意义的客户，可能是调用这个类的类）看而伤脑筋，而且有可能过一段时间之后
有可能会彻底改变原有的做法，并完全舍弃旧版本，以全新的版本代替。
4、class不可以是private和protected。
5、如果不希望那个任何产生某个class的对象，可以将该类得所有构造函数设置成private。但是即使这样也可以生成该类的对象，就是class的static的成员（属性和方法）可以办到。

2、类成员变量的访问权限：
public：紧接public的属性任何类都可以访问到。可以直接使用ClassName.propertyName。但是从类的封装性上来考虑将一个类的属性定义成public一般很少使用，
在定义静态常量的时候通畅会这样定义。如：public static final intPAGE_SIZE=10;
private：只有类本身内部的方法可以访问类的private属性，当然内部类也可以访问其外部类的private成员的。（属性和方法）
默认（friendly）：包级可见，同一个包内的类可以访问到这个属性，可以直接使用className.propertyName来访问，但是从类的封装性特性来说很少这样使用类的属性的。
protected：关键字所处理的是所谓“继承”的观念。对于同一包的其他类，protected＝默认，对于不同包的类，如果存在继承关系，而baseClass存在protected属性，则可以被其自继承，而不同包的其他类
则不能访问类的protected属性。

3、类的成员方法的访问权限：
其从语法角度来讲，这些访问权限控制符作用于类的方法和作用于类的属性上的效果是一样的。
public：所有类可见。
pirvate：只有同一类内部的方法可见，在有就是内部类也可以访问到。
默认（friendly）：包内可见。
protected:继承可见。

4、访问权限存在的理由
1、“让使用者无法碰触到他们不该碰触的东西。”这些东西仅供类的内部机制使用。将某些成员声明成private，对于使用者来说可以说是一种服务，
因为这样使用者可以知道哪些是他关注的哪些是不重要的，不需要关注，如此历来对于使用来说降低了对使用对象认识的难度。
2、（最终要的理由）让程序设计者可以更动class内部运作方式，而无须担心波及到客户端程序。

5、java的“访问权限修饰符”赋予classes开发者极具有价值的控制能力。身为classes开发者，如果你的任何改变可以完全不干扰你的使用者，
你便可以安心改变你的底层实现，因为客户端程序员无法访问class的这一部分。
通过今天学习访问权限的问题了解到，接口或者抽象等等策略所谓的“实现隐藏”其根本原因并不是说为了隐藏实现的代码和思路，而是降低使用者的使用难度，以及从维护角度来说可见范围的控制给程序维护带来了极大的安全性。

//这是打包命令
//打包命令一般放在文件开始的地方
package com.xiaoming;
import com.xiaoqiang.*;

public class Test {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Cat cat1=new Cat();
  System.out.println(cat1.a);
  System.out.println(cat1.getName());
 }

}

class Dog
{
 }

 

二．包：

包的作用：

1.区分相同名字的类

2.当类很多时，可以很好的管理

3.控制访问范围

包-打包命令：

package com.gnfire小写字母

包-常用包：

java.lang.* 包自动引入

 java.util.* 包工具包

 java.net.*网络开发包

java.awt.*包窗口工具包

/*
作者：gnfire
功能：说明继承的必要性
时间：20140225
*/
package com.gnfire;

public class Demo1
{
 public static void main(String[] args)
 {
  Pupil p1=new Pupil();
  p1.printName();
  
 }
}

//将学生的共有属性提出，做一个父类
class Stu
{
 //定义成员属性
 protected int age;
 public String name;
 public float fee;
    private String job;
 //编程中，如果你不希望子类继承某个属性或方法，
 //则将其声明为private
 public void printName()
 {
  System.out.println("名字是："+this.name);
 }
}
class Abc1{
 
}
//小学生类
class Pupil extends Stu
{
 //交学费
 public void pay(float fee)
 {
  this.fee=fee;
 }
}
//小学生类
class Kid extends Pupil
{
 }
//中学生类
class MiddleStu extends Stu
{
 //交学费
 public void pay(float fee)
 {
  this.fee=fee*0.8f;
 }
}

//大学生类
 class colStu extends Stu
 {
 //交学费
 public void pay(float fee)
 {
  this.fee=fee*0.1f;
 }
 }
 //出现了很多相同的属性或方法
 //class 子类 extends 父类
 //子类就自动拥有某些父类定义的属性和方法
 //public，protected可以被继承
 //继承要注意的事项：
 //1.子类最多只能继承一个父类（指直接继承）,C++中可以
 //2.Java所有类都是Object类的子类
 //3.Jdk6中202个包3777个类,接口，异常，枚举，注释和错误
 //4.在做开发的时候，强烈建议大家多查Jdk帮助文档
 //5.在使用类时，实在不知道怎么办，多问google

 

/*
作者：gnfire
功能：说明方法重载的必要性
时间：20140225
*/
package com.gnfire;

import javax.swing.*;
public class Demo2 extends JFrame{
 public static void main(String[] args){
  //Demo2 demo2=new Demo2();
  Abc abc1=new Abc();
  System.out.println(abc1.getMax(1.2f, 1.3f));
  
 }
/* public Demo2()
 {
  this.setVisible(true);
  this.setSize(200,200);
 }*/
}

class Abc
{
 //返回较大整数
 public int getMax(int i,int j)
 {
  if(i>j)
   return i;
  else return j;
 }
 
 public float getMax(float i,float j)//重载getMax()函数
 {
  if(i>j)
   return i;
  else return j;
 }
 public float getMax(double i,float j)
 {
  if(i>j)
   return (float)i;
  else return (float)j;
 }
 public float getMax(float i,double j)//顺序不同
 {
  if(i>j)
   return (float)i;
  else return (float)j;
 }
/* public double getMax(double i,float j)//仅仅是返回类型不同，不能构成重载
 {
  if(i>j)
   return (float)i;
  else return (float)j;
 }*/
/* protected double getMax(double i,float j)//仅仅是访问修饰符不同，不能构成重载
 {
  if(i>j)
   return (float)i;
  else return (float)j;
 }*/
}
//方法重载-注意事项：
//1.方法名相同
//2.方法的参数类型，个数，顺序至少有一项不同，仅仅是返回类型或访问修饰符不同，不能构成重载
//3.方法返回类型可以不同
//4.方法的修饰符可以不同

 

 

/*
作者：gnfire
功能：说明方法覆盖的必要性
时间：20140225
*/
package com.gnfire;

public class Demo3 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Cat cat1=new Cat();
  cat1.cry();
  Dog dog1=new Dog();
  dog1.cry();
 }

}

//动物类
class Animal{
 int age;
 String name;
 //都会叫
 protected void cry(){
  System.out.println("我是动物，不知道怎么叫唤！");
 }
}
class Cat extends Animal{
 //覆盖父类
 public void cry()
 {
  System.out.println("喵喵叫！");
 }
 
}
class Dog extends Animal{
 //覆盖父类
 public void cry()
 {
  System.out.println("汪汪叫！");
 }
 
}
//方法覆盖：1.子类和父类的方法名称，参数，返回类型完全一样
//2.子类方法不能缩小父类方法的访问权限