//Author
//Function
//Date
//public :表示这个类是公共的，一个java文件中，只有一个public类
//class：表示这是一个类
//hello：类名（公共类的类名必须和文件名一致）
public class Hello {
//一个主函数，相当于一个程序的入口
public static void main(String[] args) {//System.out是一个包，println是一个方法
int a=10;//定义一个变量,变量的名字是1，值是10
int b=20;//
System.out.println("不能整除");//输出语句，把变量a的值输出
}
}
所有程序要想运行，必须加载到内存中。
一个int 是4个字符，
1.1java基本数据类型，四种：整数、小数（浮点）类型，布尔类型，字符类型
1.1.1整数类型 byte，short，int，long
0的补码和源码都是0，正数的补码和源码是都一样的，负数的反码是符号位不变，补码是再加1.其他位取反。计算机在运行时是补码方式运行的，，原因是计算机在原码方式运行时会出错
byte，一个字节是8位bit -128到127
java规定，byte值占一个字节，最高位是符号位，代表 正负。 最大的正数： 01111111，即127 最小的负数： 10000000，即-128 二进制负数的值：取反加一，所以 10000000 的值为： A. 取反 -> 01111111 127 B. 加一 -> 128 C. 加上符号： -128 计算方法：对于负数为-（2的（字节数*8-1）次方）；对于正数（2的（字节数*8-1次方））-1
short 两个字节 -32768 到32767
int 四个字节 -2147483648到2147483647
long 八个字节 -？到？
char是两个字节可以存放汉字
1.2 public class prictice {
public static void main(String[] args) {
int test1 = 'a' + 'b';
char test2 = 'a'+28;
char test3 = '中';
System.out.println("test1=" + test1);
System.out.println("test2=" + test2);
System.out.println("test3=" + test3);
}
}
输出结果为：{
因为A的ASC对应值为95,95+28=135， 135对应的值为{
1.3 数据类型由低精度向高精度转换 byte<short<int<long<float<double
在java中，小数默认为是double类型的
%表示取模，整除后的余数，例如 4%2==02.运算符顺序(右移一位相当于除二,两位除二再除二,左移是乘法运算)
public class Demo4 {
public static void main(String[] args) {
int k = 100;
int number = (--k) + k++ * 100 >> 2;
System.out.println(number);
}
}
2.1 关系运算法
A.==等于
B.>大于
C.<小于
D.>=大于等于
E.<=小于等于
F.!=不等于
快捷键:
Ctrl+Shift+F 对齐
sysout+Alt+/ System.out.println("不能整除");
main+Alt+/ public static void main(String[] args)
Java的四大框架 Hibernate Spring Struct Swing
前端就是js css html
后端就是java python
3. 分支控制，switch 语句中，条件表达式的数据类型和case后的常量类型必须一致，包含的数据类型有 byte、short、char、int、enum
4.键盘输入字符串比较 (注意：把错误放在前，-help放在后)
字符串数组有两种定义方式：一个是String[] args ，一个是String args[]。String args[], 是为了兼容C、C++。
import java.io.*;
public class CopyOfHello {
public static void main(String []tkyhklslflasvldf) {
try {
// 输入流 ，从键盘接收数
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
// 给出提示，
System.out.print("请输入第一个数");
// 从控制台读取一个数据
String a1 = br.readLine();
String c = "-help";
if (c.equals(a1)) {
System.out.println("错误");
} else {
System.out.println("-help");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
package com.Test4;
import java.util.Scanner;
public class Mokey {
public static int peach(int day, int sday) {
if (day == sday) {
return 1;
} else {
return (peach(day + 1, sday) + 1) * 2;
}
}
public static void scan() {
System.out.print("请输入两个数：");
Scanner sr = new Scanner(System.in);
int a = sr.nextInt();
int b = sr.nextInt();
if (a < b) {
System.out.println(Mokey.peach(a, b));
} else {
System.out.println("第一个数要小于等于第二个数");
Mokey.scan();
}
}
public static void main(String[] args) {
Mokey.scan();}}
5. 成员属性成员方法
/*
* Author:Qiqige
* Date:2014.7.15
* Function:Divide
*/
import java.io.*;
public class CopyOfHello {
public static void main(String[] tkyhklslflasvldf) {
Person a = new Person();
a.age = 10;
a.name = "小明";
System.out.println("a.name=" + a.name);
a.speak();
a.calc();
a.calc(10);
}
}
class Person {
int age;
String name;
public void speak() {
System.out.println("是一个hao人");
}
public void calc() {
int result = 0;
for (int i = 1; i < 1000; i++) {
result = result + i;
}
System.out.println("结果" + result);
}
public void calc(int n) {
int result = 0;
for (int i = 1; i <= n; i++) {
result += i;
}
System.out.println("结果" + result);
}
}
方法名，用小写驼峰法（匈牙利法）命名mySpeak。也也可以my_spaek
6.this只能使用在类的内部
public class Demo8 {
public static void main(String[] args) {
Dog dog1=new Dog(2,"小黄");
Perso p1=new Perso(dog1,38,"王力宏");
Perso p2=new Perso(dog1,8,"刘谦");
p1.showInfo();
p2.showInfo();
dog1.showInfo();
p1.dog.showInfo();
}
}
class Perso {
int age;
String name;
Dog dog;
public Perso(Dog dog,int age, String name) {
this.age = age;
this.name = name;
this.dog=dog;
}
public void showInfo() {
System.out.println("人名是"+name);
}
}
class Dog{
int age;
String name;
public Dog(int age,String name) {
this.age=age;
this.name=name;
}
public void showInfo(){
System.out.println("狗名"+this.name);
}
}
7.静态代码块只执行一次，当定义一个的类的时候信息已经写到代码区了。当实例化时已经跟静态块没有关系了。
java中规则：类变量原则上用类方法去访问
类方法中不能访问非静态变量
类变量小结：
A.什么时候需要用类变量
案例：定义学生类，统计学生共交多少钱？
用类变量，属于公共的属性
B. 类变量与实例变量的区别：
加上static称为变量或静态变量，否则成为实例变量
类变量是也类相关的，公共的属性
实例变量属于每个对象个体的属性
类变量可以通过类变量名和类名名访问直接访问
C.类方法结
什么时候需要类方法，
案例：定义学生类 统计学生共交多少钱
类方法属于与类相关的，公共的方法
实例方法属于每个对象个体的方法
类方法可以通过类名，类方法名直接访问
import java.security.PublicKey;
public class Demo3_2 {
static int i=1;
static{
System.out.println("A");
//静态代码块只执行一次
i++;
}
public Demo3_2()
{
System.out.println("B");
i++;
}
public static void main(String[] args) {
Demo3_2 t1=new Demo3_2();
System.out.println(t1.i);
Demo3_2 t2=new Demo3_2();
System.out.println(t2.i);
}
}
8. 封装
封装就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（成员方法），才能对数据进行操作
hashmp 在rt.java包里解压后路径rt\java\util
9.
方法重载-注意事项
A.方法名相同
B.方法的参数类型、个数，顺序至少有一项不同
C.方法返回类型可以不同
D.方法的修饰符可以不同
只有返回类型不一样，不能构成重载
10.多台-注意事项
java允许父类的引用变量引用它子类的实例
Animal animal=new Cat（）；
10.接口
package com.sq;
interface Usb{
// 声明两个方法
// 开始工作
int a=1;
public void start();
public void stop();
}
//编写照相机类并实现接口
//一个重要原则：当一个类实现了一个接口。
//就要求该类把这类的所有接口方法都实现
class Camera implements Usb{
public void start() {
System.out.println("我是相机，开始工作了");
}
public void stop(){
System.out.println("我是相机，停止工作了");
}
}
//接口结成别的接口
class Base{
}
interface Tt{
}
interface Son extends Tt{
}
class Phone implements Usb{
public void start() {
System.out.println("我是手机，开始工作了");
}
public void stop(){
System.out.println("我是手机，停止工作了");
}
}
//计算机
class Computer{
// 开始使用usb接口
public void useUsb(Usb usb) {
usb.start();
usb.stop();
}
}
public class Demo7 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(Usb.a);
Computer computer=new Computer();
Camera camera =new Camera();
Phone phone1=new Phone();
computer.useUsb(camera);
computer.useUsb(phone1);
}
}
//接口注意事项
//
// A.接口中所有方法都不能有主题
// B.一个类可以实现多个接口
// C. 接口中可有有变量,但是变量不能用private和protected修饰
// a.接口中的变量，本质上都是static的而且是final类型，不管你加不加static
// b.在Java开发中，我们经常把常用的变量，定义在接口中，作为全局变量使用，访问形式：接口名.变量名
// D.一个接口不能继承其他的类，但是可以继承变的接口
// E. 接口不能被实例化
// 抽象类重化工，可以有实现了的方法，接口中所有方法都不能被实现
11.实现接口VS 继承类
JAVA 的继承是单继承，依旧是一个类最多只有一个父类，这种单继承机制可保证类的纯洁性，比C++
中的多继承机制简介，但是不可否则人，对子类功能的扩展有一定的影响。所以我们认为，A。实现节后可以看错是对继承的一种补充，还有一点，继承是层级式的，不太灵活。，这种结构修改某个类就会打破这种继承的平衡，而接口就没有这样的麻烦。应为它只针对限时接口的类起作用，所以。B.实现接口可在不打破继承关系的前提下，对某个类功能扩展非常灵活
12.final
A.当不希望弗雷的某个方法被子类覆盖时，可以使用final关键字修饰
B.当不希望类的某个变量值被修改，可以用final修饰
C.当不希望类被继承时，可以用final修饰
D.final修饰的变量叫做常量，一般用XX_XX_XX来命名
E.final修饰的变量在定义时，必须赋值，并且以后不能再赋值
F.因为安全的考虑，类的某个方法不允许修改
G.类不会被其他的类继承
H.类变量是固定不变的，比如圆周率3.1415926
13. 五个常用的集合类：HashMap Hashtable , LinkedList. arrayList ，vector， stack
14.统计字符串* :HeLLoWoRLd2014China中的大写个数，小写个数和数字个数
public class Demo {
public static void main(String[] args) {
// 统计字符串中的大写个数，小写个数和数字个数
String s = "* :HeLLoWoRLd2014China";
int m = 0;
int n = 0;
int l = 0;
char[] a = s.toCharArray();
for (int i = 0; i < s.length(); i++) {
if (a[i] <= 'Z' && a[i] >= 'A') {
m++;
} else if (a[i] <= 'z' && a[i] >= 'a') {
n++;
} else if (a[i] <= '9' && a[i] >= '0') {
l++;
}
}
System.out.println("大写个数=" + m + ",小写个数=" + n + ",数字个数=" + l);
}
}
15.线程 Thread.sleep(1000); try catch 可以选中后右键，surround with， try catch/block添加
/*
* 演示如何通过继承Thread来开发线程
*/
public class Demo1 {
public static void main(String[] args) {
//创建一个Cat对象
Cat cat=new Cat();
//启动线程,会导致
cat.start();
}
}
class Cat extends Thread{
//重写run函数
public void run() {
while(true){
//休眠一秒
//1000表示1000毫秒。
//sleep就会让该线程进入到blocked状态，并释放资源
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("hello world");
}
}
}
16，线程
public class Demo2 {
public static void main(String[] args) {
Dog dog = new Dog();
//创建一个thread对象
Thread t=new Thread(dog);
t.start();
}
}
//dog里没有start方法，先创建一个thread对象，把dog放进去，有了这个实现接口，本身可run，但是没start方法，借助thread启动起来
//t.start是把狗的run方法运行起来
class Dog implements Runnable {
int times = 0;
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
times++;
System.out.println("晚上好" + times);
if (times == 10) {
break;
}
}
}
}
17.两个线程
package test3;
//两个线程同时跑
public class Demo10_3 {
public static void main(String[] args) {
Pig pig = new Pig(10);
Bird bird = new Bird(10);
Thread t1 = new Thread(pig);
Thread t2 = new Thread(bird);
t1.start();
t2.start();
}
}
// 打印
class Pig implements Runnable {
int n = 0;
int times = 0;
public Pig(int n) {
this.n = n;
}
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (Exception e) {
}
times++;
System.out.println("我是一个线程正在输出第" + times + "个Hello World");
if (times == n) {
break;
}
}
}
}
class Bird implements Runnable {
int n = 0;
int res = 0;
int times = 0;
public Bird(int n) {
this.n = n;
}
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (Exception e) {
// TODO Auto-generated catch block
}
res += (++times);
System.out.println("当前结果是" + res);
if (times == n) {
System.out.println("最后结果是" + res);
break;
}
}
}
}
18.JDK包含JRE、java的类库和java的工具（java编译器，javac.exe和java的解释执行器java.exe）。JRE，JDK是程序员做开发的时候必需要的，要去其他机器上运行，只需要装jre就可以。装了一个jdk，自带了jre。
19.class文件被java虚拟机加载到内存形成他自己的运行平台这样可以屏蔽不同操作系统，把class字节码文件加载到内存里
20.
package com.Test4;
import java.io.*;
public class In2 {
public static void main(String[] args) {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
System.out.println("请输入计算种类：\n1.四则运算：\n2.计算面积");
int i1 = Integer.valueOf(br.readLine());
if (i1 == 1) {
System.out.println("输入计算方法：\n1.加法\n2.减法\n3.乘法\n4.除法");
int i2 = Integer.valueOf(br.readLine());
System.out.println("输入两个数用空格隔开");
String[] s = br.readLine().split(" ");
double x = Double.valueOf(s[0]);
double y = Double.valueOf(s[1]);
switch (i1) {
case 1:
System.out.println(x + " + " + y + " = " + (x + y));
break;
case 2:
System.out.println(x + " - " + y + " = " + (x - y));
break;
case 3:
System.out.println(x + " * " + y + " = " + (x * y));
break;
case 4:
System.out.println(x + " / " + y + " = " + (x / y));
break;
}
} else {
System.out.println("选择图形：\n1.正方形\n2.矩形\n3.圆形\n4.三角形");
int i2 = Integer.valueOf(br.readLine());
System.out.println("输入两个数用空格隔开");
String[] s = br.readLine().split(" ");
double x = Double.valueOf(s[0]);
double y = Double.valueOf(s[1]);
switch (i2) {
case 1:
System.out.println("正方形的面积" + x * x);
break;
case 2:
System.out.println("矩形的面积" + x * y);
break;
case 3:
System.out.println("矩形的面积" + Math.PI * x * y);
break;
case 4:
double z = Double.valueOf(s[1]);
System.out.println("三角形的面积" + 0.5 * x * y);
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
23.JSP报错：The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path
解决方法：A.1、右击web工程-》属性或Build Path-》Java Build Path->Libraries-> Add Libray...->Server Runtime -》JBoss 7.1 Runtime 如果不能直接解决装Tomcat ，并将tomcat在eclipse中配置。
