尚学堂笔记

尚学堂Java学习笔记
============================
J2SDK&JRE
J2SDK:JAVA2 SOFTWARE DEVELOPMENT KIT
JRE:JAVA RUNTIME ENVIRONMENT
开发需要JDK，用户需要JRE
配置path和classpath
path：windows系统执行命令时需要搜的路径
classpath：Java在编译和运行的时候要找的class所在的路径
验证： java运行Java程序
javac编译Java程序
=============================
配置好环境变量后开始编写第一个Java的HelloWorld.java程序
public class HelloWorld
{
public static void main(String [] args)
{
System.out.println("Hello World!");
}
}
用javac HelloWorld.java来编译程序，编译成功后用java HelloWorld来执行程序。javac对文件名的大小写
不敏感，但是java对文件名大小写非常敏感！
==============================
JAVA APPLICATION初步
Java源文件以.java为扩展名，源文件的基本组成部分是类（class）。

 一个源文件中最多只能有一个public类，其他类的个数不限，如果源文件包含一个public类，它必须
按照该类文件命名。
Java应用程序执行入口是main()方法，它有固定的书写格式：public static void main(String []
args){......}。
Java语言严格区分大小写。
Java方法由一条条语句构成，每个语句以分号结束。
===============================
递归调用
//分析下面程序的运行结果
public class Test
{
public static void main(String [] args)
{
System.out.println(method(5));
}
public static int method(int n)
{
if (n==1)
return 1;
else
return n*method(n-1);
}
}
这是一个递归调用的过程，相信应该很轻松地看明白的。
还有一个例子是斐波那契数列：1，1，2，3，5，8，13，......
这个递归程序应该是：
import java.util.Scanner;

public class Fib
{
public static void main(String [] args)
{
System.out.println("Please input an integer number:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
System.out.println("The Fib result of "+n+" is :"+fib(n));
}
public static int fib(int n)
{
if (n==1||n==2)
{
return 1;
}
else
{
return fib(n-1)+fib(n-2);
}
}
}
那么他的非递归程序应该怎么写呢？
import java.util.Scanner;
public class Fib
{
public static void main(String [] args)
{

 System.out.println("Please input an integer number:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
System.out.println("The Fib result of "+n+" is :"+fib(n));
}
public static long fib(int index)
{
if (index==1||index==2)
return 1;
long f1=1;
long f2=1;
long f=0;
for (int i=0;i<index;i++)
{
f=f1+f2;
f1=f2;
f2=f;
}
return f;
}
}
=====================================================
标识符
1.Java对各种变量、方法和类等要素命名的时候使用的序列成为标识符。或者说凡是可以自己起名字的地方都
叫标识符，都遵守标示符的规则。
2.Java的命名规则：标识符由字母、下划线、$或数字组成。
标识符应以字母、下划线、$开头。

 Java标识符大小写敏感，长度无限制。
3.约定俗成：Java的标识符选取应见名知意。而且不能与Java语言关键字重名。
这些关键字有：abstract default if private this boolean do implements
protected throw break double import public throws byte else instanceof return
transient case extends int short try catch final interface static void char finally
interface strictfp volatile class float native super while const for new switch null
continue goto package synchronized
Java常量
1.Java常量值用字符串来表示，区分不同的数据类型。
包括整型常量eg.123，实型常量eg.3.14，字符商量eg.'a',字符创常量eg."Hello!",逻辑常量
true/false
2.注意：区分字符常量和字符串常量
“常量”这个名词还会用在另外其他语境中表示值不可变的变量。
Java变量
1.Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
2.Java程序中每一个变量都属于特定的数据类型，在使用之前必须对其声明，声明格式为：
type varName[=value][{,varName[=value]}]
eg. int i=100;
float f=12.9f;
double d1=0.123;
String s="hello!";
3.从本质上讲，变量其实是内存中的一块小区域，使用变量名来访问这块区域，因此，每一个变量在使用前必
须先声明，然后必须进行赋值，才能使用。
Java变量的分类
1.按被声明的位置分类
局部变量：方法或语句块内部的变量

