Java笔记—03

最新推荐文章于 2024-07-31 19:38:21 发布

lb1336

最新推荐文章于 2024-07-31 19:38:21 发布

阅读量307

点赞数

文章标签： java string equals constructor object class

本文链接：https://blog.csdn.net/lb1336/article/details/6466401

版权

/**************************************/
/*      CoreJava day3 笔记小结       */
/*         项目经理：张新钊       */
/**************************************/
/**************************************************
补充：
对象的构造过程：
   1>递归的构造父类。
   2>分配本类的空间。
   3>初始化本类的属性。
   4>调用本类的构造方法。

覆盖的定义：方法名相同，参数表相同，返回植相同，访问修饰符与父类相同或者比父类的更宽。
    而且在Java中覆盖时只能是静态对静态，非静态对非静态的。
重载的定义：方法名相同，参数表不同，返回值无要求。
遮盖的定义：父类与子类之间的属性和静态方法不存在覆盖，只有遮盖。

数组：数组也是一个对象，而且只有一个属性（length）数组的元素一旦确定就无法再改变，如果要改变只有新建一个空间
System.arraycopy(a,0,b,0,a.length);

自动类型提升：
      a=b+c;
                                                   结果：
(1)b与c中有一个Double类型                        double类型
(2)b与c中有一个Float类型                         float类型
(3)b与c中有一个Long类型                          long类型
缺省是int类型。
byte b=10;（test）
--
| b=b+20;   有自动类型提升，编译时出错。
| b+=20;    没有自动类型提升，编译没有错误。
--

类加载：
   1>创建父类对象时。Animal a=new Dog();
   2>访问父类的静态成员和方法时。
   3>创建子类对象或访问子类静态成员时。
   4>如果调用子类从父类中继承的静态方法时，只加载父类。
   5>Animal a=null;这时不会加载类，虚拟机有延迟加载，即能不加载就不加载。

局部变量的用法：
  1>定义在方法中的变量叫局部变量，而在方法之外的叫成员。
  2>局部变量应先赋值后使用。
  3>局部变量的域是定义它的代码块中，即{}之内。
  4>在一个重合范围内不允许两个局部变量发生命名冲突。

多态：

Animal a = new Dog();
引用类型：编译时类型，主观的类型。
对象类型：运行时类型，客观的类型。

引用类型和具体的对象不一致时叫做多态。
定理1：我们可以把子类对象当作父类对象，如果我们这样做了就只能去调用副类中原有定义的属性和方法。
就像我给你一个手机，你只知道这个手机可以打电话，但是这个手机可能还有很多你不知道的用途，所以你就不会去用他的新特性了。
定理2：当我们把子类对象当作父类对象来看的时候，如果子类覆盖了父类中的方法，则调用该方法时调用的是子类覆盖后的方法（静态方法除外）。
就是我们用一个父类的指针指向一个具体的子类，
用instanceof运算符来判断一个子类对象是否属于一个特定的父类对象。

参数多态和返回值多态：今天的例子。
修饰符：
（1）static用来修饰类的属性和方法，静态代码块，以及内部的静态类。
   当static修饰属性时，说明此属性已经不是实例属性，而是静态属性（类属性，属于整个类的）。与C++里面的全局变量相似。
     1>staic属性在整个类中只有一份，而实例属性每个对象都有自己的一份；
     2>static属性的访问直接通过类名去访问。可以在没有生成任何对象之前旧能访问。
     3>静态方法中只能访问本类的其他静态方法或者静态属性。
     4>静态代码块的加载先于其它的属性和方法。
（2）final主要用来修饰一个类，还有属性，方法以及方法中的局部变量。
       修饰一个类表示这个类是一个不可继承的类。
       修饰一个属性说明这个属性是一个常量。
         如果在声明一个常量时没有给该属性初始化，那吗就只能在构造方法中给此属性赋值。
       修饰一个方法表示方法是不能被子类覆盖的。
       修饰一个局部变量表示局部变量的直是不能改变的。

   （3）abstract抽象的，可以修饰一个类或者一个方法。
       用于抽象方法时，方法只有声明没有实现内容（由于在父类中没有办法给出具体的实现）。
       一旦一个类中有一个抽象方法，那吗这个类一定是一个抽象类，如果一个类没有包含任何抽象方法，但是这个类也可以声明为抽象类。
       抽象类不能被实例化，但是可以声明为一个引用。例如：Animal a=new Dog();
       如果一个子类继承了这个抽象类，那吗这个子类必须要实现父类所有的抽象方法，否则这个子类也必须为抽象类。
       abstract和final这两个修饰符不能混合使用。
希望同学们能够把下面的代码搞明白：

public class Person {
static{
  System.out.println("static code block");//在类被加载时就执行的
  biming="tangliang";//由于静态代码块最早初始化，所以可以来构造对象的静态属性．
}
static String biming;
String name;
int age;
char gender;
public Person() {
  // TODO Auto-generated constructor stub
}
public Person(String name,int age,char gender){
  this.name=name;
  this.age=age;
  this.gender=gender;
}

public void say(){
  System.out.println("Hello Person!");
  System.out.println(Math.PI);
}
public static void staticTest(){
  System.out.println("this is a static method!");
}
public static void sleep(){

  System.out.println("Person sleep 8 hours");
  staticTest();
  //System.out.println(name+" sleep 8 hours");
  //say();
}

}
public class Teacher extends Person{
String jineng;
/**
* 以下是Teacher的不同的构造方法，
*　这几个构造方法相互间叫做重载．
*/
public Teacher() {
  // TODO Auto-generated constructor stub
}
public Teacher(String jineng){
  this.jineng=jineng;
}
public Teacher(String jineng,String name,int age,char gender){
  super(name,age,gender);
  this.jineng=jineng;
}
/**
* 这个方法覆盖了Person的say()方法
*/
@Override
public void say(){
  System.out.println("Hello Teacher!");
}
/**
* 这个方法重载了Person的say()方法，由于Teacher继承了Person类，
* 所以也可以说重载了Teacher的say()方法．
*/
public void say(String name){
  System.out.println("Hello "+name);
}

