21天学通Java学习笔记-Day03

Day03:

new 的功能：

    当使用 new 时会 1，创建给定类的实例对象；2，为它分配内存；3，调用给定类定义的一个构造函数。

 

    构造函数： 是用于创建和初始化类实例的方法。构造函数初始化新对象及其变量。每个类在没有手动添加构造函数时，java都会默认有一个空的构造函数。

 

内存管理：

      当创建新的对象时，java会自动分配适当数量的内存，当对象使用完后，会指向一个null值，表示不再使用，（该对象中没有任何正在使用的或者被存储数组中的变量），java定期查询未被使用的对象，并收回这些对象占有的内存。（无用单位收集）

 

实例变量和类变量由两部分组成，句点左边是对象和类的引用，句点右边为变量。

 

类变量：是在类中定义和存储。适用于类及其所有实例对象。

 

类变量的修改会直接影响所有实例中的这个变量。

 

定义类变量的方法：在前面加上关键字 static 。

 

类变量用 ：类.（句点）类变量

实例变量用 ：实例对象.（句点）实例变量

这样便于调试。

 

格式输出方法：

    System.out.format();

    相当于 C语言中 printf();

%,d    格式化整数

%,f     格式化浮点数    %,11f  控制位数 

%n   换行

 

有返回值的方法也可以赋给变量

a.b().c()；

a对象有个b方法，b方法的返回值是一个对象，该对象中有一个c方法，可以通过这个嵌套方法调用c方法。

 

lei.bl.fangf();

fangf() 方法是在实例变量 bl 储存的对象中定义，这个实例变量本身在对象 lei 中。

 

class test01{
public static void main(String[]args){
                       a lei = new a();
                       lei.bl.fangf();
          }
}
class a{
         b bl = new b();
}
class b{
          void fangf(){
          System.out.println("hhhhhh");
           }
}

 

关于 System.out.println(); 的详解：

println() 方法是在实例变量 out  储存的对象中定义，这个实例变量本身在对象 System  中。

out 是一个 PrintStream 类型实例变量 。

 

System 中有一个 public static final PrintStream out 实例变量 

out 是一个 PrintStream 类型实例变量。

PrintStream 类中有一个 println() 方法。

 

类方法：

    类方法作用于整个类，而且不需要实例化，可以直接使用。

 

堆栈内存数据问题：

         java 的基础类型存放在 stack（栈）上，new 出对象后，只把 对象 的 reference（引用）存放在 stack（栈）中用来指向某个对象，对象本身放在 heap（堆）中。

 

       还有，调用方法时传递的参数以及在调用中创建的临时变量都保存在 stack（栈）中，速度较快。

 

        其它变量，如（static）静态变量（类变量），实例变量等都在堆中创建，速度较慢。

 

  java 中引用可以看做是一种不需要操作且受限制的指针，引用无大小，不可计算，安全，强转要小心。

 

 

对象的引用：引用是一个地址，它指明了对象的变量和方法储存的位置。

 

强制类型转换：

       1.基础类型之间的转换

       2.类型实例对象之间的转换

       3.基础类型转和对象之间的转换

 

大转小必须强制类型转换，小转大不需要强制类型转换。

 

位数多的基础类型转成位数小的基础类型需要强制转换

 

父类转子类需要强制转换

class a{ 
}
class b extends a{ 
}
class test{
 public static void main(String[]args){
            a a1 = new a();
            b b1 = new b();
            a1 = b1;     //子类转父类
         a a2 = new a();
            b b2 = new b();
            b2 = (b)a2;    // 父类转子类  需要强制类型转换
a a3 = new b();    // 子类 new 一个父类对象 
            b b3 = (b)new a();   // 父类 new 一个子类对象 需要强制类型转换
       } 
}

 

 

基础类型和对象之间的转换

class test{
 public static void main(String[]args){
                Integer a = new Integer(7801);  // Integer 对象转成 int 基础类型
                int i = a.intValue();
                System.out.println(i);
               String str = "6500";   //String 对象转成 int 基础类型
               int w = Integer.parseInt(str);
               System.out.println(w);
      }
}

 

多态：

    必须满足三个要求：1.必须有继承；2.必须有重写；3.必须有父类引用指向子类对象

多态例子代码：

public class testdt {
 public static void main(String[]args){
 BaiDog bd = new BaiDog();   //new 一个子类对象
 HeiDog hd = new HeiDog();   //new 一个子类对象
 ZhuRen zr = new ZhuRen("bai",bd);  //将子类对象传入父类引用中（父类引用指向子类对象）
 ZhuRen zz = new ZhuRen("hei",hd);  //将子类对象传入父类引用中（父类引用指向子类对象）
 zr.wan();  //调用的是被重写后的方法
 zz.wan();   //调用的是被重写后的方法
 }
}
class Dog {                                 //父类 Dog
  public void jiao(){          //父类 jiao( )方法
  System.out.println("wang,wang。。。。");
 }
}
class BaiDog extends Dog {        //继承 Dog 父类的 BaiDog 子类
 public void jiao(){            //重写父类的 jiao( )方法
  System.out.println("baidog-jiao111,baidog-jiao111......");
 }
}
class HeiDog extends Dog {        //继承 Dog 父类的 HeiDog 子类
 public void jiao(){            //重写父类的 jiao( )方法
  System.out.println("heidog-jiao222,heidog-jiao222......");
 }
}
 
 
class ZhuRen {
 String name;
 Dog d;
 ZhuRen(String name,Dog d){   //需要传入一个父类 Dog对象
  this.name=name;
  this.d=d;
 }
 public void wan(){
  d.jiao();        //调用传入对象的jiao( )方法，必须是父类中有的方法，子类重写后会显示重写后的内容，子类没有重写显示的是父类这个方法中的内容
 }
}

执行结果：baidog-jiao111,baidog-jiao111......

                  heidog-jiao222,heidog-jiao222......  //显示的是子类重写后的方法内容

 

基础类型对应的对象:

boolean     Boolean

byte            Byte

short           Short

int               Integer

long            Long

char            Character

float           Float

double       Double

 

对象封装器

自动封装和拆封：一种自动转换过程，处理表示同一类值的基本类型和对象时更容易。

 

自动封装：就是自动的将基本类型转换为对象；自动拆封则是相反。

 

如果编写语句时，本来应该出现基本类型变量的地方使用了对象（或者相反），相应的值会自动被转换，以便能够成功执行。

 

两个对象之间的比较：

== 比较的是两个对象的地址，检查是否是同一个对象 

equals()是 Object 类的方法 两个对象引用相同则返回true(与==用法一样)，如果子类重写equals( )方法用法请参考重写后的equals( )方法

 

把相同内容赋给多个 String，返回的还是同一个对象。

 

判断对象所在的类：

对象.getClass().getName();

获得对象所在类的类名。

getClass() 和 getName() 都是Object 类中定义的方法

 

判断对象是否是这个类的对象：

用 instanceof 判断，左边是对象引用，右边是类名

boolean pd = (b)对象 instanceof (a)类型；(b对象是否是一个a类型对象，返回boolean类型)