实习第一天 java基础笔记

对于数组的初始化 

方式一:

int a[];

a=new int[10];

方式二：

int a[]=new int [10];

方式三：

int a[]={1,2,3,4,5};

两个函数的使用

函数一：System.arraycopy 函数

public static void main(String args[])
	{
	    int []a,b;
	    b=new int [10];
	    a=new int [10];
	    for(int i=0;i<5;i++){
	    	a[i]=i;
	    }
	    System.arraycopy(a, 0, b, 1, 3);
	    for(int i=1;i<=4;i++){
	    	System.out.println(b[i]);
	    }	   
	}
       // 输出结果是0 1 2 3

函数二：

关于Arrays.sort的使用  注意要把 java.util.* 中的包导入到里面

	    int []a={1,10,12,4,3,6};
	    Arrays.sort(a);
	    for(int i=0;i<a.length;i++)
	    	System.out.println(a[i]);
           // 输出的结果是 1 3 4 6 10 12

关于java对于方法的重载

就是在同一个类中允许同时存在一个以上的同名的方法叫做方法的重载

只要他们的  “参数个数或类型不同”  即可。

 

对象的比较 

== 用来比较两个对象的地址是否相同

equals 用来比较两个对象的内容是否相同

例子

	public static void main(String args[]){
		String str1="java";
		String str2=new String("java");
		String str3="java";
		System.out.println("str1?==str2-->>"+(str1==str2) );
		System.out.println("str1?==str3-->>"+(str1==str3) );
	}

对与字符串 赋值

String 对象一旦声明就不会轻易改变，若改变则会先断开原有对象的引用再开辟新的对象 之后再指向新的空间

用String（""）对象来进行声明的时候 是开辟了两个内存空间 然后就进行了直接赋值的形式

构造方法中

this（）

表示 无参的构造方法

例子

class Person{
    int num=100;
    Person(){
    	System.out.println("init");
    }	
    Person(int a){
    	this();
    	num=a;
    	System.out.println(num);
    }
}

public class Java{
	public static void main(String args[]){
		Person yang=new Person(100);
	}	
}

对于static 关键字的使用

static 修饰的属性能被所有的对象所共享

用static 修饰的方法为静态方法 可由类名直接调用

static 类型修饰的属性 既可以在static 方法中修饰 也可以在非static 方法中修饰

static 类型的方法不能调用非static 类型的属性

内部类的声明属性可以让外部类访问

外部类的声明属性也可以让内部类做访问

内部类的应用

内部类不仅可以在类中定义，也可以在方法中定义内部类

第六章 类的继承

之类对象在实例化中1会先去调用父类中的无参构造方法（目的是为了对继承父类的成员进行初始化选择的操作）

例子

class Person{
      private String name="ysh";
      protected void showName(){
    	  System.out.println(name+name);
      }
      public Person(){
    	  System.out.println(name);
      }
}
class Student extends Person{  //继承了 name属性 和 showName 方法
	int code=100;
	public Student(){
		System.out.println(code);
	}
	
}
public class Java{
	public static void main(String args[]){
		Student yang=new Student();  //先调用的是父类person的构造方法 然后调用的是 student自己的构造方法
		yang.showName();
	}	
}

关于类的继承的理解， 子类的构造函数 默认调用父类的无参构造函数。

                     要注意 如果对父类添加了带参数的构造函数 那么系统就默认取消了无参的构造函数，这时需要你自己手写一个无参的构造函数，否则子类初始化的时候无法使用。

然后 你可以用super 关键字来指定父类的构造函数 这样就不会出现编译错误了

注意 用super 调用程序的父类的构造方法只能放在子类构造方法的第一行

例子：

class Person {
       String name;
       int cardNume;
       public Person(String name,int cardNume){
    	   this.name=name;
    	   this.cardNume=cardNume;
       }	
}

class Student extends Person{
	  double height;
	  public Student(){
		  super("yang",200);
		  setHeight(1.88);
	  }
	  void setHeight(double height){
		  this.height=height;
	  }
}

public class Java{
	public static void main(String args[]){
		Student zzy=new Student();
	    System.out.println(zzy.name+" "+zzy.height+" "+zzy.cardNume);
	}
}

继承中 复写的应用

（1）及子类中继承了父类 而且子类中的方法和父类中的方法的名称，参数个数和类型都完全一致是，就成子类中的方法复写了父类的方法。如果子类中重复定义了 父类的属性，那么子类就复写了父类的属性。

（2）复写中子类属性或方法的权限应当 大于等于 父类中相对应的属性或方法的权限。

关于抽象类的使用~

（1）用抽象类 person 抽象出 实例student和 worker。 然后开始时抽象类附有的属性是名字 年龄和职业，然后方法是自己能说出自己的信息，实例student和worker来讲抽象方法实例化。