public static void sleep(){
  System.out.println("Teacher sleep 6 hours");
}
public String toString(){
  return this.name+" "+this.age+" "+this.gender+" teach:"+this.jineng;

}

}
public class Test {

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  Person p1=new Teacher();
  Person p2=new Teacher("Java");
  Person p3=new Teacher("Java","zhangxz",24,'M');
  System.out.println(p1);
  System.out.println(p2);
  System.out.println(p3);
  p3.say();
  p3.sleep();    //看看这两个sleep()输出结果有什么不同
  Person.sleep();

  System.out.println(Person.biming);//静态变量的演示
  p1.biming="zhangxz";
  System.out.println(p1.biming);
  p2.biming="liuyi";
  System.out.println(p1.biming);
}

}

usb接口
接口的定义：一个接口是一个特殊的类使用interface来定义（而类使用class来定义），用来屏蔽Java中的单继承的缺陷。
      接口是一种特殊的类型，接口中的所有方法都必须为抽象方法，而且默认是公开的方法。
            接口中的所有属性都是final static的，即都是静态常量的。
            接口没有构造方法，不能用来生成对象。
            类与接口之间的代码复用关系叫做实现而不叫继承，使用implements来实现，而类的继承使用extends来实现。
            一个类可以实现多个接口，多个接口之间使用逗号隔开。
            接口之间能通过extends来实现继承关系，而且一个接口可以实现多个接口，每一个接口都将成为这个类的兼容类型
              也就是允许多态的实现。
            一个类如果实现了一个接口，就要实现一个接口中的所有方法，否则这个类就必须为抽象类。
            一个类实现了一个接口，那吗这个类和接口之间的关系也可以使用instanceof来判断一个类是否实现了一个接口。

接口的作用：
           1>实现多继承
           区分主类型和次类型，接口的引入就使得我们可以对事物的共性作一个再抽象，抽象出一个副类型。
           2>标准
           标准的制定者，使实现者和调用者分离。
           解耦合的工具。
           标准的使用者和标准的实现者通过接口实现弱耦合。

           它能够尽量减低系统的耦合度。（对象要高内聚，低耦合）独立完成一项工作的能力叫内聚性（手机的发展），

Object类的方法：

(1)clone();
作为了解知识，知道对象的拷贝分为深拷贝和浅拷贝。
(2)equals();
    普通对象实现equals()方法：自己定义两个对象是不是相同，默认的Object的实现方法是比较两个对象的地址是否相同。
    String实现equals()方法：由于String类覆盖了Object的equals方法，所以String类比较两个字符串的内容是否相同。
    Java语言规范要求equals方法具有下面的特征：
    1>自反性：对于任何非空的引用x，x.equals(x)应该返回true;
    2>对称性：对于任何引用x和y,如果x.equeals(y)返回true,那吗y.equals(x)也应该返回true.
    3>传递性：对于任何引用x,y和z，如果x.equals(y)返回true,y.equals(z)返回true，那吗x.equals(z)也应该返回true.
    4>一致性：如果x和y引用的对象没有发生改变，那吗反复调用x.equals(y)应该返回的结果相同。
    5>对于任何非空引用x,x.equals(null)应该返回false;

注意：在Java中的==和equals()的区别。