java02

/*
*测试标识符的写法，

标示符必须以字母，下划线，$开头。其它部分可以加数字、字母、下划线、$，

1字节=8位，2的8次方状态，3个字节表示一个汉字，
*/
public class Welcome{
    public static void main(String[] args){   
        int  $abc = 3;
        int $ = 5;
        int _123=5;
        //int 123abc = 6;    //标识符不能以数字开头
        //int  abc# = 3;    //标识符不能包含除了字母、数字、下划线、$之外的其他字符
        //int  class = 3;
        int 尚学堂 = 10;   //java内部采用了Unicode字符集，universal。
    }
}



//测试整数类型：byte,short,int,long。以及进制之间的转换问题
public class TestDataType {
    
    public static void main(String[] args){
        int a = 10;//10进制
        int a2 = 010;//8进制的8
        int a3 = 0xf;//0x开头都是16进制
        
    //    byte b = 200;
    //    System.out.println(b);
        System.out.println(a);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(Integer.toBinaryString(a));//a转为2进制
        System.out.println(Integer.toOctalString(a));//a转为8进制
        System.out.println(Integer.toHexString(a));//a转为16进制
        
        int a5 = 10;
        long a6 = 200;
        byte b2 = 100;   //如果数据的大小没有超过byte/short/char的表述范围，则可以自动转型。
        
        long  a7 = 11123213232L;
        long l = 3;
        long l2 = l+3;    //L问题
        
    }

}

//测试浮点数
public class TestFloatType {
    
    public static void main(String[] args){
    
        //double d = 3.14;   //浮点数常量默认类型是double。
        //float f = 6.28F;    
        double d2 = 314e-2;   //采用科学计数法的写法
        System.out.println(d2);
        
        float f = 0.1f;
        double d = 1.0/10;
        System.out.println(f==d);   //false
    
        
    }

}

//测试char
public class TestCharType {
    
    public static void main(String[] args){
    /*    
        char c1 = 'a';
        char c2 = '尚';   //unicode  2: 0-65535
        char c3 = '
';
        System.out.print(c1);
        System.out.print(c3);
        System.out.print(c2);
    */
    /*
        char c4 = 'a';
        int i = c4 + 2;
        char c5 = (char)i;   //强制转型
        System.out.println(c5);
        
        //循环打印a-z
        for(int j=0;j<26;j++){
            char temp = (char)(c4+j);
            System.out.print(temp);
        }
        
        //java里面的字符串，是定义成：String类了。
        String  str = "abcdefghijklmnopqrstuvwxyz";
        System.out.println("
"+str);
    */
        boolean b = false;   //false
        if(b){    
            System.out.println("true");
        }
        
        
        
    }

}

//测试自动转型和强制转型 
public class TestCast {
    
    public static void main(String[] args){
    /*    
        byte b = 123;
        //byte b2 = 300;
        //char c = -3;
        char c2 = 'a';
        int i = c2;
        long d01 = 123213;
        float f = d01;
        
        //测试强制转型
        int i2 = -100;
        char c3 = (char)i2;   //-100超过char的表数范围，所以转换成完全不同的值，无意义的值！
        System.out.println(c3);
    */    
    /*
        //表达式中的类型提升问题
        int a = 3;
        long b = 4;
        double d = 5.3;
        int c = (int)(a+b);   //做所有的二元运算符(+-/*%)，都会有类型提升的问题！
        float f = (float)(a + d);
    */
    
        int money = 1000000000;  //10亿
        int years = 20;
        long total = (long)money*years;   //返回的是负数
        System.out.println(total);
        
        //一个人70年心跳多少次
        long times = 70L*60*24*365*70;
        System.out.println(times);
        
        
    }

}

jdk7新特性

int是4个字节，每个字节8位，

public class TestBinaryNum {
    
    public static void main(String[] args){
        int a = 0b0000_0000_0000_0000_0000_0000_0000_0011;//下划线表示数字的分隔符
        int b = 1_2312_3131;
        System.out.println(a);
        System.out.println(b);
    }
}

Java是强类型，每个变量必须声明其类型，js是弱类型，不用指明其数据类型，

变量分为局部变量和实例变量（成员变量），局部变量是属于一个方法的，在方法里声明。局部变量必须先初始化（赋值）在使用。Final常量只能被初始化（赋值）一次，初始化就是第一次赋值，Final只能赋一次值。

变量、方法的名：要首字母小写和驼峰原则。
常量：大写字母和下划线。
类名：首字母大写和驼峰原则。



