[Java知识库]java学习总结

Java中的println和printf的区别：

println是用于输出参数内容，然后换行，其参数个数固定为一个。
printf是用于输出带各种数据类型的占位符的参数，其参数个数是不定的。

package testecclipse;
public class addtest {
	public static void main(String[] args) {
	int m=12,n=34;
	//int sum;
	//sum= m++;
	System.out.println(m++);
	System.out.printf("%d%d",m++,++n);
	System.out.printf("%d%d\n",n++,++m);
	//sum = ++n;
	//System.out.println(++n);
	}
}

Java SE 面向对象详解：

方法不能嵌套定义，可以嵌套调用方法。

1. 面向对象程序设计的三大基本特征： 继承（Inheritence）、封装（Encapsulation）、多态
   （Polymorphism）
2. 封装： 类包含了数据与方法，将数据与方法放在一个类中就构成了封装。
3. 如何定义类？
   修饰符 class 类的名字
   {
   //类的内容（包含了属性与方法）
   }
4. 方法。如何定义方法？
   修饰符 返回类型 方法名称（[参数 1， 参数 2， 参数 3…]）
   {
   //方法体
   }
5. main方法是整个 Java程序的入口点，如果类的定义中没有 main方法，则程序无法执行。
6. 方法定义不能嵌套，也就说不能在一个方法中定义另外一个方法。方法只能定义在类中。
7. 关于方法的执行：首先需要定义方法，接下来就可以使用方法（调用方法），当方法调
   用完毕后，方法可以返回值。 方法到底是否返回值是由方法的定义决定的。
8. 如何生成对象？通过类来生成对象（通常使用 new 关键字来生成对象）。

public class Person{ }
类名 变量名 = new 类名();
Person person = new Person();
Person person2 = new Person();
Person person3 = new Person();

10. 方法调用需要通过对象来完成，方法调用的形式是：
    对象变量.方法名([参数值 1， 参数值 2， 参数值 3….]);
11. 关于方法的注意事项：
    1） 在方法定义中，方法的返回类型与 return 后面的变量或常量类型保持一致。
    2） 在方法调用时，给方法传递的参数需要与方法定义时的参数保持一致（参数个数一
    致，参数类型一致）。
    3） 方法定义时的返回类型与接收方法返回值的变量类型保持一致。
12. public int add(int a, int b)
    {
    return a + b;
    }
    方法定义时的参数叫做形式参数。
    int a = test.add(8, 3);
    方法调用时所赋予的具体值叫做实际参数。
13. 关键字 void 表示方法不返回值。
14. 如果方法不返回值，那么声明方法的时候使用 void 关键字， 在方法定义中可以有两种
    情况实现不返回值：
    a) 不使用 return 语句。
    b) 使用 return，但 return 后面没有任何值或者变量， return 后面只有一个分号，表示
    退出方法，返回到方法的调用端。
    使用方式：
    return;
    14.如果一个java源文件中定义了多个类，那么这些类中最多只能有一个类是public的，换句话说，定义的多个类可以都不是public的。
    15.在java中进行方法的参数传递时，无论传递的是原生数据类型还是引用类型，参数传递方法统一是传值（pass by value）.Java中没有传引用（pass by reference）的概念。
    第16讲 方法重载剖析
    1.引用回顾

package testecclipse;
public class ParamTest3 {
	public void change(Person person,Person person2) {
		person.name="lisi";
		person2.name="wangwu";
		
	}
	public static void main(String[] args) {
		Person person = new Person();//创建新对象person指向其地址
		person.name="zhangsan";//将person指向的地址内容赋值为zhangsan
		
		Person person2=person;//person2指向person
		
		ParamTest3 test=new ParamTest3();
		
		test.change(person, person2);
		
		System.out.println(person.name);
		
	}
	
}
class Person{
	String name;
}

2.类和对象
类的格式：
修饰符 class 类名{
类的成员变量
类的成员方法
}
类包括成员变量（用于描述对象的属性）和成员方法（描述对象的行为）。
成员变量格式：修饰符 数据类型 成员变量名
调用成员变量，使用（.）操作符，调用格式：对象名.成员变量名(属性)；
成员方法格式：
修饰符 返回类型 方法名（[参数类型 参数名]）[throw 异常列表]{
方法体;
}
调用成员方法：对象名.成员方法名();
创建对象：类名 对象名=new 类名([参数]);
new 关键字在生成对象时完成了三件事情：
a) 为对象开辟内存空间。
b) 调用类的构造方法。
c) 将生成的对象的地址返回。
package testecclipse;
//方法参数传递、类、成员变量、方法调用

public class PeopleTest {
	int age;//成员变量
	public void change2(PeopleTest p) {//在括号里先申明一个PeopleTest类的对象为p
		p =new PeopleTest();//然后方法里面创建对象p
		p.age++;
	}
	public void change3(PeopleTest p,int i) {//方法的参数可以是类的对象，也可以是变量,其实类的对象也就是变量
		p.age++;
		i++;//i的值没有意义，不会影响age属性。
	}
	public void change0(int i){
		i++;	
	}
	public static void main(String[] args) {
		//调用三种方法：change2 change3 change0比较输出结果
		/*
		PeopleTest people=new PeopleTest();
		int a=0;
		people.change0(people.age);//age是int型的，
		//调用成员变量，使用(.)操作符，格式：对象名.成员变量名(属性),eg：people.age
		System.out.println(people.age);
		*/
		
		/*
		PeopleTest people =new PeopleTest();
		people.change2(people);
		System.out.println(people.age);
		*/
		PeopleTest people =new PeopleTest();
		people.change3(people,people.age);//i的值没有意义，不会影响age属性。
		System.out.println(people.age);
	}
}

