java的基础知识总结（1）

一、基础

 

1、编译与运行

（1）

 

public class helloworld{

       public static void main(String[] args){

              System.out.println("Hello World!");

       }

}

 

Javac E:\java\D01\helloworld.java

 

Java helloworld

 

（2）

 

class A

{

 

}

 

class B

{

 

}

 

class C

{

 

}

 

 

一个java源文件中可以定义多个class，不一定有public的class，一个class会定义生成一个.class文件；

 

 

（3）

 

一个java源文件中定义公开的类，只能有一个，且类名必须和java源文件名一致。

 

（4）

 

 

每个class都可以定义main方法，都可以定义程序的入口，执行A.class：java A。

 

2、标识符

 

程序员可以自己定义的名称。

 

（1）

遵守驼峰命名方式。

类名、接口名：首字母大写，后面每个单词首字母大写；

变量名、方法名：首字母小写，后面每个单词首字母大写；

常量名：全部大写。

 

3、数据类型

byte

short

int

long

float

double

boolean

char

 

4、运算符

 

赋值运算符

字符串连接运算符

三元运算符

 

5、基本语法

（1）

public class TestCode

{

         public static void main(String [] args)

         {

                   //int num1=10,num2=20;

                   //String  strCode="this is a code!";

                   //String  strCode1=strCode+"yes!";

                   //System.out.println(num1>num2?num1:num2);

                  

                   //1、创建键盘扫描器对象

                   java.util.Scanner s=new java.util.Scanner(System.in);

                  

                   //2、调用Scanner对象的next（）方法

                   //String strInputNum=s.next();

                   int strInputNum=s.nextInt();

                   //System.out.println("输入了："+strInputNum);

         }

}

 

import java.util.*;

 

public class TestScan

{

         public static void main(String [] args)

         {

                   Scanner in =new Scanner(System.in);

                   System.out.println("input your name:");

                   String strName=in.nextLine();

                   System.out.println("your name: "+strName);

         }

}

 

 

（2）大数

import java.math.*;

import java.util.*;

 

 

public class TestBigInteger 

{

         public static void main(String[] args)

         {

                   //System.out.println("Hello World!");

                   Scanner in =new Scanner(System.in);

                   System.out.print("How many numbers do you need to draw?");

                   int k=in.nextInt();

 

                   System.out.print("What is the biggest number you can draw?");

                   int n=in.nextInt();

                  

                   BigInteger lotterOdds=BigInteger.valueOf(1);

 

                   for(int i=1;i<k;++i)

                   {

                            lotterOdds=lotterOdds.multiply(BigInteger.valueOf(n-i+1)).divide(BigInteger.valueOf(i));

                   }

 

 

                   System.out.println("Your odds are 1 in " + lotterOdds+".");

         }

}

 

 

6、方法

一个代码片段可以被重复调用，完成特定的功能。

 

public class MethodTest

{

         public static void main(String [] args)

         {

                   addInt(100,100);

         }

 

         public static void addInt(int a,int b)

         {

                   int c=a+b;

                   System.out.println(a + "+" + b + " = " +c);

         }

}

 

（1）[修饰符列表] 返回值类型 方法名（形参列表）{

         方法体

}

 

7、方法的内存分析

 

8、方法重载

 

（1）

public class TestOverload

{

         public static void main(String [] args)

         {

 

                   int a=1,b=1;

                   int c=TestOverload.addNum(a,b);

                   System.out.println("Overload Test."+c);

         }

         public static int addNum(int a,int b)

         {

                   return a+b;

         }

         public static long addNum(long a,long b)

         {

                   return a+b;

         }

         public static double addNum(double a,double b)

         {

                   return a+b;

         }

}

 

9、方法递归

 

10、类与对象

 

类->实例化->对象

 

对象的状态与动作，类的属性与方法。

 

11、static关键字和静态代码块

类级别的动作和方法。

12、继承

extends

 

13、方法的覆盖override

 

14、多态

（1）

向下转型（downcasting）父->子

向上转型（upcasting）子->父

 

（2）编译器和运行期

 

15、package语法机制

  

16、单例模式

 

package testjavase.test04;

 

public class Singleton {

         static Singleton singleton;

         private Singleton() {}

        

         public static Singleton getSingleton()

         {

                   if(singleton==null)

                            singleton=new Singleton();

                   return singleton;

         }

}

 

 

二、基础特性

 

 

1、包

 

2、设置类路径

 

 

 

3、注释

 

 

4、super

 

5、多态

6、抽象类

 

7、equals

 

8、ArrayList

 

 

9、可变参数

 

10、异常处理

11、继承设计的技巧

 

 

12、接口

（1）

 

（2）接口与抽象类

 

（3）对象克隆

（4）接口与回调

package javase01.com.mao.test05;

import java.util.*;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.Timer;

 

public class TimerTest {

public static void main(String[] args)

{

         ActionListener listen =new TimerPerform();

         Timer t=new Timer(10000,listen);

         t.start();

         JOptionPane.showMessageDialog(null, "Quit?");

         System.exit(0);

}

}

 

 

class TimerPerform implements ActionListener

{

         public void actionPerformed(ActionEvent event)

         {

                   Date now=new Date();

                   System.out.println("Time is: "+now);

         }

}

13、内部类

（1）

 

（2）

（3）内部类的访问特权管理

（4）匿名内部类

package anonymosInnerClass;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Date;

import javax.swing.Timer;

public class TestAnonymosInnerClass {

}

class TalkingClock{

         private int interval;

         private boolean beep;

        

         public TalkingClock() {

                   super();

                   // TODO Auto-generated constructor stub

         }

         public TalkingClock(int interval, boolean beep) {

                   super();

                   this.interval = interval;

                   this.beep = beep;

         }

         public void start() {

                   ActionListener listen =new ActionListener()

                   {

                            public void actionPerformed(ActionEvent event)

                            {

                                     Date now=new Date();

                                     System.out.println("Time is: "+now);

                                     if(beep)

                                     {

                                               Toolkit.getDefaultToolkit().beep();

                                     }

                            }

                   };

                   Timer t=new Timer(interval,listen);

                   t.start();

         }

 

}

 

 

 

 

 

（4）内部静态类

14、代理

package proxy;

 

import java.util.*;

import java.lang.reflect.*;

 

public class TestProxy {

         public static void main(String []args)

         {

                   Object [] elments=new Object [1000];

                   for(int i=0;i<elments.length;++i)

                   {

                            Integer value=i+1;

                            InvocationHandler handler=new TranceHandler(value);

                            Object proxy=Proxy.newProxyInstance(null, new Class[] {Comparable.class}, handler);

                            elments[i]=proxy;

                   }

                   Integer Key=new Random().nextInt(elments.length)+1;

                   int result =Arrays.binarySearch(elments, Key);

                   if(result>=0)

                   {

                            System.out.println(elments[result]);

                   }

         }

}

 

 

class TranceHandler implements InvocationHandler

{

         private Object target;

 

         public TranceHandler(Object target) {

                   super();

                   this.target = target;

         }

         public Object invoke(Object proxy,Method m,Object[]args) throws Throwable

         {

                   System.out.print(target);

                   System.out.print("."+m.getName()+"{");

                   if(args!=null)

                   {

                            for(int i=0;i<args.length;++i)

                            {

                                     System.out.print(args[i]);

                                     if(i<args.length-1)

                                     {

                                               System.out.print(",");

                                     }

                                    

                            }

                            System.out.println("}");

                   }

                   return m.invoke(target, args);

         }

}