public class TestVariable {
    int t;    //实例变量，成员变量，属性
    
    public static void main(String[] args){
        int a;
        int b = a+3;//出错，局部变量a要初始化在使用。
        int x,y,z;
        
        final int C=34;
        C = 35;//出错，Final只能赋值一次
        
        
        final int  MAX_SPEED = 120;
        
        
        
    }

}

/*整数运算：
1）2个整数相加，有一个为Long，则结果为long。
2）没有long，结果为int，即使操作数全为short,byte,结果也是int.
浮点运算：
1）2个操作数有一个为double,结果为double.
2）只有2个操作数都为float,结果才为float.


&& 左边为false则右边不算了
|| 左边为true则右边不算了


复杂的运算符操作时，尽量使用小括号。
*/

public class TestOperator {
    
    public static void main(String[] args){
    
        double d = 10.2%3;
        System.out.println(d);//1.1999999993，有一个为double则结果为double.
        
        int a = 3;
        int b = a++;   //执行完后,b=3。先给b赋值，再自增。
        int c = ++a;   //执行完后,c=5。先自增,再给b赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    
    //    int c = 3/0;
        
    
        boolean c = 1<2&&2>(3/0); 
        System.out.println(c);
    
    
        //测试位运算，主要用在游戏和权限中使用，
        int m = 8;
        int n = 4;
        System.out.println(m&n);
        System.out.println(m|n);
        System.out.println(~m);
        System.out.println(m^n);
        
        
        int a = 3*2*2;
        int b = 3<<3;  //左移相当于乘以2：3*2*2;移位比乘法要快很多，
        int c = 12/2/2;
        int d = 12>>2;//右移相当于除以2，
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        
        boolean b1 = true&false;//布尔变量是一位
        System.out.println(b1);//false
    
    
    
        //扩展运算符
        int  a = 3;
        a +=5;  //a = a+5;
        
    
    
        //字符串相连：加号两边只要有一个为字符串，则变为字符串连接符，整个结果为字符串。
        System.out.println(4+"5");
    
    
        int a=3;
        int b=5;
        String str= "";
        
        if(a<b){
            str = "a<b";
        }else{
            str = "a>b";
        }
        
        str = (a<b)?"a<b":"a>=b";
        System.out.println(str);

        
    }

}

eclips的使用


eclips是IBM开发的，eclips还可以开发C++,Python，Android。
eclips的workspace的bin目录下在运行时会生成class文件，


jdk7之前，switch表达式只能是int(可以自动转为int的byte,short,char)和枚举类型。
JDK7中可以放置字符串。

switch (a) {   //JDK7的新特性，表达式结果可以是字符串！！！
        case "马士兵":
            System.out.println("输入的马士兵");
            break;
        case "高琪":
            System.out.println("输入的高琪");
            break;
        default:
            System.out.println("大家好！");
            break;
        }





    public static void main(String[] args) {
        int oddSum = 0;  //用来保存奇数的和
        int evenSum = 0;  //用来存放偶数的和
        for(int i=0;i<=100;i++){
            if(i%2!=0){
                oddSum += i;
            }else{
                evenSum += i;
            }
            
        }
        System.out.println("奇数的和："+oddSum); 
        System.out.println("偶数的和："+evenSum); 
        
        System.out.println("#########################"); 
        
        for(int j = 1;j<=1000;j++){
            if(j%5==0){
                System.out.print(j+"	");
            }
            if(j%(5*3)==0){
                System.out.println();
            }
        }
        
    }




    public static long factorial(int n){
        if(n==1){
            return 1;
        }else{
            return n*factorial(n-1);
        }
    }//f(n)=n*f(n-1)

自己调自己就是递归。


API:Application Programming Interface:应用程序编程接口
API就是方法的说明，


import java.util.Scanner;


/**
 * 测试Scanner类的使用，如何接收键盘的输入。
 * @author dell
 *
 */
public class TestScanner {
    
    public static void test01(){
        Scanner s = new Scanner(System.in);
        String str = s.next();  //程序运行到next会阻塞，等待键盘的输入！
        System.out.println("刚才键盘输入："+str); 
    }
    
    public static void test02(){
        Scanner s = new Scanner(System.in);
        System.out.println("请输入一个加数："); 
        int a = s.nextInt();
        System.out.println("请输入被加数：");
        int b = s.nextInt();
        int sum =a+b;
        System.out.println("计算结果，和为："+sum); 
    }
    
    
    public static void main(String[] args) {
        test01();
    }
}

 