5.方法重载（Overload）
表示两个或多个方法名字相同，但方法参数不同。方法参数不同有两层含义：
（1）参数个数不同
（2）参数类型不同。注意：方法的返回值对重载没有任何影响

package testecclipse;
public class OverloadTest {
//下面两个方法add同名，但参数不同，则这两个方法构成重载关系。（方法名相同，参数类型或者参数个数不同，则为方法重载）
	public int add(int a,int b) {
		return a+b;
	}
	public int add(int a,int b,int c) {
		return a+b+c;
	}
	public static void main(String[] args) {
		OverloadTest test =new OverloadTest();
		
		int result =test.add(1, 2);
		int result2=test.add(1,2,3);
		
		System.out.println(result);
		System.out.println(result2);
	}
}

6.构造方法的重载
构造方法重载：只需看参数即可。如果想在一个构造方法中调用另外一个构造方法，那么可以使用this() 的方式调用，this()括号中的参数表示目标构造方法的参数。this调用构造方法，this()必须要作为构造方法的第一条语句。换句话说，this()前面不能有任何可执行的代码
6.1方法和构造方法的区别：
6.1.1构造方法
java构造函数，也叫构造方法，是java中一种特殊的函数。函数名与类相同，无返回值。
特点：1.方法名称和类名相同
2.不用定义返回值类型（不同于void类型返回值，void是没有具体返回值类型；构造函数是连类型都没有）
3.不可以写return语句（返回值类型都没有，也就不需要return语句）
作用：一般用来初始化成员属性和成员方法的，即new对象产生后，就调用了对象了属性和方法。
构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句。
而一般函数是对象调用才执行，用".方法名“的方式，给对象添加功能。
一个对象建立，构造函数只运行一次。 而一般函数可以被该对象调用多次。
注：一般函数不能调用构造函数，只有构造函数才能调用构造函数。
6.1.2构造方法与一般方法在写法上的不同：
（1）构造方法：
public(修饰符) class（定义类的关键字） Test（类名）(){
//无参
Test（类名）（）{ }
//带一个参数
Test（类名）（String(变量类型) name（变量名））{ }
}
（2）一般方法：
定义类：

public(修饰符) class（定义类的关键字） Test（类名）(){
      private(修饰符) static(修饰符) String(变量类型) s（变量名） = "hello world";
下面是方法的定义：
public(修饰符)  static(修饰符)  void(返回值类型)  main（方法名）（String[] args（参数）){
             System.out.println(s);（代码语句）
      }
}

代码示例:

package testecclipse;
public class ConstructorOverload {
	类名和方法名相同，是构造方法，无返回值.一般用来初始化成员属性和成员方法的
	//构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句。
	public ConstructorOverload() {//构造函数
	//构造方法重载：只需看参数即可。
	//如果想在一个构造方法中调用另外一个构造方法，那么可以使用this() 的方式调用，this()括号中的参数表示目标构造方法的参数。
		this(3);//调用含一个参数的这个构造方法
		System.out.println("test");	
		//this(3);//this调用构造方法，this()必须要作为构造方法的第一条语句。换句话说，this()前面不能有任何可执行的代码
	}
	public ConstructorOverload(int i) {//构造函数
		System.out.println(++i);
	}
	public static void main(String[] args) {
		ConstructorOverload col =new ConstructorOverload();
		/*构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句。
		而一般函数是对象调用才执行，用".方法名“的方式，给对象添加功能。*/
	}
}

.继承（Inheritance）

Java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类【基类，base class】，继承的类叫做子类），java中的继承使用extends关键字
7.1.当生成子类对象时，java默认首先调用父类的不带参数的构造方法，然后执行该构造方法，生成父类的对象。接下来再去调用子类的构造方法，生成子类的对象。
换句话说，【要想生成子类的对象，首先需要生成父类的对象，没有父类的对象就没有子类对象，比如：没有父亲就没有孩子】

