认识java组合，import,final ,this

用法

• import
• private,public,default,protected一些属性
• this
• final
• 组合

import

(不同包之间的数据引用)

package com.object.test;
import com.object.test2.User;//import 另外一个包
//import com.object.test2.*引入包内所有的内容，但是会降低编译速度，但是不会降低运行速度

//这两个都有date
import java.sql.Date;
import  java.util.*;

import  static com.object.test2.Student.school;//倒入静态属性，注意static

import static java.lang.Math.*;
import  static  java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
       // com.object.test2.User u = new com.object.test2.User();不import
        User u= new User();//import
        u.login();
       java.util.Date d =new java.util.Date();//因为两个import 里都有date,所有需要make specify
        System.out.println(PI);//正常需要写成Math.PI,这个有点像c 中的define
        System.out.println(random());
        System.out.println(school);
    }
}

---

属性

private,public,default,protected

private 只属于该类

default 属于该类和同一个包

protected 属于该类和同一个包和子类，但是不同一个包就只属于它的子类

该子类只能通过方法引用super的protected的属性，不能用对象的protected属性

public 权限最大

this

• 创建好的对象的地址

下面的例子通过在各个情况下显示出它们这几种属性的区别

//在同一个类下，所有属性都可用
package com.object.test2;

public class User11 {
    private int idprivate=001;
    int agedefault=19;
    public int numpublic=100;
    protected String nameprotected="no";
    public void login(){
        System.out.println("login");
        System.out.println(this.numpublic);
        System.out.println(this.nameprotected);
        System.out.println(this.agedefault);
        System.out.println(this.idprivate);
}
}

//相同的包下，private不可用，其他都可用
package com.object.test2;
public class Student {
    public static void main(String[] args) {
        User11 h= new User11();
        // System.out.println(h.id);error ,PRIVATE

        System.out.println(h.agedefault);//default
        System.out.println(h.nameprotected);//protected
 }

package com.object.test;
//不同的包下，public可用，protected在一定条件下可用
import com.object.test2.User11;

public class Student1 {
    public static void main(String[] args) {
        User11 m= new User11();
        //System.out.println(m.agedefault);error ,default 不可跨包
        System.out.println(m.numpublic);//public
        //System.out.println(m.nameprotected);protected,不可跨包，除非是子类
    }
}
//students2 是user11的子类，它可以访问parent 的protected，
// 但是它不能访问parent对象的protected
//super 只能在子类中被调用，代表直接parent
class Student2 extends User11{
    public void test(){
        System.out.println(super.nameprotected);
    }

---

final

修饰变量，赋了初值，就不能更改了，跟c中的define很像

修饰方法，不可被子类重写，但是可以被继承

修饰类，不能被继承

override

在子类中重新写方法

package com.object.inherite;

public class Person extends Object{
    String name ;
    int height;

    public void rest() {
        System.out.println("rest a little");
    }
    public  Person getFriend(){
        return  new Person();
    }
}
//extends 继承super 的所有属性和方法，但是不包括构造
class Student extends Person{
    int scores;
    public  void study(){
        System.out.println("study"+this.name);
    }
    //重新定义方法，就会覆盖继承来的方法 == override
    public  void rest(){
        System.out.println("sleep.");
    }
    @Override
    public String toString(){
        return  name+"want a new friend";
    }
    Student(String name,int height,int scores){
        this.name= name;
        this.height = height;
        this.scores = scores;
    }
   Student(){

   }
    public static void main(String[] args) {
        Student s = new Student("jess",170,90);
        System.out.println(s instanceof Person);
        //instanceof 表示实例，意思是s属于person,return true or false
        System.out.println(s instanceof Student);
        s.rest();
        System.out.println(s.getFriend());
        System.out.println(s.toString());
    }
}
class Aminal1 {
 public final void shout(){
System.out.println("walwalwal");
}

}
//它可以继承shout()方法，但是不可以修改-》override
class Cat extends Aminal1{
public void shout(){
System.out.println("walwalwal");
}

}
/*final 加了任何class 就不能继承了*/ class Dog1{
    public /*final 这里修饰方法，它可以继承，不可以override*/  void  shout(){
        System.out.println("wowowo");
    }

}
//这个final修修饰类，不可被继承
final class  tiger{
    
}
//这个会报错，因为tiger 是final定义的，它没有子类，丁克
//class  dongbeitiger extends tiger{}  

class Taidi1 extends Dog{
    //OVERRIDE
    public  void shout(){
        System.out.println("hohoho");
    }

}

---

组合

package com.object.inherite;

public class Aminal {
    public static void main(String[] args) {
        Taidi  t = new Taidi();
       t.dog.shout();
       t.dog.height=100;
    }
}
  class Dog{
     int height;
     public void  shout(){
         System.out.println("wowowo");
     }

}
class Taidi {

     //通过组合，去引用dog class的代码
    Dog dog = new Dog();



}