面向对象的三大基本特征：继承、封装、多态。
  
  
C++的开始名字是带类的C，java是面向对象，没有比面向对象跟高级的了。
  
  
如果是多人开发面向过程就很难了，面向过程要一步一步的做（一个方法一个方法的调用），面向对象的话可以把工作分派到每个人，每个人做自己的事，然后整合进来。
  
  
面向对象：首先考虑清除要哪些对象，每个对象有哪些方法（每个方法就是面向过程）。
  

造车这个事情，就需要造车轮，造发动机，造车皮。很难决定上面造的先后顺序，所以面向过程就很难了。如果用面向对象：车轮（买橡皮，造模具，出车轮），发动机（学原理，买铁，制作），座椅（橡皮，固定），这样将上面的东西组装，则汽车造出。
  
    
面向对象（OOP）的本质：以类的方式组织代码，以对象的方式组织数据。


抽象就是把几个东西相同的部分抽出来，class(分类)的意思。


虚拟机跑起来后，回去找main方法，main方法就是第一步(入口)。实际上，main方法和main方法说在的类是没有关系的。java要求所有方法必须写到类里面，所以main方法在类里面。


除了8种基本数据类型之外，其余都是引用类型，不初始化都为null。8种基本数据中数字就是0，小数是0.0，布尔默认是false（0）,char是u0000(还是0，2个字节)。

java中方法参数传递都是值传递，没有引用传递，传递的都是值。


return语句：1结束方法2返回值

局部变量一定要初始化才能用，成员变量不用初始化，系统会帮你初始化。




栈（特点：自动分配连续的内存空间，后进先出，存放局部变量，）。
堆（特点：内存空间不连续，存放new出来的对象。还有方法区：存放类的代码信息，static变量，常量池[字符串常量]）等。

内存分析要从main方法开始分析，因为从main方法开始程序才开始跑，虚拟机也是从这里开始跑的。
Student s1 = new Student();
虚拟机看到左边的Student会在内存空间（堆）里找Student类，如果没有Student类就在类路径下面找这个类加载进来（类加载器加载进来），找不到就报错：类没有找到（是找Student的字节码文件）。有类就直接用。Student加载后在堆的方法区就有类的信息（代码[属性，方法]，static常量，常量池[方法区中常量池是共享的，也就是说方法区中，只要是使用同一个常量池就不用另外搞一个新的了，用这个相同的就可以了。字符串常量，代码中所有加双引号的都是字符串常量]），这个类可以被多个对象共有。
s1是局部变量放在栈中，new Student()创建的对象在堆里面，这个对象的属性会有默认值，但是这个对象是没有方法的，因为每个对象的方法是一样的，所以这个对象的方法会指向堆中方法区中类的信息中的方法信息区域，=是赋值符，赋值就是把堆中的new Student()的区域(这个对象的地址是连续的)的首地址给栈中的s1。
s1.name="啊啊"，给堆中这个对象的属性赋值，把堆中这个对象的属性值赋值为字符串"啊啊"的地址，"啊啊"是存放在堆中方法区中类的信息区的常量池区域。操作对象就是操作地址，"啊啊"也是一个对象，是对象就有地址。几本数据类型（int，float）不是对象是没有地址的。
s1.study(),执行方法.
以上图已经截。



垃圾回收：
垃圾不用管，内存中对象会越来越多。一个对象没有引用指向他就会被垃圾收走。我们无法调用垃圾回收器，只能发送请求建议垃圾回收器跑一下。能力强的人用C++的回收规则要好。由于java是写大型软件、服务器软件所以如果垃圾回收的不好就会出问题。



类中出现的字符串都存在于堆中的方法区中的常量池中，所有引用同一个字符串的变量都是指向同一个地方（方法区的常量池中）。



构造器也是方法，特殊处在于：1这个方法只用来构造这个类的对象，2用new关键字调用，3没有构造方法则添加一个无参数的构造方法，有则不加，3返回值是类本身。



重载（overload）:同一个类中名字相同参数不同的方法（如果与jdk的方法同名则调用jdk的方法时要加包名），类型、个数、顺序不同。能不能构成重载关键在于调这个方法的时候可不可以区分是哪个方法，与返回值无关，因为返回值在调的时候是用不到的，故区分不了。