package testecclipse;
public class Child extends Parent {//在调用构造方法Child()时，由于继承了父类，先调用父类方法
//所以该代码块先输出parent后输出child	
	public Child() {
		//下面两个方法构成重载
	public Parent(int i) {
		System.out.println("parent");
	}
	public Parent() {
		System.out.println("parent");
	}
}
class Parent{
	//下面两个方法构成重载
	public Parent() {
		System.out.println("parent");
	}
}

7.2super关键字：super表示对父类对象的引用
7.3如果子类使用super（）显式调用父类的某个构造方法，那么在执行的时候就会寻找与super（）所对应的构造方法而不会再去寻找父类的不带参数的构造方法。
与this一样，super也必须要作为构造方法的第一条一句执行。前面不能有其他可行性语句

package testecclipse;
public class Child extends Parent {//在调用构造方法Child()时，由于继承了父类，先调用父类方法
//所以该代码块先输出parent后输出child	
	public Child() {
		super(1);//super()显示调用父类构造方法,执行时就会寻找与super（）所对应的构造方法而不会再去寻找父类的不带参数的构造方法	
		System.out.println("child");
	}
	public static void main(String[] args) {
		Child child= new Child();//创建对象child后立马调用Child()构造方法
	}
}
class Parent{
	//下面两个方法构成重载
	public Parent(int i) {
		System.out.println("parent");
	}
	public Parent() {
		System.out.println("parent");
	}
}
/*
 * this()调用当前构造方法
 * super()显示调用父类构造方法
 */

7.4继承的特点
（1）父类有的，子类也有，
（2）父类没有的，子类可以增加
（3）父类有的，子类可以改变

package testecclipse;
public class InheritenceTest {
	public static void main(String[] args) {
		Apple apple =new Apple();
		System.out.println(apple.name);
	}

}
class Fruit{
	String name="fruit";
	
}
class Apple extends Fruit{
	String name="apple";
	
}

7.5继承的注意事项
（1）构造方法不能被继承
（2）方法和属性可以被继续
（3）子类的构造方法隐式地调用父类的不带参数的构造方法
（4）当父类没有不带参数的构造方法时，子类需要使用super来显式地调用父类的构造方法，super指的是对父类的引用。
（5）super管家字必须是构造方法的第一行语句。
第18讲 多态剖析
1.方法重写（Override）
又叫复写，子类与父类的方法返回类型一样、方法名称一样，参数一样，这样我们说子类与父类的方法构成了重写关系。

package testecclipse;
public class InheritenceTest2 {
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.run();
	}

}
class Animal{
	public void run() {//与子类Dog的run方法构成重写关系，
		//子类与父类的方法返回类型一样、方法名称一样，参数一样，
		System.out.println("animal is running");
	}
}
class Dog extends Animal{
	public void run() {
		super.run();//调用父类的方法
		System.out.println("dog is running");
		super.run();//调用父类的普通方法，所以这句哪一行都可以，只是执行的顺序不同。
		/*但是调用构造方法一定要·放在该方法的第一行，先创建实例；
		 * 而普通方法调用前已经有对象实例了，所以放哪一行都可以
		 */
	}
	
}

2.方法重写与方法重载的关系
重载发生在同一个类内部的两个或·多个方法，重写发生在父类与子类之间（没有继承就没有重写）。
3.当两个方法形成重写关系时，可以在子类方法中通过super.run()形式调用父类的run方法，其中super.run()不必放在第一行语句，因此此时父类对象已经构造完毕，先调用父类的run（）方法还是先调用子类的run（）方法是根据程序的逻辑决定的。
3.在定义一个类的时候，如果没有显式指定该类的父类，那么该类就会继承java.lang.Object类（JDK提供的一个类，Object类是java中所有类的直接或间接父类。）
4.多态（Polymorphism）
我们说子类就是父类（玫瑰是花，）因此多态的意思就是：父类型的引用可以指向子类的对象
Flower类型的对象指向了Rse类型的对象（因为Rose也就是花，eg：男人是人，但不能说人是男人）
Java SE Lesson2
1、多态：父类型的引用可以指向子类的对象
2.Parent1 p=new Child1);
当使用多态方式调用方法时，首先检查父类中是否有sing（）方法，如果没有则编译错误；如果有，再去调用子类的sing（）；

package testecclipse;

public class PolyTest {
	public static void main(String[] args) {
//		Parent1 parent= new Parent1();
//		parent.sing();
		
		Parent1 p=new Child1();//多态，父类型的引用可以指向子类的对象，父类型中必须有这个方法，否则父类型中找不到这个方法
		p.sing();
	}

}

class Parent1{
	public void sing() {//与Child中的sing（）方法构成重写关系
		System.out.println("parent is singing");
	}
}
class Child1 extends Parent1{
/*
 * public void sing() {
 * 		System.out.println("child is singing");
    }
 */
}

3.一共有两种类型的强制类型转换：
（1）向上类型转换（upcast）：比如说将Cat类型转换为Animal类型，即将子类型转换为父类型。多于向上类型转换，不需要显式指定。
（2）向下类型转换（downcat）：比如将Animal类型转换为Cat类型。即将父类型转换为子类型。对于向下类型转换，必须要显式指定（必须要使用强制类型转换）。

package testecclipse;

public class PolyTest2 {
	public static void main(String[] args) {
		Animal1 a=new Dog1();//多态，父类型的引用可以指向子类的对象
		Dog1 dog=(Dog1)a;//强制类型转换，向下类型转换
		//父类型Animal1的引用a指向子类型Dog1的对象，则父类型的a可以转换成子类型Dog的引用
		dog.sing();
		
		Animal1 b=new Cat1();
		Cat1 d=(Cat1)b;
		d.sing();

//		Animal1 c=new Cat1();
//		Cat1 e=(Dog1)c;//这句转换是错误的，只能转换成Cat1类型的
//		e.sing();
		
	}

}
class Animal1{
	public void sing() {
		System.out.println("animal is singing");
	}
}
class Dog1 extends Animal1{
	public void sing() {
		System.out.println("dog is singing");
		
	}
}
class Cat1 extends Animal1{
	public void sing() {
		System.out.println("cat is singing");
	}
}


