类与对象

类的声明和实例化

public class Cat
{
String name;//这是字段
int age;
char gender;
//【方法】返回某一类事物的个体可以干什么
public void eat(String foodName){
System.out.println(“猫吃”+foodName);
}

public static void main()
{
Cat c=new Cat();//声明一个cat类型变量，开辟内存空间，Cat类型决定空间大小
c.name=”tom”//c通过变量储存找到地址
c.age=5;
c.eat(“小黄鱼”);//main调用c的eat方法
}
}
当一个类中没有显示书写任何构造方法时，
编译器会为当前类添加一个默认的构造方法
该方法public修饰，与类同名，无参。

eg:找100以内的质数：
for(int i=2;i<100;i++)
{
for(int j=2;j{
if(i%j==0)
{
break;
}
if(j>1/2)
{System.out.println(i);}
}
}

方法都在栈里
—>一个方法产生一个栈帧，栈帧都在栈中。
new在堆内存中创建对象的过程中被称为实例化。

类是抽象的一类事物
对象某个事物的一个具体个个体如一个叫张三的人。
字段本质上就是一个变量，是属于类的一个成员，也称成员变量。
某一种事物的每个个体具有的特征可以使用类的字段表示。如：姓名，性别

Static

属于个体的字段被称作实例变量（实例字段） 无static修饰，伴随示实例存在的。

   属于类的字段叫类变量（静态变量）eg: public static String home；<br />只要发生改变，则所有类的实例化都会更改。<br />静态变量伴随类存在的：类被加载就存在，类卸载就消失）

实例变量通过 “对象名.字段名”访问 first.home
或 类名+字段名： Person.home (推荐使用)

在一个类中static修饰的成员是属于类的。
static 修饰的方法是类方法（静态方法）
没有static修饰的方法是实例方法；

静态方法：

1.通过类名访问：类名.方法名（）;
2.通过对象名访问：对象名.方法名（）；
实例方法：
只能通过对象名.方法名（）访问

this

实际上相当于引用于一个变量，用于引用当前对象本身。
this也仅限在本类中使用（与实例有关代码中）即static不行。

eg:
public class Master {
private String name ;
public void introduce() {
System.out.println( “introduce : “ + System.identityHashCode( this ) );
System.out.println( “大家好，我是” + this.name );
}
public static void main(String[] args) {
Master a = new Master();
System.out.println( “main : “ + System.identityHashCode( a ) );
a.name = “钟南山” ;
a.introduce(); // 此时在 introduce 方法内部的 this 就表示 a 对应的实例，哪里调用方法this就表示圆点前的对象
System.out.println( “~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~” );
Master b = new Master();
System.out.println( “main : “ + System.identityHashCode( b ) );
b.name = “钱三强” ;
b.introduce(); // 此时在 introduce 方法内部的 this 就表示 b 对应的实例
}
}

递归 （涉及一点异常抛出）

一个方法内部调用自身
public class Recursion {
// 使用递归方式求 N 的阶乘
public long factorial( long n ) {
if( n < 0 ) {
// 创建一个异常对象 ( RuntimeException 是一个异常类 )
RuntimeException ex = new RuntimeException( “你丫数学是跟谁学的?负整数还有阶乘?” );
throw ex ; // 使用 throw 抛出 异常对象
}
if( n == 0 || n == 1 ) {
return 1L ; // 数学中规定 0！ 和 1！都是 1
} else {
// 一个方法内部调用了它自己
return n factorial( n - 1 ) ; // 整数 n 乘以 n - 1 的阶乘 就是 n 的阶乘
}
}
public static void main(String[] args) {
Recursion x = new Recursion();
int n = 20 ;
// main 调用 x 的 factorial 方法 求 n 的阶乘 并返回 n 的阶乘
long f = x.factorial( n );
// factorial( 6 ) -> 6 factorial( 5 ) -> 5 factorial( 4 ) -> 4 factorial( 3 ) -> 3 factorial( 2 ) -> 2 factorial(1)
// 6 120 <= 5 24 <= 4 6 <= 3 2 <= 2 1
*System.out.println( n + “ 的阶乘等于 “ + f );
}
}

可变长参数

在一个方法的参数列表中，以…形式定义的参数是可变长参数
之多只有一个可变长参数
可当作数组使用
null并不是长度为0

public class Bus {
/
在 一个方法的参数列表中，以 … 形式定义的参数就是可变长参数
在一个方法的参数列表中至多出现一个 可变长参数，并且必须是形参列表中的最后一个
*/
public void launch( String driver , String…passenger ){
System.out.print( driver + “师傅为您服务” );
// 调用 launch 方法时，如果可变长参数部分直接传入的就是 null ，则导致 passenger 变量就是 null
if( passenger != null ) {
// System.out.print( “【 length : “ + passenger.length + “ 】” );
// 在 方法内部 ，可变长参数可以当做数组来使用
if( passenger.length > 0 ) {
System.out.print( “ , 车上的乘客有: “ );
for ( int i = 0 ; i < passenger.length ; i++) {
System.out.print( passenger[ i ] + “ “ );
}
}
}
System.out.println();
}
public static void main( String[] args ) {
Bus b = new Bus();
String driver = “卡巴斯基” ;
b.launch( driver ); // 注意第二个参数没有指定
b.launch( driver , “孙悟空” ); // 在 可变长参数 中传入了一个参数
b.launch( driver , “孙悟空” , “牛魔王” , “奔波儿灞” ); // 在 可变长参数 中传入了三个参数
b.launch( driver , null** );
}
}