static关键词：静态变量（类变量，其余叫成员变量），静态方法（类方法）。静态变量、静态方法在堆的方法区，所有对象共有，在虚拟机加载累的时候就有了，非静态的属性和方法是属于对象的，只有有了对象才有。静态的方法不能使用非静态变量，因为静态方法先加载，普通方法是有了对象才有的。普通方法、成员变量是属于对象的。静态变量只有一份，被所有对象共有，可以使用‘对象.类属性’不过一般用‘类名.类属性’。静态方法可以访问静态属性。静态属性没有对象也可以调用。



如果希望类加载后，对整个类进行某些操作，可以使用静态块。在类的初始化执行，不是创建对象时执行，静态代码块不能访问非静态成员。



this关键字：this叫隐式参数，this不能用于静态方法，因为this表示对象。（输入syso加'alt+/'就可以出来System.out.println();）

 public  Student(String name,int id){
         this(name);   //通过this调用其他构造方法，必须位于第一句！
         this.name = name;
         this.id = id;
     }
     
     public Student(String name){
         this.name = name;
     }
     public Student(){//Student()这里会传一个隐式参数this，还有一个super.
         System.out.println("构造一个对象");
     }
     
     

面向对象3大特征：继承[难]、封装（隐藏）[简单]、多态[难]
继承就是分类，只要涉及到分类就要抽象（抽出相同的部分，只要代码需要多次拷贝就可以用继承）。继承就是对某一批类的抽象,提高代码的复用性。
（一个源文件可以定义多个类，也可以单独写一个类）。
子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法）。java类只有单继承，C++有多继承，所以java是C++-,就是把C++过于复杂的除掉了，继承的类多了就会很复杂。java接口有多继承，任何类都继承Object类。
继承可以重写（override），重写的方法必须和被重写的方法一样，重写的方法不能比被重写的方法有更严格的访问权限（由于多态），重写之后还是可以调父类的这个方法（super.方法名）。

object类：
super关键字：super是父类对象的引用（引用就是地址），this是本类对象的引用（地址），可以通过super来访问父类中被子类覆盖的方法和属性。任何类的构造函数，如果第一行没有显式的调用super()方法,那么java会默认调用super()方法作为父类的初始化函数，显式写super()方法必须位于构造函数的第一行。每个方法里面传进来的形参都有2个隐式参数（this、super）,所以this.方法名和super.方法名这2中方法只能在方法里调用，不能在方法外面调用。


继承VS组合：继承就是子类对象包着父类对象，单从代码服用的角度看，组合完全可以替代继承。组合就是一个类里面有另一个类的对象，和继承的作用差不多，一个类可以调用另一个类的所有属性和方法。
is-a（是）关系使用继承，has-a（有）关系使用组合。



final关键字：final变量只能被赋值一次不能修改，final方法不能被子类重写，但可以重载。final类不能被继承（Math,String）。



封装（隐藏）：程序要求高内聚低耦合（难得东西不让别人看，简单的东西给别人看），高内聚就是类的内部数据操作细节自己完成，不润许外部干涉。低耦合是暴露少量方法给外部调用。
成员变量全部私有，boolean变量的get方法是以is开头的。



多态：1.要有继承，2.要有方法重写（不能调用接口没有的方法），3.父类引用指向子类的对象。
Animal a = new Cat();
a.catchMouse();/*这是错的，Cat继承自Animal，catchMouse()方法只是Cat类有而Animal类没有，父类接口不能调用子类有而父类没有的方法，要想调用需要像下面那样进行强制转型。*/    
Cat a2 = (Cat)a;
a2.catchMouse();
if(c instanceof Cat){}
(子类对象给父类对象赋值后，父类对象调用属性和方法时，父类有子类没有则调用父类，父类有子类也有则把父类屏蔽调用子类，父类没有子类有要想调用就要强制转换)


编译：javac Test.java    
运行：java Test
（只不过myeclips帮我们做了）
内存分析：
public class Test {
    public static void main(String[] args) {
        Animal a = new Cat();
        testAnimalVoice(a);
        Cat a2 = (Cat)a;
    }
    public static void testAnimalVoice(Animal c){//形参c也是局部变量（在栈中），把a赋值给c(值传递不是引用传递，传递的是a的地址值)，所以c也指向了cat对象（变量的声明形式的变量都存放的是地址，指向堆中的对象。）。
        c.voice();
        if(c instanceof Cat){
            ((Cat) c).catchMouse();
        }
    }
}
(实际上所有的类是一次性加载的，看到需要用哪些类一次性加载完。)
首先在堆中加载Test类，然后执行main方法，看到Animal会加载Animal类，看到a就会在栈里面建一个a,然后在堆中加载Cat类，看到new就会在堆中生成cat对象和animal对象（子类的构造函数会调用父类的构造函数），看到=就把cat对象的地址赋给a,Cat a2 = (Cat)a;看到a2就在栈中建一个局部变量a2,然后就是把a的值（地址值）赋给了a2,a2也是存在于栈中的局部变量，所以a2也指向了cat对象。


