黑马程序员_高新技术

最新推荐文章于 2018-09-01 15:20:56 发布

zhanggeng22

最新推荐文章于 2018-09-01 15:20:56 发布

阅读量329

点赞数

本文链接：https://blog.csdn.net/zhanggeng22/article/details/8585250

版权

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

package cn.itcast;
import java.lang.Math.*;
/*java基础加强和JDK1.5的新特性
面试技巧和面试题目分析:
eclipse的使用技巧
eclipse和Myeclipse区别,Myeclipse是个插件,可以加强eclipse
eclipse是用java开发出来的javaw,图形界面是javaw不会启动命令行
eclipse使用java开发出来的,这就是在运行javaw.exe
eclipse是IDE的开发工具
下边这些是什么的简写:
java ee
ide -->itegrity development environment集成开发环境
sun公司notebeans的开发工具,比eclipse更好
还有一个收费的开发工具
jms
jmx
jndi
工程:
多个java类和资源联合成为一个工程:project ,夹包,新建工程
开发工具可以帮助管理工具,工作台
eclipse是javac和java可以是自己配置的
在java的windows中打开Preferences
中在compiler设置JDK----------编译器
在Intalled JREs中设置路径------运行器
workspace设置工作间
[1]工程名字静态导入
透视图,要有包名 ,包名就是域名的反写;
StaticImport
可以加入提示的习惯,在windows中设置
要记得解除其他绑定
要用单词拼写自己的类名
切换透视图
staticimport
内容助理
Alt+/
如何导入新的工程
拷贝目录然后导入
build path可以增加诶不和外部的夹包.也可以添加夹包库.
普通import是导入一个类,或者是某一个包下的类.
*/
/*public class StaticImprot {
public static void main(String[] args)
{
  int x=1;
  x++;
  System.out.println(x);
  System.out.println(Math.max(3,6));
  System.out.println(Math.abs(3 - 6));
  System.out.println(add(3,5));
  System.out.println(add(3,5,6));
}

    public static int add (int a,int...args)
    {
    int sum=a;
    for(int a1 = 0;a1<args.length;a1++)
    {
     sum=sum+a1;
    }
   return sum;
    }
}*/
/*
透视图与视图
双击边框上边的条就可以调试程序
右键运行可以找到低bug透视图可以调试注释的文件
选中变量点右键watch
小窗口就是视图,透视图是低bug视图,如果没有找到就去other中寻找
预定义的视图的集合叫透视图
*/
/*
* 如何设置单个工程的java和javac
* 在首选项中选择JDK和JRE
* 还可以点击某个单独的工程区编译JDK
* 否则会出现版本错误.高版本不能再低版本运行,
*/
/*
* 绑定模板代码:
* 在配置中选java选Editor其中有各种模板
* 自己也可以新建,点new新建,可以写原来的内容
* 然后右键选择
* */
/*导入新的工程,
* 切换工作间,然后复制文件到显得工作间的地址下;
* 然后开始导入,选择类型,选择地址,若果JDK不同可以重新设置JDK
* 在buildpath中不是增加单独的夹包,也可以增加不同的夹包
* */
/*静态导入
* 普通import语句是导入某一个类
* 或者是某个包下的所有的类
* 由于方法是静态的,所以我们需要类名导入
* 现在可以导入静态方法,这样调用方法,就可以省略类名
* 而且还可以导入一个类下的所有的方法
* 以后还要学习自动拆箱和装箱.
* 注意JDK的版本的运行
* */
/*可变参数:
* 对于参数不固定的方法
* overload和override的区别
* 重载和重写
* JDK1.5中的可变参数
* VariableParameter
* 只能出现在参数列表的最后,在...前边和后边有无空格都可以
* 调用可变参数的时候,方法是以数组的形式来返回参数
* */
class VariableParameter{
   public static int add (int a,int...args)
   {
  int sum=0;
  /* for(int a;a<args.length;a++)
   {
    sum=sum+a;
   }*/
   for(int arg:args)
   {
    sum+=arg;
   }
  return sum;
   }
}
/*
   * for循环的增强
   * for(type 变量名;集合变量名)
   * {...}
   * 迭代变量在()中定义;
   * 集合变量是以数组或实现Iterable接口的集合类
   * 前边还可以加final来修饰局部变量
   * */
   /*
    * 基本数据类型的自动装箱与拆箱
    * 基本类型的整数在小于127到-128之间可以存储为一个数据
    * 当大小大于1byte的时候才会分别存储
    * 小对象的相同属性存储到一起
    * 不同的属性变成方法这个方式叫做享元模式
    * 英文名字叫做flyweight*/
