java学习2

[java]代码库
//写代码一定要保存，不然总是会报错，还查不出来，切记！当保存成为习惯就没有这个问题了
 * 面向对象：三大特点（封装，继承，多态），。这只是面向对象的，java的特点有很多，可移植，健壮，
 * 
 * 
 * 在多个对象中抽象出来的叫类
 * return 就是一个程序的结束，后面跟的逻辑都是无意义的，main是开始
 *  但程序进入main之前会先找static 然后把带有static的方法和变量放到静态池 静态池是在方法之前编译 
 * 
 * 生物：动物 植物 细胞  对于动植物来说   生物就是类   类下面有三种对象
 * 
 * 对象是类的实例   是一类事物的具体体现
 * 
 * 在类中的位置不同  
 * 成员变量：类中，方法外 
 * 局部变量：方法中 
 * 作用范围不一样  
 * 成员变量：类中 
 * 局部变量：方法中 
 * 初始化值的不同  
 * 成员变量：有默认值 
 * 局部变量：没有默认值。必须先定义，赋值，
 *  生命周期不同 
 *  成员变量：随着对象的创建而存在，随着对象的消失而消失 
 *  局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 
 * 
 * 属性：成员变量：事物的状态信息
 * 方法： 成员方法：对应事物的行为
 *  
 * 类的使用
  方法的命名：修饰符  +  返回值类型   +方法名(数据类型 ){    }
  类的命名：    修饰符  +            +方法名     (  )   {    }
  变量       ：    修饰符  +  变量名
JavaBean是类的规范 ：必须是具体的，公共的 具有无参构造();写了有参，若不写无参，默认无参就不在生效
 
java中构造方法指的是：与类名相同，无返回类型的方法，参数可以为空，也可以带参数。
比如一个 Point 类，private Point(){}这个就是无参数的构造方法。
private Dao(int x0, int y0){}这个就是带参数的构造方法。
作用：用来初始化 java 类，提供类的初始化和实例化，即可以通过new来创建对象以便调用。
如果想在实例化对象的时候就为这个属性赋值的话，可以通过有参构造实现。
 
 
public:对所有类可见  
 
protected:对同一包中的类可见、对同一包及不同包中的子类可见
 
default:对同一包中的类可见、对同一包中的子类可见
 
private:仅对类本身可见   封装 修饰成员变量被   
private修饰后的成员变量和成员方法，只在本类中才能访问
 
可见是可访问的意思，即由这些修饰符修饰的成分（类、方法、成员变量）可以被其它类
访问。对子类可见即子类可以继承。
 
这里需要注意的是protected与default，二者的区别在于不同包中的子类是否可以继承。
 
封装的构造方法
 修饰符 当前类名(参数列表){
// 方法体    
}
  
 public class Animal(){   //创建一个类
 private int num;         //定义两个私有变量
 private String name;
 public Animal(){         //构建无参
 }
 public Animal(int num,String name){  //构建有参
 this.num=num;
 this.name=nume
 }
 public int getNum(int num){
 
 return num;
 }
 public void setNum(){
 this.num=num;
 }
 public void cont(){                 //创建方法
 }                                   
  
 }
 
 
 
 public class Cat (){
 public static void main (String [] args){
 
 }
  
 public String getName(){
     //Animal类的句柄     miao是类的对象     new Animal()  :Animal类的空间
 Animal miao=new Animal();      //创建一个Animal对象   miao  需要用到无参构造
 miao.setNum(" mao111");    //私有后的赋值  不私有可直接调用   miao.num=45;
  
 //调用的三种形式：直接调用，赋值调用   输出调用
 类中 ： 方法名直接调用
 赋值调用：int sum =getSum(5,6);使用有参构造
 输出调用：syso("有返回值得方法名()");
 重载：同一个类， 方法名相同 型参不同
 重写：子类重写父类中的抽象方法，声明完全一样，增加方法体；子类重写方法权限(public 等
 )必须大于父类
  
 子类初始化，默认先初始化父类的构造super();父类构造   super父类的引用  this没有继承关系也有本类引用的意义
 object 是所有类的爸爸  this.成员变量  this.成员方法  本类的成员变量和方法
 子类重写父类的构造，实例的调用就可以用父类的构造 若想使用子类的，还有重载，再次构造一个生成器
 super()  this()  都必须在第一行
 继承只能单继承
 但clss A{
    class B extends A{
        class C extends B{
        }
    }
 }   这样多层继承就可以解决单一继承的缺点
 abstract 抽象方法  的关键字，但接口的抽象类可以省略
  
  
  
  
 
  
  
  
  
                                                       
  
  
  
 }
  
 }
 
  
  