多态的例子：
servlet(服务器端小程序)，
public class HttpServlet {
    public void service(){
        System.out.println("HttpServlet.service()");
        this.doGet();//这个方法仍然不会调用本类的方法,而是子类的方法。
        doGet();//与上面是一样的。
    }
    
    public void doGet(){
        System.out.println("HttpServlet.doGet()");
    }
    
}

public class MyServlet extends HttpServlet {
    
    public void doGet(){
        System.out.println("MyServlet.doGet()");
    }
    
}

public class Test {
    public static void main(String[] args) {
        HttpServlet s = new MyServlet();    s.service();//调用子类的service()方法，子类没有就用父类的（父类的就是子类的），调用service方法的时候会调用doGet方法，doGet方法子类父类都有就会调用子类的，相当于把父类方法屏蔽了（因为相当于this.doGet()，而这个this指的是最外层的子类对象）
    }
}
运行结果：
HttpServlet.service()
MyServlet.doGet()
MyServlet.doGet()



抽象类：
是一个模版模式，为子类提供了一个通用模版，子类可以在模版上进行扩展，可以避免子类设计的随意性。
1.有抽象方法的类是抽象类
2.抽象类没有实例，即不能用new来实例化抽象类
3.抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例，只能用来被子类调用
4.抽象类只能用来继承，必须被子类实现，否则没意义

继承抽象类必须实现所有抽象方法，抽象类可以继承抽象类。抽象方法的意义在于把方法的设计和实现分开了。


接口：比抽象类还要抽象的类。接口编译后也是class文件，接口里面只有常量和抽象方法，接口里面的常量总是public static final 类型，在子类用接口名.常量名来调用。接口中的方法一定是public abstract。




内部类：
一个类里面定义的类叫内部类，比如Computer类里面可以加一个Cpu类，这个Cpu类别的类也用不到，Cpu类就是为Computer类服务的，Cpu类定义在里面的好处是别的地方不能直接访问Cpu类，Cpu类从属于Computer类，只能通过Computer类才能访问，Computer类是Cpu类的外部类，Cpu类是Computer类的内部类。Cpu类可以直接使用Computer类的私有属性和方法，Computer类不能直接访问Cpu类的属性，内部类的存在就是为了外部类的。
内部类的分类：
1.成员内部类。2.匿名内部类。3.局部内部类
1.成员内部类：这个内部类仿佛是外部类的一个成员一样，成员内部类分为静态内部类和非静态内部类，静态内部类类似于静态属性，非静态内部类类似于普通属性。
成员内部类可以使用private，protected，public任意进行修饰。
非静态内部类必须存在与一个外部对象里(外部对象存在才存在),非静态内部类可以使用外部类的成员，外部类不能直接访问非静态内部类的成员。
非静态内部类里面不能有静态方法、静态属性、静态初始化块。
静态内部类看成外部类的静态成员，静态内部类不能使用外部类的普通属性，可以使用外部类的静态属性。外部类的方法可以使用静态内部类.名字访问静态内部类的静态成员。
/**
 * 测试内部类的使用
 * @author dell
 *
 */
public class Outer {
    public static void main(String[] args) {
        Face f = new Face();
        Face.Nose n = f.new Nose();//非静态内部类一定要有外部类的对象才能有
        Face.Nose n1 = new Face().new Nose();
        n.breath();
        Face.Ear e = new Face.Ear();
        e.listen();
    }
}

class Face {
    int type;
    String shape="瓜子脸";
    static String color="红润";
    
    class Nose {
        
        void breath(){
            System.out.println(shape); 
            System.out.println(Face.this.type);
            System.out.println("呼吸！");
        }
    }
    
    static class Ear {
        void listen(){
            System.out.println(color); 
            System.out.println("我在听！"); 
        }
    }
    
}
3.局部内部类：定义在方法里面，用的极少，方法完了以后类也没了。
2.匿名内部类：适合那种只需要使用一次的类，比如键盘监听操作，语法：new 父类构造器（实参裂变）实现接口(){匿名内部类类体}，定义和调用放在一起。