/*public class AutoBox{
public static void main(String[] args)
{
   Integer iObj=1;
    System.out.println(iObj+12);
String s1=new String("abc");
String s2=new String("abc");
   Integer i1=12;
   Integer i3=Integer.valueOf(12);
   Integer i2=12;
   System.out.println(i1==i2);
   System.out.println(i1==i3);
   }
}*/
/*
* 枚举:
* 为什么会有枚举?
* 问题:要定义星期几或性别变量该这么定义?假设用1-7分别表示星期一到星期日
* 可以再编译的时候就定义枚举的存储
* 将大量的if,else语句变成抽象类
* 有子类自己完成,就是将ifelse语句变成抽象类
* */
*/
public class EnumTest{
public static void main(String[] args)
{
   weekDay weekDay=0;

}
}
package cn.itcast;

public abstract class WeekDay {
private WeekDay(){}
public final static WeekDay SUN=new WeekDay(){

    @Override
    public WeekDay nextDay() {
     // TODO Auto-generated method stub
     return MON;
    }

   };
   public final static WeekDay MON=new WeekDay(){

    @Override
    public WeekDay nextDay() {
     // TODO Auto-generated method stub
     return SUN;
    }


   };
   public abstract WeekDay nextDay();
   /*public WeekDay nextDay()
   {
    if(this==SUN){
     return SUN;
    }else{
     return MON;
    }
   }*/
  public String toString(){
   return this==SUN?"SUN":"MON";
  }

}
/*编写一个枚举类
*枚举后边加上()表示指定的方法;
* */
package cn.itcast.day1;
public class EnumTest{
   public static void main(String[] args)
   {
    WeekDay weekDay1 WeekDay1.MON;
    System.out.println(weekDay.nextDay());
    System.out.println(weekDay);
    System.out.println(weekDay.name);
    System.out.println(weekDay.orinal);
    System.out.println(weekDay.valueOf().length);
    WeekDay1 weekDay2 WeekDay1.TUE;
    System.out.println(weekDay.nextDay());
    WeekDay1 weekDay3 WeekDay1.WED;
    System.out.println(weekDay.nextDay());
    WeekDay1 weekDay4 WeekDay1.THT;
    System.out.println(weekDay.nextDay());
    WeekDay1 weekDay5 WeekDay1.FRI;
    System.out.println(weekDay.nextDay());
    WeekDay1 weekDay6 WeekDay1.SAT;
    System.out.println(weekDay.nextDay());
    WeekDay1 weekDay0 WeekDay1.SUN;
    System.out.println(weekDay.nextDay());
    new Date(200){}//子类的无参数构造方法,可以调用父类有参数的构造方法

   }
   public enum WeekDay
   {

    SUN(1),MON(),TUE,WED,THT,FRT,SAT;
    private WeekDay(){Syetem.out.println("1");};
    private WeekDay(int day){Syetem.out.println("2");};
   }
   public enum TrafficLamp{
     RED(20){
     public abstract TrafficLamp nextLamp();
      return GREEN;
     }.GREE(20)N{
     public abstract TrafficLamp nextLamp();
     return YELLOW;
     },YELLOW(15){
      public abstract TrafficLamp nextLamp();
      return RED;
     };
    public abstract TrafficLamp nextLamp();
    private int time;
    private TrafficLamp(int time){this.time=time;};
    }
}
/*抽象枚举实例
   * 内部卡类可以有四个修饰
   * 如果枚举只有一个成员就是单例设计模式
   * */