package testecclipse;

public class PolyTest2 {
	public static void main(String[] args) {
		//向上类型转换
		Cat1 cat=new Cat1();
		Animal1 animal=(Animal1)cat;
		animal.sing();
		
		//向下类型转换
		Animal1 a=new Cat1();
		Cat1 c=(Cat1)a;
		c.sing();
	}

}
class Animal1{
	public void sing() {
		System.out.println("animal is singing");
	}
}
class Dog1 extends Animal1{
	public void sing() {
		System.out.println("dog is singing");
		
	}
}
class Cat1 extends Animal1{
	public void sing() {
		System.out.println("cat is singing");
	}
}

package testecclipse;

public class PolyTest4 {
	/*
	public void run(BMW bmw) {
		bmw.run();
	}
	public void run(QQ qq) {
		qq.run();
	}
	*/
	public void run(Car car) {//多态
		car.run();
		
	}
	
	public static void main(String[] args) {
		/*
		PolyTest4 test=new PolyTest4();
		BMW bmw=new BMW();
		test.run(bmw);
		
		QQ qq=new QQ();
		test.run(qq);
		*/
		PolyTest4 test=new PolyTest4();
		Car car=new BMW();//多态，父类型的引用可以指向子类的对象
		test.run(car);
		
		QQ qq=new QQ();
		test.run(qq);
	}

}
class Car{
	public void run() {
		System.out.println("car is running");
	}
}

class BMW extends Car{
	public void run() {
		System.out.println("BMW is running");
	}
	
}
class QQ extends Car{
	public void run() {
		System.out.println("QQ is running");
	}
	
}

4.抽象类（abstract class）
使用了abstract关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说，不能new出来一个抽象类的对象（实例）
5.抽象方法（abstract method）
：使用abstract关键字所修饰的方法。抽象方法需要定义在抽象类中。相对于抽象方法，之前所定义的方法叫做具体方法（有声明，有实现）
6.如果一个类包含了抽象方法，那么这个类一定是抽象类。
7.如果某个类是抽象类，那么该类可以包含具体方法（有声明有实现）
8.如果一个类中包含了抽象方法，那么这个类一定要声明成abstract class，也就是说，该类一定是抽象类。反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法。

package testecclipse;

public class AbstractTest {
	public static void main(String[] args) {
	}
}
abstract class T{//抽象类中可以包含具体方法和抽象方法
	public abstract void method();//抽象方法只有声明，没有实现（及没有{}方法体）
	public void test() { 
		System.out.println("test");
	}
}

9.无论何种情况，只要一个类是抽象类，那么这个类就无法实例化。
10.在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，该子类需要声明成一个
abstract class。

package testecclipse;

public class AbstractTest {
	public static void main(String[] args) {
		R r=new R();
		r.method();
	}

}
abstract class T{
	public abstract void method();//抽象方法只有声明，没有实现（及没有{}方法体）
	public void test() {
		System.out.println("test");
	}
	
}

class R extends T{
/* 在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；
 * 否则，该子类需要声明成一个abstract class。
 */
	public void method() {//子类实现了父类中定义的所有抽象方法
		System.out.println("method");
	}
	
}


package testecclipse;

public class AbstractTest {
	public static void main(String[] args) {
//		R r=new R();//抽象类不能实例化
	}
}
abstract class T{
	public abstract void method();//抽象方法只有声明，没有实现（及没有{}方法体）
	public void test() {
		System.out.println("test");
	}
	
}
//方法二：子类也抽象化，此时不能实例化，要想调用方法，还需要在新建一类进行实例化，再调用方法。
abstract class R extends T{
	public void method() {
		System.out.println("method");
	}
	
}

package testecclipse;

public class AreaAbstractTest {
	public static void main(String[] args) {
		Shape shape =new Triangle(10,6);
		int area=shape.computeArea();
		System.out.println("triangle:"+area);
		
		shape =new Rectangle(10,10);
		area=shape.computeArea();
		System.out.println("Rectangle:"+area);		
	}

}
abstract class Shape{//定义成抽象类以规范子类的行为，
	public abstract int computeArea();//抽象方法只有声明，没有实现(方法体）	
}
class Triangle extends Shape{
	int width;
	int height;
	
	public Triangle(int width,int height) {//构造方法，用于初始化对象
		this.width=width;//方法参数赋给成员变量
		this.height=height;
		
	}
	public int computeArea() {
		return (width*height)/2;
		
	}
}

class Rectangle extends Shape{
	int width;
	int height;
	
	public Rectangle(int width,int height) {//构造方法，用于初始化对象
		this.width=width;//方法参数赋给成员变量
		this.height=height;
		
	}
	public int computeArea() {
		return this.width*this.height;		
	}
}

11.接口（interface）
接口的地位等同于class，接口中的所有方法都是抽象方法。
在声明接口中的方法时，可以使用abstract关键字，也可以不使用。通常情况下都会省略abstract关键字。