java中四种访问修饰符 
 
 
 
Java中的四种访问修饰符：public、protected、default（无修饰符，默认）、private。
 
  
•四种修饰符可修饰的成分（类、方法、成员变量）
 
              public protected default private
          类         √       ×         √          ×
                 
   
                方法        √       √         √          √
  
               成员变量   √       √         √          √
  
 
  
•四种修饰符的访问权限
 
public:对所有类可见
 
protected:对同一包中的类可见、对同一包及不同包中的子类可见
 
default:对同一包中的类可见、对同一包中的子类可见
 
private:仅对类本身可见   
 
可见是可访问的意思，即由这些修饰符修饰的成分（类、方法、成员变量）可以被其它类访问。对子类可见即子类可以继承。
 
这里需要注意的是protected与default，二者的区别在于不同包中的子类是否可以继承。
 
访问权限 类 同一包 同一包中的子类 不同包中的子类 不同包 
public
√
  
√
  
√
  
√
  
√
  
protected
√
  
√
  
√
  
√
 × 
default
√
  
√
  
√
 × × 
private
√
 × × × × 
 
  
•例如
 
package1：ParentClass、ChildClassOne、TestOne
 
package2：ChildClassTwo、TestTwo
 
package3：TestThree
 
其中ParentClass为
 
public class ParentClass {
 
    public int a=2;
    protected int b = 3;
    int c = 4;
    private int d = 5;
 
}
 
 
　　1.对于TestOne来说，ParentClass类、a、b、c均可见，d不可见。即在TestOne中可以new一个ParentClass对象，且该对象中的a,b,c变量可操作。如下：
 
  
 
public class TestOne {
 
    public static void main(String args[]) {
 
        ParentClass obj = new ParentClass();
 
        System.out.println(obj.a);
        System.out.println(obj.b);
        System.out.println(obj.c);
//      System.out.println(obj.d);     //d 不可见
    }
}
 
 
　　2. ChildClassOne继承ParentClass且与其在同一个包中，则a、b、c均可见，d不可见。
 
public class ChildClassOne extends ParentClass{
 
    public static void main(String args[]) {
 
        ChildClassOne obj = new ChildClassOne();
 
        System.out.println(obj.a);
        System.out.println(obj.b);
        System.out.println(obj.c);
//      System.out.println(obj.d);      // d不可见
    }
}
 
 
　　3. ChildClassTwo继承ParentClass，则a、b均可见，d不可见，由于子类与ParentClass不在同一包中，故c（default类型）不可见。
 
public class ChildClassTwo extends ParentClass{
 
    public static void main(String args[]) {
        ChildClassTwo obj = new ChildClassTwo();
 
        System.out.println(obj.a);
        System.out.println(obj.b);
//      System.out.println(obj.c);    // c不可见
//      System.out.println(obj.d);    // d不可见
    }
}
 
 
　4.对于TestTwo来说，ParentClass类、a均可见，b、c、d不可见。由于TestTwo与ParentClass不在同一个包中，故只有public修饰的成分可见。
 
public class TestTwo {
 
    public static void main(String args[]) {
 
        ParentClass obj = new ParentClass();
        System.out.println(obj.a);
//      System.out.println(obj.b);     // b 不可见
//      System.out.println(obj.c);     // c 不可见
//      System.out.println(obj.d);     // d 不可见
    }
}
 
 
　
•另外值得注意的是继承父类的子类与其他类之间的可见性，取决于其他类与父类之间的可见性。
 
对于TestOne来说，ChildClassOne中a，b，c都可见，d不可见，这是由于TestOne与ParentClass在同一个包中。
 
而对于TestThree来说，ChildClassOne中只有a可见，这是由于TestThree与ParentClass在不同的包中。
 
需要注意：
 
虽然a、b对ChildClassTwo可见，TestTwo与ChildClassTwo在同一包中，
 
但对于TestTwo来说，ChildClassTwo中只有a可见，这是由于TestTwo与ParentClass在不同的包中，只有public修饰的可见。
 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * */
用户注册

用户登录

发表随想

该用户最新代码

编程随想

[java]代码库

网友评论 (发表评论)

发表评论：

评论须知：

扫码下载

输入口令后可复制整站源码