 成员变量：方法外部，类内部定义的变量
2.按所属的数据类型划分
基本数据类型变量
引用数据类型变量
Java局部变量与成员变量
1.方法体内部声明的变量（包括形参）称为局部变量。方法体内部是指与方法对应的大括号内部，即，出了大
括号后就没有人认识括号里面的东西了。
2.在方法图外部，类内部声明的变量为成员变量。如：
public void method()
{
int i;
int j=i+5;//编译出错，因为i还未初始化
double d=3.14;
Dog dog=new Dog(22,7,1964);
}
注意：任何一个程序都不应该照抄，应该在看懂程序的基础上自己去编写。否则你自己就是一个TypeWriter
了。
======================================================
Java基本数据类型
1.Java中定义了4类8中基本的数据类型
逻辑型:boolean
文本型:char
整数型:int long byte short
浮点数型:float double
2.逻辑型Boolean

 Boolean类型适用于逻辑运算，一般用于流程控制。
Boolean类型只允许取值true或false，不可以是0或非0的整数来代替true/false。
3.字符型char
char类型数据用来表示通常意义上的“字符”。
字符常量为用单引号括起来的单个字符。
Java字符采用Unicode（全球语言统一编码）编码，每个字符占用两个字节，因而可以使用十六进制
编码形式表示。
Java语言中还允许使用转义字符‘/’来将其后的字符转变为其他的含义。
4.整数类型
Java个整数类型有固定的表数范围和字段长度，不受操作系统的影响，以保证Java程序的可移植性。
Java语言整数常量的三种表示形式：十六进制整数，以0X开头；十进制整数；八进制整数，以0开
头。
Java语言的整形常量默认为int类型，声明long型常量可以后加'l','L'。如：int i1=300;
long i2=2342L;
5.浮点类型
与整数类型相似，Java浮点类型有固定的表数范围和字段长度，不受平台影响。
Java浮点类型常用两种表示形式：十进制形式和科学计数法形式
Java浮点型常量默认为double型，如要声明一个常量为float 型的，则需要在后面加f或F，如double
d=123.9;//正确
float f=23.9;//报错！丢失精度

尚学堂java 笔记3
============================================
运算符
1.Java语言支持如下运算符
算术运算符：+，-，*，/，%，++，-- --
关系运算符：>，<，>=，<=，==，!=
逻辑运算符：!，&，|，^，&&，||
位运算符：&，|，^，~，>>，<<，>>>
赋值运算符：=
扩展赋值运算符：+=，-=，*=，/=
字符串连接运算符：+
2.“+”除用于算术加法外，还可以用于对字符转进行连接操作，如：int id=500+23;
String s="Hello"+" World!";
3."+"运算符两侧的操作数中只要有一个是字符串（String）类型的，系统会自动将另一个操作数转
换为字符串然后再进行连接。如：
int c=12;
System.out.println("c= "+c);
4.当进行打印时，无论任何类型，都自动转换为字符串进行打印。如：
Syetem.out.println(c);//此时c是字符串类型的
=============================================
表达式
1.表达式是符合一定语法规则的运算符和操作数的序列
2.表达式的类型和值。
对表达式中操作数进行运算得到的结果成为表达式的值。
表达式值的数据类型即为表达式的类型
3.表达式的运算顺序
按照运算符的有限级从高到低的顺序进行
优先级相同的运算符按照事先约定的结合方向进行

==============================================
三目条件运算符
1.语法格式为X?:Y,Z;
其中X为Boolean类型表达式,先计算X的值,若为TRUE,则整个三目运算的结果为表达式Y的值,否则为表达式Z的
值.举例略.
==============================================
语句
1.条件语句-根据不同的条件，执行不同的语句
if
if...else...
if...else if...else...
switch
2.循环语句-重复执行某些动作
for
while
do...while;
注意：只有一条语句需要执行时，可以省略大括号，但是建议不要省略。
3.for循环语句
for语句为如下形式：
for (表达式1；表达式2了表达式3){...}
eg.
//计算1！+2！+...10!
public class Test
{
public static void main(String [] args)
{
long result = 0;
long f = 1;

 for (int i=1; i<=10; i++)
{
f *= i;
result += f;
}
System.out.println("result=" + result);
}
}
===================================================
练习：1+3+5+...+99=?
public class OddSum
{
public static void main(String [] args)
{
int sum = 0;
for (int i=1; i<=99; i+=2)
{
sum += i;
}
System.out.println("1+3+5+...+99=" + sum);
}
}
==================================================
while & do while语句
1.while语句为如下形式
while(逻辑表达式){语句;...;}

2.do ... whiled语句为如下形式
do{语句；...;}while(逻辑表达式);//while后面有一个分号，不能丢掉
3.break语句用于终止某个语句块的执行，用在循环体汇总，可以强制退出循环。
4.continue语句用在循环体语句中，用于终止本次循环，继续下次循环。
==================================================
循环语句举例
1.输出1-100内前5个可以被3整除的数
public class Test
{
public static void main(String [] args)
{
int num = 0,i = 1;
while(i <= 100)
{
if (i%3 == 0)
{
System.out.println(i + " ");
num++;
}
if (num == 5) break;
i++;
}
}
}
2.输出101-200内的质数
public class Test

{
public static void main(String [] args)
{
for (int i=101; i<200; i+=2)
{
boolean f=true;
for (int j=2; j<i; j++)
{
if (i%j == 0)
{
f=false;
break;
}
}
if (!f) continue;
System.out.println(" " + i);
}
}
}
==================================================
switch语句
1.switch()
{
case XX:......
case YY:......
...
default:......
}

2.小心case穿透，推荐使用break语句
3.多个case可以合并到一起
4.default可以省略，但不推荐省略
5.Java中switch只能探测到int类型值
===================================================
方法
1.Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，声明格式为：
[修饰符1 修饰符2.。。]返回值类型 方法名（形参列表）{Java语句。。。}
2.形式参数：在方法被调用时用于接收外界输入的数据
实参：调用方法时实际传给方法的数据
返回值：方法在执行完毕后返还给调用她的环境的数据
返回值类型：事先约定的返回值的数据类型，如无返回值，必须声明为void
3.Java语言中使用下述形式调用方法：对象名.方法名（实参列表）
实参的数目、数据类型和次序必须和所调用方法的形参列表项匹配
return语句终止方法的运行并指定要返回的数据
4.Java中进行函数调用中传递参数时，遵循只专递的原则
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。

尚学堂Java笔记4
=============================================
面向对象的设计思想：
1.面向对象的基本思想是：从现实世界种客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用
人的自然思维方式。
2.面向对象更加强调运用人类在日常的思维逻辑中经常采用的方法与原则，如抽象、分类、继承、聚合、多态
等。
3.（重要）作为面向对象的思维方式，不应该考虑第一步做什么，第二步做什么，而应该考虑，在这个问题里
包含哪些类，哪些对象；然后考虑这些类中应该包含哪些属性和方法；再考虑类和类之间存在什么关系（关
联、继承、组合、聚集、接口、多态等）。
=============================================
对象和类的概念
1.对象用计算机语言对问题域中事物的描述，对象通过属性（attribute）和方法（method）来分别对应事物
所具有的静态属性和动态属性。
2.类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的静态和动态属性。
3.类可以看成一类对象的模板（template），对象可以看成该类的一个具体实例（instance）。
=============================================
Java与面向对象
1.对象的Java程序的核心，在Java程序中“万事万物皆对象”。
2.对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体。
3.类用来创建同一类型的对象的模板，在一个类中定义了该类对象所应具有的成员变量以及方法。
4.J2SDK提供了很多类供编程人员使用，贬称和人员也可以自定义自己的类。
以后约定，成员变量就是属性，方法就是函数
==============================================
Java类的定义
//用class关键字定义一个类

class person
{
//成员变量
private int id;
private int age=20;
//方法定义
public int getAge(){return age;}
public void setAge(int i){this.age=i;}
public int getId(){return id;}
}
成员变量
1.成员变量可以使Java语言中任何一种数据类型（包括基本类型和引用类型）
2.在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。其默认值如下：
byte 0
short 0
int 0
long 0L
char '/u0000'
float 0.0F
double 0.0D
boolean false
所有引用类型 null
但是局部变量必须对其进行初始化，否则将不能通过编译。
3.成员变量的作用范围为整个类体。
======================================================
引用
1.Java语言中除基本类型之外的变量类型都称之为引用类型。

2.Java中的对象是通过引用对其操作的。
/*
*声明了一个String类型的引用变量，但是没有使他指向一个对象
*/
String s;
/*使用new语句创建了一个String类型的对象并用s指向它，以后可以通过s完成对其的操作。
*/
s = new String("Hello World!");
3.在内存中区分类和对象：类是静态的，位于代码区；对象是new出来的，位于堆内存，类的每个成员变量在
不同的对象中都有不同的值（静态变量除外），而方法只有一份，执行的时候才占内存。
4.对象使用new关键字创建对象。
5.使用对象（引用）.成员变量或来引用的成员变量 。
6.使用对象（引用）.方法（参数列表）来调用对象的方法。
7.同一类的每个对象有不同的成员变量的存储空间。
8.同一类的每个对象共享该类的方法。
=================================================
构造函数
1.使用new+构造函数来创建一个新对象
2.构造函数是定义在Java类中的一个用来初始化对象的函数
3.构造函数与类名同名且没有返回值
如：public class Person
{
int id;
int age=20;
Person(int id, int age)
{
id=_id;

 age=_age;
}
public int getID(){return id;}
public void setID(int id){this.id=id;}
public int getAge(){return age;}
public void setAge(int age){this.age=age;}
public static void main(String [] args)
{
Person tom=new Person(1, 23);
Person jack=new Person(2,22);
System.out.print("Tom's id and age:"+tom.getID()+" "+tom.getAge());
System.out.print("/nJack's id and age:"+jack.getID()+" "+jack.getAge());
}
}
当没有指定构造函数时，编译器会为类自动添加一个形如：类名（）{}的构造函数
当你添加了构造函数后，系统就不再构造方法了，除非显示地写一个重载的构造方法。
==================================================
约定俗成的命名规则
1.类名首字母大写
2.变量名和方法名首字母小写
3.运用驼峰标识
==================================================
方法的重载

1.方法的重载是指一个类中可以定义有相同的名字，但是参数不同的多个方法。调用时会根据不同的参数表选
择对应的方法。
如：class Person
{
private int id;
private int age;
Person(int _id, int _age){id=_id; age=_age;}
void info(){System.out.println("My id is: "+id);}
void info(String s){System.out.println(s+" "+id+",and my age is "+age);}
}
public class TestOverload
{
public static void main(String [] args)
{
Person tom=new Person(20092402, 23);
tom.info();
tom.info("Hello!! My name is Tom,My id is:");
}
}
--------------------------------------------------------
另一个例子：
public class TestOverload
{
public static void main(String [] args)
{
Person tom = new Person();
Person jack = new Person(20092402, "Jack");
Person jerry = new Person(20092401,23);

 tom.display();
jack.display();
jerry.display();
int age = 25;
tom.setAge(age);
tom.display();
jack.setAge(++age);
jack.display();
}
}
class Person
{
private int id;
private int age;
private String name;
Person(){id = 0;age = 20;}
Person(int _id,String _name){id = _id;age = 21;name = _name;}
Person(int _id, int _age){id = _id; age = _age;}
public void setID(int _id){id = _id;}
public void setAge(int _age){age = _age;}
public void setName(String _name){name = _name;}
public int getID(){return id;}
public int getAge(){return age;}