package testecclipse;

public interface InterfaceTest {
	public void output();//在声明接口中的方法时，可以使用abstract关键字，也可不使用。通常情况下都会省略abstract关键字。

}

12.接口可以看做是一种特殊的抽象类（抽象类中可以有具体方法，也可以有抽象方法，而接口中只有抽象方法，不能有具体方法）。
13.类可以实现接口。实现用implements表示，代表了某个类实现了某个接口。
14.一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。如果该类是个抽象类，那么久无需实现接口中的方法。
15.Java是单继承的，也就是说某个类只能有唯一个父类。一个类可以实现多个接口。

package testecclipse;

public class InterfaceTest1 {
	public static void main(String[] args) {
		MyClass myClass=new MyClass();
		myClass.output();
		myClass.output2();//调用方法
		myClass.output3();
	}
}
interface MyInterface{//第一个接口
	public void output();
}

interface MyInterface2{	//第二个接口
	public void output2();
}
class MyParent{
	public void output3() {
		System.out.println("ouotput3");
	}
}
//MyClass类同时实现了继承父类MyParent和和两个接口MyInterface和MyInterface2
class MyClass extends MyParent implements MyInterface,MyInterface2{
//一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法。如果该类是个抽象类，那么久无需实现接口中的方法。
	public void output() {//实现接口MyInterface的所有方法
		System.out.println("output");
	}
	public void output2() {//实现接口MyInterface2的所有方法
		System.out.println("output2");
	}	
}

16.多态
所谓多态，就是父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。关于接口与实现接口的类之间的强制类型转换方式与父类和子类直接的强制类型转换方式完全一样。

package testecclipse;

public class InterfaceTest2 {
	public static void main(String[] args) {
		AA bb=new BB();//接口类型的引用指向实现接口类的对象
		bb.output();	
	}
}

interface AA{
	public void output();
}

class BB implements AA{
	public void output() {
		System.out.println("BB");
	}	
}

17.static关键字
可以用于修饰属性，也可以用于修饰方法，还可以用于修饰类（后面的课程讲）
18.static修饰属性：无论一个类生成多少个对象，所有这些对象共用唯一一份static成员变量；一个对象对该静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生变化。

public class StaticTest {
	public static void main(String[] args) {
		MyStatic myStatic =new MyStatic();
		MyStatic myStatic2 =new MyStatic();
		myStatic.a=10;
		System.out.println(myStatic2.a);
		}
}
class MyStatic{
	static int a;//MyStatic无论生成多少个static对象，这些对象共用static成员变量
}
如果一个成员变量是static的，那么我们可以通过类名.成员变量名的方式来使用它（推荐的方式）。
public class StaticTest {
	public static void main(String[] args) {
		/*
		MyStatic myStatic =new MyStatic();
		MyStatic myStatic2 =new MyStatic();
		myStatic.a=10;
		System.out.println(myStatic2.a);
	    */
		MyStatic myStatic=new MyStatic();
		MyStatic.a=10;//如果一个成员变量是static的，则可通过类名.成员变量名的方式来使用它
		System.out.println(myStatic.a);
	}
}
class MyStatic{
	static int a;//MyStatic无论生成多少个static对象，这些对象共用static成员变量
}
19.static修饰方法：static修饰的方法叫做静态方法。对于静态方法来说，可以使用类名.方法名的方式来访问。
public class StaticTest2 {
	public static void main(String[] args) {
//		MyStatic2 test=new MyStatic2();
//		test.output();
		MyStatic2.output();//output是静态方法，所以直接用类名调用方法
	}
}
class MyStatic2{
	public static void output() {
		System.out.println("output");
	}
}
20.静态方法只能继承，不能重写（Override）。
21.final关键字
final可以修饰属性、方法、类。
22.final修饰类：当一个类被final修饰时，表示该类是一个终态类，即不能被继承。
public class FinalTest {
	public static void main(String[] args) {
		F f=new F();
	}
}
final class E{//终态类，不能被继承
}
class F{
}

23.final修饰方法：当一个方法被final所修饰时，表示该方法是一个终态方法，即不能被重写（Override）。
24.final修饰属性：当一个属性被final所修饰时，表示该属性不能被改写（即为常量）。
25.当final修饰一个原生数据类型时，表示该原生数据类型的值不能发生变化（比如说不能把10变为20）；如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了。但该引用所指向的对象的内容是可以发生变化的。

public class FinalTest3 {
	public static void main(String[] args) {
		People2 people =new People2();
		//people.address=new Address();//这句报错，无法为做final变量改变值，这句意图改变address的指向
		people.address.name="shanghai";//只是修改了address指向的对象地址的值，并没有改变指向
	}
}
class People2{
	final Address address =new Address();//new的成员变量，地址里面的值为beijing
	//（final修饰引用类型）final address表示address始终指向这个对象，不能改变指向
}
class Address{
	String name ="beijing";
}