/*
   * 反射的基石----Class类
   * java类属于同一类事物,描述这类事物的java类名就是Class
   * 代表什么样的事物?
   * java的类在描述人的特性和属性
   * 但是具体的对象对应的值是什么,类是不管的,在java中用到的java的类
   * 也是一个确实超出的东西.他们的起源是什么?我们可以用来描述这个类
   * 描述这个类的名字就是Class.
   * 类名,包,成员被捕,父类,属性
   * Person person= new Person();
   * CLass cls =Date.class//字节码;
   * 什么是字节码?就是二进制代码,然后把二进制代码加载到类中来
   * Class.forName("java.lang.String");
   * 加载在内存当中
   * 要得到雷明亮:
   * System.class
   * new Date().getClass();
   * Class.forName("java.lang.String");
   * 八个基本的数据类型对应8个级本的数据对象
   * void也有对应的CLass对象
   * 对Class的介绍,了解Class
   * 数组类型的判断isArray();
   * 只要在原程序中出现的类型都有Class实例对象
   *
   * */

String str1="abc";
   CLass clas1=str1.getClass();
   Class cls2=String.Class;
   Class cls3=Class.forName("java.lang.String");
   System.out.println(cls1==cls2);
   System.out.println(cls1.isPrimitive());//不是基本类型的自己吗
   System.out.println(cls1==cls3);
   Constructor constructor= String.class.getConstrutor(stringBuffer.class,int.class);
   String str2=(String)Constructor.newInstance(new StringBuffer("abc"));
   System.out.println(str2.charAt(2));
   ReflectPoint pt=new eflectPoint(3,5);
   Field field=new pt.getClass().getField("5");
   //这不是对象身上的变量是类身上的变量,所以还要再取一次,但是私有的变量是去不到的,
   //想要得到隐藏的方法pt1.getClass().getDeclaredField
   //想要使用方法pt1.setAccessible(true);
   field.get(pt);
   //还可以用数组来表示.
   /*反射
    * method带便字节码的方法
    * 反射就是把java类中的各种成分映射成为相应的java类
    * 得到的实例对象如何运用哪?
    * Constructor类代表一个类的构造方法
    * Constructor[] constructor
    * 得到某一个构造方法
    * getConstrutor()得到构造方法
    * 获得方法时要调用类型
    * Class的newInstance的方法.这就是泛型
    * 反射可以导致程序性能要种下降
    * */
   /*Filed字段反射
    * */private int x;
    public int y;
    /*修改变String类型变量名
    * */
    */public String str="ball";
    public String str2="Backetball";
    public String str3="yuoo";
    changeStringValue(pt);
    public static void   changeStringValue(Object obj)throws Exception
    {
    Field[] fields=obj.getClass().getFields();
    for(Field field:fields)
    {
      if(field.getType()==String.class)
      {
       String oValue=(String)field.get(obj);
       String nValue =oValue.replace('b','a');
       field.set(obj,nValue);
      }//字节码用==比较,这里是同一份方法
    }
    }
    /*Method
     * 类中的方法
     * 可以代表某一个类中的方法
     * 先获得类中方法然后在带哦有
     * JDK1.4和1.5的区别可变参数的传递
     * */
Method methodCharAt=String.class.getMethod("charAt".int.class);
methodCharAt.invoke(str1,1);
//invoke表示调用方法
//面向对象搞成私有的,谁操作就给谁使用,这就是专家模式
//静态方法调用的时候使用null
/*
* 反射挡住的main方法
* 自己写的程序调用别人的main方法
* 普通方式调用完毕,为什么要用反射的方式去调用*/
class TestArguments{
public static void main(String[] args)
for(String arg:args)
{
   System.out.println();
}
   }