 public String getName(){return name;}
void display()
{
System.out.println("ID:" + id + " Name:" + name + " Age:" + age);
}
}

尚学堂Java笔记6
==================================================
访问控制
1.Java权限修饰符public protected private置于类的成员定义之前，用来限定其他对象对该类对象成员的访
问权限。
————————————————————————------------------------------------
修饰符 内部类 同一个包 子类 任何地方
---------------------------------------------——————--------------------------------------
private Yes
------------------------------------------------------------------------------------------------
---
default Yes Yes
------------------------------------------------------------------------------------------------
---
protected Yes Yes Yes
------------------------------------------------------------------------------------------------
----
public Yes Yes Yes Yes
------------------------------------------------------------------------------------------------
-----
2.对于class的权限修饰只可以用public和default。
public类可以在任意地方被访问
default类只可以被同一个包内部的类访问。
======================================================
类的继承与权限控制
1.Java中使用extends关键字实现类的继承机制
2.通过继承，子类自动拥有了基类(super class)的所有成员（变量和方法）。

3.Java只支持单继承，不允许多继承，也就是说一个子类只能有一个基类，一个基类可以派生出多个子类。
如：
class Parent
{
private int n_private=1;
private int n_friendly=2;
protected int n_protected=3;
public int n_public=4;
}
class Child extends Parent
{
super();
public void f()
{
n_private = 10;
n_friendly = 20;
n_protected = 30;
n_public = 40;
}
}
===================================================
方法的重写
1.在子类中可以根据需要对基类中集成的方法进行重写
2.重写方法必须和被重写方法有相同的方法名称、参数列表和返回类型
3.重写方法不能使用比被重写方法更严格的访问权限
4.如：
class Animal

{
protected double weight;
protected double height;
protected String name;
public void setName(String _name){name=_name;}
public void setWeight(double _weight){weight=_weight;}
public void setHeight(double _height){height=_height;}
public String getName(){return name;}
public double getWeight(){return weight;}
public double getHeight(){return height;}
public String run()
{
return "Animal is running....";
}
}
class Cat extends Animal
{
Cat()
{
name="MiaoMiao";
weight=2.5;
height=0.58;
}
public String run()//重写方法
{
return "Cat is running....";

 }
}
class Dog extends Animal
{
Dog()
{
name="WangWang";
weight=6.5;
height=0.98;
}
public String run()
{
return "Dog is running....";
}
}
public class TestAccess
{
public static void main(String [] args)
{
Cat c=new Cat();
c.setName("SuperCat");
c.setWeight(40.9);
System.out.println("Cat's name is :"+c.getName()+" Cat's weight is
:"+c.getWeight());
System.out.println("Cat's height is :"+c.getHeight());
System.out.println(" Behavior: "+c.run());

 Dog d=new Dog();
d.setName("SuperDog");
d.setWeight(70.9);
System.out.println("Dog's name is :"+d.getName()+" Dog's weight is
:"+d.getWeight());
System.out.println("Dog's height is :"+d.getHeight());
System.out.println(" Behavior: "+d.run());
}
}
记住：当你要重写方法时，要去父类去拷贝，不然很容易出错。
======================================================
super关键字
在Java类中使用super来引用父类中的成分。
如：
class Father
{
public int value;
public void f()
{
value = 100;
System.out.println("Father class.value="+ value);
}
}

class ChildClass extends Father
{
public int value;
public void f()
{
super.f();
value = 200;
System.out.println("ChildClass.value="+value);
System.out.println(value);
System.out.println(super.value);
}
}
public class TestSuper
{
public static void main(String [] args)
{
ChildClass cc=new ChildClass();
cc.f();
}
}
=================================================
继承中的构造方法
1.子类的构造的过程中必须调用其基类的构造方法
2.子类可以在自己的构造方法中使用super（argument_list）调用基类的构造方法。
使用this（argument_list）调用本类的另外的构造方法。
如果调用super必须写在子类构造方法的第一行。
3.如果子类的构造方法中没有显示地调用基类的构造方法，则系统会默认调用基类的无参数的构造方法

4.如果子类构造方法中既没有显示调用基类的构造方法，而积累中有没有无参数的构造方法，则编译出错！
如：
class SuperClass
{
private int n;
SuperClass()
{
System.out.println("SuperClass constructed!");
}
SuperClass(int n)
{
System.out.println("SuperClass ("+ n + ")");
this.n = n;
}
}
class SubClass extends SuperClass
{
private int n;
SubClass()
{
super(300);
System.out.println("SubClass constructed!");
}
SubClass(int n)
{

 System.out.println("SubClass ("+ n +")");
this.n = n;
}
}
public class TestSuperSub
{
public static void main(String [] args)
{
//调用子类第二个构造方法时，因为没有super（），则系统会默认调用父类的无参构造方
法。
SubClass s1 = new SubClass();
//调用子类的第一个构造方法时，有super（300），则调用父类的有参构造方法。
SubClass s2 = new SubClass(29);
}
}
显示结果为：
SuperClass（300）
SubClass constructed!
SuperClass constructed!
SubClass(29)
===============================================================
//TestTeacher.java
class Person

{
private String name;
private String location;
Person(String name)
{
this.name=name;
location="Beijing";
}
Person(String name, String location)
{
this.name=name;
this.location=location;
}
public String info()
{
return "Name:"+name+"/tLocation:"+location+"/t";
}
}
class Teacher extends Person
{
private String capital;
Teacher(String name, String capital)
{
this(name,"Beijing",capital);

 }
Teacher(String name,String location,String capital)
{
super(name,location);
this.capital=capital;
}
public String info()
{
return super.info()+"capital:"+capital+"/t";
}
}
class Student extends Person
{
private String school;
Student(String name, String school)
{
this(name,"Beijing",school);
}
Student(String name, String location, String school)
{
super(name,location);
this.school=school;
}

 public String info()
{
return super.info()+"school:"+school+"/t";
}
}
public class TestTeacher
{
public static void main(String [] args)
{
Person p1=new Person("A");
Person p2=new Person("B","shanghai");
Student s1=new Student("C","S1");
Student s2=new Student("C","shanghai","S2");
Teacher t1=new Teacher("D","Professor");
System.out.println(p1.info());
System.out.println(p2.info());
System.out.println(s1.info());
System.out.println(s2.info());
System.out.println(t1.info());
}
}
下面内容见http://www.gjrencai.com/newsShow.asp?dataID=1236