第二次值改为shagnhai
26对于final类型的成员变量，一般来说有两种赋初值方式：
（1） 在声明final类型的成员变量时就赋上初值
（2） 在声明final类型的成员变量时不赋初值，但在类的所有构造方法中都为其赋初值。
public class FinalTest4 {
final int a;//在声明final类型的成员变量时就赋初值
/*构造方法的特点
* 1.方法名称和类名相同
2.不用定义返回值类型（不同于void类型返回值，void是没有具体返回值类型；构造函数是连类型都没有）
3.不可以写return语句（返回值类型都没有，也就不需要return语句）
````java
*/
public FinalTest4() {//构造方法
a=0;
}
public FinalTest4(int a) {//构造方法
this.a=a;
}

}

/*final赋值的两种方式：
 * （1）	在声明final类型的成员变量时就赋上初值
 * （2）	在声明final类型的成员变量时不赋初值，但在类的所有构造方法中都为其赋初值。
 */
27.static代码块：静态代码块。静态代码块的作用也是完成一些初始化工作。首先执行静态代码块，然后执行构造方法。静态代码块在类被加载的时候执行，而构造方法是在生成对象的时候执行；要想调用某个类生成对象，首先需要将类加载到java虚拟机上（JVM），然后JVM加载这个类来生成对象。
28.类的静态代码块只执行一次，是在类被加载的时候执行的，因为每个类只会被加载一次，所以静态代码块也只会被执行一次；而构造方法则不然，每次生成一个对象时都会调用类的构造方法，所以new一次就会调用构造方法一次。
````java
public class StaticTest4 {
	P p=new P();
	P p2=new P();
	S s=new S();
}

class P{
	static {//静态代码块，加载到java虚拟机时就执行
		System.out.println("P static block");
	}
	public P() {//构造方法，创建对象时才会执行，进行初始化
		System.out.println("P constructor");
	}
}
class Q extends P{
	static {
		System.out.println("Q static block");
	}
	public Q() {
		System.out.println("Q constructor");
	}
}
class S extends Q{
	static {
		System.out.println("S static block");
	}
	public S() {
		System.out.println("S constructor");
	}
}

29.如果继承体系中既有构造方法，又有静态代码块，那么首先执行最顶层的静态代码块，一直执行到最底层的静态
代码块，然后再去执行最顶层类的构造方法，一直执行最底层类的构造方法。注意：静态代码块只执行一次。
30.不能在静态方法中访问非静态成员变量；可以在静态方法中访问静态的成员变量。可以在非静态方法中访问静态的成员变量。
总结：静态的只能访问静态的；非静态的访问一切。
32.This关键字
（1）This关键字只能用于方法体内。当一个对象自动创建后，java虚拟机会为这个对象分配一个引用自身的指针，指针名为this。
（2）this只能在类的非静态方法中使用；静态方法和静态的代码块中绝对不能出现this。
（3）this指代的是当前类或者对象本身。即this代表了当前类或对象的一个“引用”。

/*定义了名称相同的类的成员变量x和方法的局部变量x，
* 通过this关键字指向当前对象，调用当前对象的成员变量，即this.x
*/
public class ThisTest {
   int x=0;//成员变量
   public void test(int x) {
   	x=3;//方法中的局部变量
   	System.out.println("在方法内部：");
   	System.out.println("成员变量x="+this.x);
   	System.out.println("局部变量x="+x);
   	System.out.println("-------------");
   }	
   
   public static void main(String[] args) {
   	ThisTest t=new ThisTest();
   	System.out.println("调用方法前：");
   	System.out.println("成员变量x="+t.x); //调用成员变量x
    	System.out.println("-------------");
    	
   	t.test(99);//调用test()方法
   	System.out.println("调用方法后：");
   	System.out.println("成员变量x="+t.x);
   }
}
/*当一个类的属性（成员变量）名与访问该属性的方法参数名相同，
* 则需要使用this关键字类访问类中的属性，以区分类的属性和方法中的参数。
*/

1、接口补充
（1）接口中所声明的方法都是抽象方法，接口中的方法都是public的。
（3） 接口汇中也可以定义成员变量，接口中的成员变量都是public/final/static的。
（4）一个类不能既是final，又是abstract的。因为abstract的主要目的是定义一种约定，让子类去实现这种约定，而final表示该类不能被继承，这样abstract希望该类可以被继承而final明确说明该类不能被继承，两者矛盾。因此一个类不能既是final的，又是abstract的。
2、Design Pattern(设计模式)
2.1单例模式（Singleton）
一个类只会生成唯一的一个对象

package Java_Lesson3_study;
//单例模式的实现
public class SingletonTest {
	public static void main(String[] args) {
		//两个实例
		Singleton singleton =Singleton.getInstance();
		Singleton singleton2 =Singleton.getInstance();
		//判断两个对象是否指向同一个引用，是输出true，不是输出false
		System.out.println(singleton == singleton2);
	}

}
/*第一种情况：新建实例赋值
class Singleton{
	private static Singleton singleton=new Singleton();//静态方法只能调用静态的成员变量，所以也要定义成静态的。
	private Singleton() {
		
	}
	public static Singleton getInstance() {//加static，使得用类名直接调用
		return singleton;
	}
	
}
*/
/*第二种情况不赋值*/
class Singleton{
	private static Singleton singleton;//静态方法只能调用静态的成员变量，所以也要定义成静态的。
	private Singleton() {
		
	}
	public static Singleton getInstance() {//加static，使得用类名直接调用
		if(singleton==null) {
			singleton=new Singleton();
		}
		return singleton;
	}
	
}

