Java小记3（第三周）

一、参数传值机制

Java中，方法中所有参数都是“值传递”，也就是“传递的是值的副本”。也就是说，我们得到的是“原参数的复印件，而不是原件”。因此，复印件改变不会影响原件。
基本数据类型参数的传值
传递的是值的副本，副本改变不会影响原件
引用类型参数的传值
传递的是值的副本。但是引用类型指的是“对象的地址”。因此，副本和原参数都指向了同一个“地址”，改变“副本指向地址对象的值，也意味着原参数指向对象的值也发生了改变”
包机制—package的使用
包机制是Java中管理类的重要手段。开发中，我们会遇到大量同名的类，通过包可以解决类重名的问题，也可以实现对类的有效管理。包对于类，相当于文件夹对文件的作用。
！！注意：
1.通常是类的第一句非注释性语句
2.包名：域名倒着写，再加上模块名，便于内部管理类
例如：

com.sun.text;
com.oracle.test;
com.gao;
com.gao.car; //这两个包没有包含关系，是两个完全独立的包
//package的使用
package cn.sxt;
public class Test{
   public static void main(String[] args){
      System.out.println("helloworld");
      }
}
      

JDK中的主要的包

1. Java.lang：包含一些Java语言的核心类，如String、Math、Integer、System和Thread，它提供常用功能。
2. Java.awt：包含了构成抽象窗口工具集（abstract、window toolkits）的多个类，这些类被用于构建和管理运管用程序的图形用户界面（GUI）。
3. java.net：包含执行与网络相关的操作的类
4. java.io：包含能提供多种输入/输出功能的类
5. java.util：包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。
   import
   使用不同（同级）包内的class方法：

package cn.sxt.gao;

public class Test{
  public static void main(String[]args){
     cn.sxt.oo.User user= new cn.sxt.oo.User();
     }
}
//*******************************************
//通过导入类
package cn.sxt.gao;
import  cn.sxt.oo.User ;
public class Test{
  public static void main(String[]args){
     User user= new User();
     }
}
//*********************************************
import java.sql.Date;
import java.util.*;//导入该包下的所有类，会降低编译速度而不会降低运行速度
//导入同名的处理一般采用第一种：包名+类名显式调用相关类
     

静态导入

public class Test{
  public static void main(String[]args){
  System.out.println(Math.PI);
  }
}
  
  //*********************
  //静态导入
import static java.lang.Math.*;
public class Test{
  public static void main(String[]args){
  System.out.println(PI);
   }
}

面向对象的特征：

1.）继承：
关键字：extends
要点：
！！！1.java中只有单继承即只有一个直接父类
2.java中类没有多继承，接口有多继承
3.子类继承父类可以得到父类全部的属性和方法（除了父类的构造方法），但不一定可以直接访问（父类的私有属性和方法）
4.如果定义一个类时，没有调用extends，则它的父类为：java.lang.Object。
2）封装
3） 多态
instanceof运算符
二元运算符，左侧是对象，右侧是类；当对象是右侧类或子类所创建对象时，返回值为true，否则返回false；
方法的重写override
子类重写父类的方法
子类通过重写父类的方法，可以用自身的行为替换父类的行为。
方法重写的要点:
1.“==”:方法名、形参列表相同；
2.“<=”:返回值类型和声明类型，子类小于等于父类
3.“>=”:访问权限，子类大于等于父类
例

public class TestOverride{
 public static void main(String[]args){
 Horse h=new Horse();
 h.run();
 }
}
class Vehicle{
  public void run(){
    System.out.println("run");
    }
  public void stop(){
      System.out.println("stop");
     }
   public Person whoispag(){
   return new Person();
   }
}
class Horse extends Vehicle{
public void run(){   //重写1."==":方法名、形参列表相同；
    System.out.println("runrunrun");
    }

public Student whoispag(){      //2.“<=”:返回值类型和声明类型，子类小于等于父类(sudent是person子类)
   return new Student();
   }                           //属于重写
   
public Object whoispag(){  //object是person的父类大于原返回值类型不属于重写
 return new Student();
   }   
}

Object类
object类是所有java类的根基类，也就意味着所有的java对象都拥有object类的属性和方法。
object中的toString方法

public String toString(){
  return getClass().getName()+"@"+Integer.toHexString(hashCode());
  }
//当然toString()可以重写
public String toString(){
  return 语句
  }

equals方法的重写
“==”代表比较双方是否相同。如果是基本类型则表示值相同，如果是引用类型则表示地址相同即是同一对象
equals方法：
public boolean equals（Object obj）方法，提供定义“对象内容相等”的逻辑。

public class TestEquals{
  public static void main(String[]args){
    Object obj;
    String str;
    User u1=new User(1000,"hu","123456");
    User u2=new User(1000,"huhu","123456");
    System.out.println(u1==u2);
    System.out.println(u1.equals(u2));
    String str1=new String("cc");
    String str2=new String("cc");
    System.out.println(str1==str2);   //false:str1和str2是两个不同的对象
    System.out.println( str1.equals( str2));  //true  内容相同
    
    
    }

  class User{
    int id;
    String name;
    String pwd;
    
    public User(int id,String name,String pwd){
    super();
    this.id=id;
    this.name=name;
    this.pwd=pwd;
    }

@Override
public boolean equals(Object obj){  //重写
  if(this==obj)
  return true;
  if(obj==null)
  return false;
  if(getClass()!=obj.getClass())
  return false;
  User other=(User)obj;
  if (id!=other.id)
  return false;
 return true;
} 
}

super
是直接父类对象的引用，可以通过super来访问父类中被子类覆盖的方法和属性。

public class Testsuper{
 public static void main(String[]args){
   new ChildClass().f();
   }
}
class FatherClass{
  public int value;

  public void f(){
  value =100;
  System.out.println(value);
  }
}
class ChildClass extends FatherClass{
  public int value;
  public void f(){
  super.f();  //调用父类对象的普通方法
  value=200;
  System.out.println(value);
  System.out.println(super.value);  //调用父类对象的成员变量
  }
}

结果：
100
200
100

  

---

使用ctrl+t查看类的继承层次结构