day1

-. java 增强

 

>>>1.  编译带包的类

 

    javac -d . Test.java

 

>>>2. 运行带包的类

 

     java com.test.Test

 

>>>3. 打包

 

     jar -cvf my.jar  com(这个里面放的是包里面的类文件)

 

>>>4. 单击运行jar包 如单击 自己打的包 my.jar

 

>4.1 配置jar包里面的 META-INF 文件夹下面的MANIFEST.MF 文件 在后面写上 Main-Class: com.test.Test  

****需要注意的是:Main-Class:后面的空格 还有后面是 包名.类名

 

>>>5 myEclipse 一个快捷键 Ctrl+Shift+m 导入单个类 而不是全部的类  很重要

 

>>>>6 多态的深入理解

 

>>动态绑定 只有方法(非静态)

 

>>静态绑定 有成员变量 还有静态方法

 

public class Animal{

    public static String name="Animal";

    public int age=20;

    public void say(){

        System.out.println("Animal");

    }

    public static void show(){

        System.out.println("Animal");

    }

}

public class Cat{

    public static String name="Cat";  //这个叫静态成员变量

    public int age=59;              //非静态成员变量

    public void say(){

         System.out.println("Cat");

    }

    public static void show(){

           System.out.println("Cat");

    }

 

}

 

      Animal c=new Cat();

      c.name  ---> Animal

      c.age------> 20                 这叫静态绑定 他会跟变量名绑定

      c.say()---------------->cat    这叫动态绑定

      c.show()------------->Animal  也是静态绑定

 

>>>7 调试

     Step into 单步进入-将进入执行的方法内部继续执行。

     Step over  单步前进-执行下一步。

     Step return – 单步退出-跳出正在执行的方法。

     Drop to frame – 跳到正在执行的方法的第一句代码。

     Resume : 执行到下一个断点。

     Terminate:停止调试。程序将停止运行。

 

二:Junit使用

 

>>一般写得时候 会自己建立一个测试类 在测试类里面写测试方法 在测试的方法上加上@Test注解

>>注意 必须 先导入Junit 包 通过 properties--java Build Path-->add library--> junit

 

package com.junit.test;

 

import org.junit.Test;

 

import com.junit.Student;

 

public class JunitTest {

     @Test

     public void testJunit(){

    Student s=new Student();

    s.say();

     }

}

 

 

三: 缓冲机制

 

案例: 通过一个城市的名字 来获得这个城市的信息

 

>> 不可能吧 所有的城市 都事先准备好 都放入内存 那样太浪费内存了

 

解决之道---> 用hashMap<String,City> 来解决

package com.buff;

import java.util.HashMap;

import java.util.Map;

public class City {

private City(){   //一个似有的构造

}

private static Map<String,City> map=new HashMap<String,City>();

public static City getCity(String name){  //对外公开的方法 通过名字来获得 城市的信息

City city=map.get(name); //如果在内存中 直接在内存中查找 然后返回结构

if(city==null){                   //如果没有 该城市  

city=new City();           //在创建对象

map.put(name,city);          //添加到map中

}

return city;                         //加载到内存 然后返回

}

}

 

四: 只能创建两个对象 通过单利

gender 性别

//用枚举来实现

public class Gender {

public static Gender MALE;  //先只定义 这种类型 不创建实力 节省内存 创建两个 通过公开的静态方法返回 所要的对象

public static Gender FMALE;

public static Gender getMale(){

if (MALE == null) {

MALE = new Gender();

}

return MALE;

}

 

public static Gender getFlMale() {

if (FMALE == null) {

FMALE = new Gender();

}

return FMALE;

}

 

}

五: 不可变类: 就是这个类一旦被声明 他的属性就不可以改变

实现 思路:

 

1.属性全部似有化 并且final  private final 修饰所有的属性

 

2.不提供 setxxx的方法(不允许在外面设置 可以通过构造来初始化值)   只提供getxxx

public class Person {

        private String name;

public Person(String name){

         this.name=name;

        }

         public String getName(){

             return this.name;

       } 

}

 

 

>>> 注意: 当参数是地址 的时候 需要特别注意 比如: 参数是数组 就是地址 可以通过采取保护性copy方式实现

public class Student {

private String[] stu;

public Student(String[] stu){

this.stu=stu;

}

public void reCall(){

for (String stu1 : stu) {

System.out.println(stu1);

}

} 

}

>>>>>>>测试

package com.junit;

import org.junit.Test;

import com.buff.Student;

public class JunitTest {

@Test

public void testStu() {

String[] s = { "zs", "ls", "ww", "zl" };

s[1] = "aa";                                //在这里吧值给修该了

Student stu = new Student(s);

stu.reCall();                                //所以打印出来的结果也就不一样了

}

}

 

>>解决之道     

因为传递的是地址  所以通过地址copy原先的一份存起来 这样 当途中通过地址修该堆内存中的内容是 不会影响原来copy的那一份

public class Student {

private String[] stu;

public Student(String[] stu){

stus=new String[stu.length];  //copy 一份

            for(int i=0;i<stus.length;i++){                 //通过循环在赋值

               stus[i]=stu[i];

                }

}

public void reCall(){

for (String stu1 : stu) {

System.out.println(stu1);

}

} 

}