3.包与导入语句剖析
3.1包（package）
用于将完成不同功能的类分门别类，放在不同的目录（包）下。包的命名规则：将公司域名反转作为包名。
域名：www.shengsiyuan.com，则包名：com.shengsiyuan
对于包名：每个字母都需要小写。如果定义类的时候没有使用package，那么java就会认为我们所定义的类位于默认包里面（default package）。
6.编译带有package声明的Java源文件有两种方式：
（1）直接编译，然后根据类中所定义的包名，逐一手工建立目录结构，最后将生成的class文件放到该目录结构中（很少使用，比较麻烦）
（2）使用编译参数 -d，方式为javac -d.源文件.java，这样在编译后，编译器 会自动帮助我们建立好包所对应的目录结构。
7.有两个包名，分别是aa.bb.cc与aa.bb.cc.dd，那么我们称后者为前者的子包。
8.导入（import），将使用package分离的各个类导入回来，让编译器能够找到所需要的类。
9.import的语法：import com.shengsiyuan.PackageTest;
10.import com.shengsiyuan.,表示导入com.shengsiyuan包下面的所有类。
11.import aa.bb.并不会导入aa.bb.cc包下面的类。这时需要这样写：
Import aa.bb.;
Import aa.bb.cc.;
12.关于package，import，class的顺序问题：
（1）首先需要定义包（package），可选
（2）接下来使用import进行导入，可选
（3）然后才是class或者interface的定义。
13.如果两个类在同一个包下面，则不需要导入，直接使用即可。
3.2.访问修饰符（access modifier）
(1)public（公共的）：被public所修饰的属性和方法可以被所有类访问。
（2）protected（受保护的）：被protected所修饰的属性和方法可以在类内部、相同包、以及该类的子类所访问。
（3）private（私有的）：被private所修饰的属性和方法只能在该类内部使用
（4）默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用。
15. Instanceof（谁的实例）：判断某个对象是否是某个类的实例。语法形式：引用名instanceof 类名（接口名），返回一个boolean值。
16、System.out.println(people instanceof People);//结果为true，因为Man是People的子类，根据继承，子类就是父类，因此Man也可以看做是People的实例。

package Java_Lesson3_study;

public class InstaceofTest {
	public static void main(String[] args) {
		Peo people4=new Peo();
		System.out.println(people4 instanceof Peo);
	}
}
class Peo{
	
}

18.相等性的比较（==）
（1）对于原生数据类型来说，比较的是左右两边的值是否相等。
（2）对于引用类型来说，比较左右两边的引用是否指向同一个对象，或者说左右两边的引用地址是否相同。
4.java.lang.Object类
Java.lang包在使用的时候无需显式导入，编译是由编译器自动帮助我们导入。
4.1API（Application Programma Interface）应用编程接口
4.2.当打印引用时，实际上会打印出引用所指对象的toString()方法的返回值，因为每个类都直接或间接地继承自Object，而Object类中定义了toString(),因此每个类都有toString()这个方法。
4.3关于进制的表示：16进制，逢16进1，16进制的数字包括：0-9，A，B，C，D,E，F
package Java_Lesson3_study;

public class ObjectTest{
	
	public static void main(String[] args) {
		Object object =new Object();
		
		System.out.println(object);
		System.out.println(object.toString());
		
		String str="aaa";
		System.out.println(str);
		System.out.println(str.toString());
		
		Student student=new Student();
		
		System.out.println(student);
		System.out.println(student.toString());
	}
}

class Student extends Object{
	public String toString() {
		return "Hello World";
	}
	
}

4.3 equals()方法，该方法定义在Object类当中，因此Java中的每个类都该具有该方法，对于Object类的equals()方法来说，它是判断调用equals()方法的引用与传进来的引用是否一致，即这两个引用是否指向的是同一个对象。对于Object类的equals()方法来说，它等价于==。

public class StringTest {
	public static void main(String[] args) {
		
		Object object=new Object();
		Object object2=new Object();
       
		System.out.println(object.equals(object2));
		System.out.println(object.equals(object));
	}
}

运行结果：
false
true
对于String类的equals()方法来说，它是判断当前字符串与传进来的字符串的内容是否一致。
对于String对象的相等性判断来说，请使用equals（）方法，而不要使用==。
5.String类陷阱剖析
5.1 String是常量，其对象一旦创建完毕就无法改变。当使用+拼接字符串时，会生成新的String对象，而不是向原有的String对象追加内容。

public class StringTest2 {
	public static void main(String[] args) {
		String s1="Hello";
		String s2="World";
		String s3=s1+s2;
		System.out.println(s3);
	}
}

5.2 StringPool（字符串池），
package Java_Lesson3_study;

