（1.9）java基础语法自述---类和对象

（1.9）java基础语法自述—类和对象（引用，继承，重载，构造方法，this）

一，引用

• 引用的概念，如果一个变量的类型是类类型，而非基本类型，那么该变量又叫引用。

1. 引用和指向

• new Something();

  • 代表创建了一个Something对象
  • 但也仅仅是创建了一个对象，没有办法访问它
  • 为了访问这个对象，我们使用引用来代表这个对象

• Something h = new Something();

  • h这个变量是Something类型的，又叫做引用
  • = 的意思指的是h这个引用代表右侧创建的对象
  • "代表"在面向对象里又叫做指向

2. 多个引用，一个对象

• 引用可以有多个，但对象只有一个，可通过间接指向另一个对象

  Something h1 = new Something();
  Something h2 = h1;
  Something h3 = h2;
  

3. 一个引用，多个对象

• 一个引用，同一时间，只能指向一个对象，可以添加多个引用，但前面的引用都将失去意义

二，继承

• 在类与类之间有关联时，一个类中的属性正好也符合另一个类的属性，那么就可以通过继承的方式减少代码量

  //设计一个类
  public class Books{
      String name;
  }
  
  //设计另一类继承上一个类
  public class hhh extends man(){
      public static void main(String[] args){  
      	hhh Study = new Study();
      	Study.name = "java"; // name属性，就是从Books类中继承过来的
      }
  }
  

三，方法重载

1.一般的方法的重载

• 是指方法名一样，但参数类型不一样，调用时会根据参数类型及数量，自动调用对应的方法

public class hhh extends Books{
    public void reading(){
        System.out.println(name+ "被hhh快读完了");
    }
    public void reading(Books h1){
        System.out.println(name+ "被hhh快读完了，并且还计划买"+h1.name);
    }
    
    public static void main(String[] args){
        hhh h = new hhh();
        h.name = "三体1";
        
        Books h1 = new Books();
        h1.name = "三体2";
        
        h.reading();
        h.reading(h1);
    }
    
}

2.可变数量的参数

• 上述方法在遇到数量变多时，就会变得很复杂，因此需要采用可变数量的参数

public class hhh extends Books{
    public void reading(){
        System.out.println(name+"非常精彩");
    }
    
    //可变数量参数
    public void reading(Books...h){
        for(int i = 0;i<h.length;i++){
            System.out.println(name+ "读完了，hhh的下一本书可能是"+h[i].name);
        }
    }
        
        public static void main(String[] args){
            hhh h = new hhh();
            h.name = "三体1";
            
            Books h1 = new Books();
            h1.name = "三体2";
            Books h2 = new Books();
            h2.name = "三体3";
            
            h.reading();
            h.reading(h1);
            h.reading(h1,h2);
        }
}

四，构造方法

• 通过一个类创建一个对象，这个过程称作实例化
• 实例化是通过调用构造方法实现的

1. 什么是构造方法

• 方法名和类名一样(包括大小写)
• 没有返回类型
• 实例化一个对象时，必然会调用构造方法

public class Books{
    String name;
    
    public Books(){
        System.out.println();
    }
    public static void main(String[] args){
        Books h = new Books();//实例化一个对象时，必然会调用构造方法
    }
}

2.隐式的构造方法

• 每个类会默认构造一个无参的类，如果不写，会默认提供一个

    //这个无参的构造方法，如果不写，
    //就会默认提供一个无参的构造方法
    //  public Books(){ 
    //      System.out.println("调用Books的构造方法");
    //  }	

3. 有参构造方法

• 如果一旦提供了一个有参构造方法，同时也没有显式的提供一个无参的构造方法，那么默认的无参就木有了

public class Books{
    String name;    
	//有参的构造方法
    //默认的无参的构造方法就失效了
    public Books(String bookname){ 
        name = bookname;
    }
      
    public static void main(String[] args) {
        Books h =  new Hero("三体"); 
          
        Hero teemo =  new Hero(); //无参的构造方法“木有了”
    } 

### 4，构造方法的重载

• 和普通方法一样，构造方法也可以重载

public class Books{
    String name;
    int page;
   
    public Books(String bookname){
        name = bookname;
    }	
    //带有两个参数的构造方法
    public Books(String bookname,int pagenumber){
        page = pagenumber;
    }
    
    public static void main(String[] args){
        Books h = new Books("三体");
        Books h1 = new Books("三体"，312);
    }
}

五，this

1.this即是指当前对象

public class Books{
    String name;
    public void showad(){
        System.out.println("打印this看到的虚拟地址"+this);
    }
    
    public static void main(String[] args){
        Books h = new Books;
        h.name = "三体";
        
        //直接打印对象，会显示该对象在内存中的虚拟地址
        System.out.println("打印对象的内存中的虚拟地址" + h);
        
        //调用showad，打印该对象的this，显示相同的地址
        h.showad();
    }
}

2.通过this关键字访问对象的属性

public class Books{
    String name;
    
    //属性名与参数名一样，但在方法体中，只能访问到参数的name
    public void setName1(String name){
        name = name;
    }
    //为了避免第一种中的问题，参数名不得不使用其他名
    public void setName2(String bookname){
        name = bookname;
    }
    //用this访问属性
    public void setName3(String name){
        this.name = name;//name 代表参数的name，
        				 //this.name代表属性name
    }
}

3.通过this调用其他的构造方法

• 如果要在一个构造方法中，调用另一个构造方法，可以使用this()。

public class Books{
    String name;
    int page;
    //带一个参数的构造方法
    public Books(String name){
		this.name = name;        
    }
    //带两个参数的构造方法
    public Books(String name,int page){
        this(name); //此处调用了上述的构造方法里的所有内容，特别好用
        this.page = page;
    }
    
    public static void main(String[] args){
        Books h = new Books("三体", 312);
        System.out.println(h.name);
    }
}