用户注册



邮箱:

密码:

用户登录


邮箱:

密码:
记住登录一个月忘记密码?

发表随想


还能输入:200字
云代码 - java代码库

java学习2

2019-09-04 作者:折腾不为过举报

[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修饰的可见。

 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * */


分享到:
更多

网友评论    (发表评论)


发表评论:

评论须知:

  • 1、评论每次加2分,每天上限为30;
  • 2、请文明用语,共同创建干净的技术交流环境;
  • 3、若被发现提交非法信息,评论将会被删除,并且给予扣分处理,严重者给予封号处理;
  • 4、请勿发布广告信息或其他无关评论,否则将会删除评论并扣分,严重者给予封号处理。