String startingClassName=args[0];
Method methodmain=String.class.getMethod("main".String[].class)
//methodCharAt.invoke(null,new Object[](new String[]{"111","222","333"}));
methodCharAt.invoke(null,(Object)(new String[]{"111","222","3333")
/*数组的反射
* 具有相同元素和类型的可以认为是一个数组
* */
int [] a1=new int[]{1,2,3};
int [] a2=new int[4];
int [][] a3=new int[3][2];
int [] a4=new int[3];
String[] a5=new String[]{"a","b","c"};
a1.getclass()==a2.getclass();
a1.getclass().getSuperclass().getName();
a2.getclass().getSuperclass().getName();
Object[] aobj1=a1;
Object[] aObj2=a2;
Arrays.asList(a1);//只能看到字符串类型的时候不能看到数组类型的
/*数组的反射
* */
Object obj=null;
printObject(obj);
//进行判断不是数组直接但因,是数组拆包打印
//元素的类型是不能达到,因为数组类型可以是任意的
ArrayList();//创建的是一个一个不同的数组引用,即使元素相同但是还是有元素的位置顺序
Hashset();//其中的每一个元素都是不同的,会在放入之前进行判断.
Hashcode();//方法的作用.
//这是一个算法,对对象算出HashCode取膜然后存放区域.但是只能用于哈希值相同的时候才可以比较,区域要相同才可以.
//对于对象相等的时候才能存放在一起.当被存入HashCode的时候,就不要修改涉及HashCode值运算的值
//这样可以防止内存泄露.java中有内存泄露.没有被释放的内存.哈希值的存储例子;
//利用反射做框架
/*框架和工具类的区别
* 框架是调用你的类,类可以调用工具类
* 框架要解决的问题.
* 调用.
* */
InputStream ips=new FileinputStream("config.properties");
properties props=new properties();
props.load(ips);
String className=props.getproperties("className");
Colllection collections=(Collection)Class.forMame(className).newInstance();
ips.close();
//配置文件的书写:
className=java.util.ArrayList;
//配置文件的存放.相对于当前的工作文件目录.
getRealPath();//可以得到真实的位置.再加上拼接内部的位置.
//一定要记住用完整的路径,不是用编码,而是计算出来的.
//还可以查找加载文件
efictTest.class.getClassLoader().getResourAsStream("config.properties");
/*内省:
* IntroSpector-->JavaBean
* JavaBean是一个特殊的java类.符合特殊的书写方法.
* 必须有get和set属性.
* 去掉get和set剩下的名称就是javabean的属性
* 如果第二个字母是小的,则把第一个字母变成小的
* private int x;
*public int getAge()
*{
* return x;
*};
*public void steAge(int age)
*{
* this.x=age;
*};*/
/*
* 在javaEE开发必须用javabean
* 主要是传值的作用*/
public int x;
public String getStartingClassName() {
  return startingClassName;
}
public void setStartingClassName(String startingClassName) {
  this.startingClassName = startingClassName;
}
public Method getMethodmain() {
  return methodmain;
}
public void setMethodmain(Method methodmain) {
  this.methodmain = methodmain;
}

public int getX() {
  return x;
}
public void setX(int x) {
  this.x = x;
}
Beaninfo可以对普通java类进行javabean的操作
可以使用Beanutils工具类进行操作.
需要先进入jar包然后导入
JDK新特性注解:
/*什么是注解*/
@suppressWarnings("deprecation");去除过时警告
//注解是一种标记来告诉编译器,
//一个注解就是一个类
System.runFinalizerOnExit(true);
@deprected注解已经过时的方法
@Override解释覆盖
//可以加在很多地方包,类,方法,对象
//写法就是一个接口的写法,然后在前边加上@
//泛型是1.5新特性中最难的
//在类明后延长
ArrayList<String>=new ArrayList<String>();
//就是在生命之前进行类型的定义
//在JDK中类型有泛型变量才可以定义
//类加载器，就是加载类的工具，就是加载classpath然后把处理。
/*
   * 三个加载可以多个了，java定义了三个主要类加载器
   * BooStrap是第一个加载类
   * 不能获得名字，而且是C++程序写在JVM中*/
   */
   BooStrap//tr/jar
   ExpClassLoader//ext.jar输出的class文件的jar包
   AppClassLoader//只是加载classpath