public class ObjectTest2 {
	public static void main(String[] args) {
		Object object=new Object();
		Object object2=new Object();
		System.out.println(object==object2);
		System.out.println("--------------------------------");
		
		String str=new String("aaa");//string也是类，
		String str2=new String("aaa");
		System.out.println(str==str2);
		System.out.println("--------------------------------");
		
		String str3="bbb";
		String str4="bbb";
		System.out.println(str3==str4);
		System.out.println("--------------------------------");
		
		String str5=new String("ccc");
		String str6="ccc";
		System.out.println(str5==str6);
		System.out.println("--------------------------------");
		
		String s="hello";
		String s1="hel";
		String s2="lo";
		System.out.println(s==s1+s2);
		System.out.println("--------------------------------");
		System.out.println(s=="hel"+"lo");
	}

}

5.3 String s=”aaa”;（采用字面值方式赋值）
(1)查找String PooL中是否存在“aaa”这个对象，如果不存在，则在String Pool中创建一个“aaa”对象，然后将String Pool中的这个“aaa”对象的地址返回来，赋给引用变量s，这样，s会指向String Pool中的这个“aaa”字符串对象。
（2）如果存在，则不创建任何对象，直接将String Pool中的这个“aaa”对象地址返回来，赋给s引用。
5.4 String str=new String(“aaa”);
(1)首先在String Pool中查找有没有“aaa”这个字符串对象，如果有，则不在String Pool中再去创建“aaa”这个对象了，直接在堆中（heap）中创建一个“aaa”字符串对象，然后将堆中的这个“aaa”对象的地址返回来，赋给s引用，导致s指向了堆中创建的这个“aaa”字符串对象。
（2）如果没有，则首先在String Pool中创建一个“aaa”对象，然后再在堆中（heap）创建一个“aaa”对象，然后将堆中的这个“aaa”对象的地址返回来，赋给s引用，导致s指向了堆中所创建的这个“aaa”对象。（创建了两次）
String str=new String(“aaa”);//string也是类，
String str2=new String(“aaa”);
System.out.println(str==str2);
Java SE Lesson 4
第32讲java数组内存地址解析
4.1包装类（Wrapper Class）
针对原生数据类型的包装。所有的包装类都位于java.lang包下。Java中的8个包装类分别是：Byte，Short，Integer，Long，Float，Double，Character，Boolean。他们的使用方式都是一样的，可以实现原生数据类型与包装类型的双向转换。
4.2 数组（Array）:
相同类型数据的集合就叫做数组。
4.3定义数组：
type[] 变量名=new type[数组总元素的个数]；可以按照以下方式定义长度为10的数组：
int[] a=new int[4];;或者int a[]=new int[2];java中推荐第一种方式
public class ArrayTest {
public static void main(String[] args) {
//方法1：
int[] a=new int[4];//a是一个整型数组的引用
a[0]=1;
a[1]=2;
a[2]=3;
a[3]=4;
System.out.println(a[3]);
// 方法二:
int a[]=new int[2];
a[0]=1;
a[1]=2;
a[2]=3;
a[3]=4;
System.out.println(a[3]);
}
}

（1）数组中的元素索引是从0开始的。对于数组来说，最大的索引==数组的长度-1；
4.4定义数组的第三种方式
type[] 变量名={new type[]}{都好分隔初始化值列表}

public class ArrayTest {
	public static void main(String[] args) {
//		/*方法三：两种直接赋值方式
		int[] b= {1,2,3,4};
		System.out.println(b[3]);
		
		int[] c=new int[] {1,2,3,4};
		System.out.println(c[3]);
//		*/
		}
}

4.5 length属性
java中的每个数组都有一个名为length的属性，表示数组的长度；length属性是public，final，int的。数组长度一旦确定，就不能改变大小。

public class ArrayTest {
	public static void main(String[] args) {
int[] d=new int[100];
		 for(int i=0;i<d.length;i++) {//length是数组的内置属性
			d[i]=i+1;
			System.out.println(d[i]);
		}
	}
}

4.6 int[] a=new int[10]
int[] a=new int[10],其中a是一个引用，它指向了生成的数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。

数组里存放的是引用，不是对象

public class ArrayTest2 {
	public static void main(String[] args) {
		Person[] p=new Person[3];//声明了Person类型的数组对象
		p[0]=new Person(10);//给数组赋值
		p[1]=new Person(20);
		p[2]=new Person(30);
		
		for(int i=0;i<p.length;i++) {
			System.out.println(p[i].age);
		}
		Person[] p2=new Person[5];//声明一个长度为5的Person数组，没有给数组赋值
		for(int i=0;i<p2.length;i++) {
			System.out.println(p2[i]);//打印数组的内容，均为null
		}
	}
}
class Person{
	int age;
	public Person(int age) {
		this.age=age;
	}
}
数组里存放的是引用，不是对象
 
	p[0]=new Person(10);//给数组赋值
	p[1]=new Person(20);
	p[2]=new Person(30);这三句生成Person对象，使得数组引用指向person对象，
public class ArrayTest3 {
	public static void main(String[] args) {
		Students[] s=new Students[100];//声明数组
		for(int i=0;i<s.length;i++) {//i是索引下标，从0开始，所以下标为奇数时输出李四，下标为偶数时输出张三
			s[i]=new Students();//生成对象
			s[i].name=i%2==0 ? "zhangsan" : "lisi";
		}
		for(int i=0;i<s.length;i++) {
			System.out.println(s[i].name);
		}
	}
}

class Students{
	String name;
}