java基础寒假内容

关键字static
当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

class Circle{
		private double radius;
		public Circle(double radius){this.radius=radius;}
		public double findArea(){return Math.PI*radius*radius;}}
创建两个Circle对象
Circle c1=new Circle(2.0);	//c1.radius=2.0
Circle c2=new Circle(3.0);	//c2.radius=3.0

Circle类中的变量radius是一个实例变量(instance variable)，它属于类的每一个对象，不能被同一个类的不同对象所共享。
上例中c1的radius独立于c2的radius，存储在不同的空间。c1中的radius变化不会影响c2的radius，反之亦然。

类属性作为该类各个对象之间共享的变量。
如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

Java类中，可用static修饰属性、方法、代码块、内部类

被修饰后的成员具备以下特点：
随着类的加载而加载
优先于对象存在
修饰的成员，被所有对象所共享
访问权限允许时，可不创建对象，直接被类调用。

class Circle {
private double radius;
public static String name = "这是一个圆";
public static String getName(){
return name;}
public Circle(double radius) {
getName();
this.radius = radius;}
public double findArea() {
return Math.PI * radius * radius;}
public void display(){
System.out.println("name:"+name+"radius:"+radius);
}}

```java
public class TestStatic {
public static void main(String[] args) {
Circle c1 = new Circle(2.0);
Circle c2 = new Circle(3.0);
c1.display();
c2.display();
}
}

类变量（类属性）由该类的所有实例共享

```java
public class Person {
       private int id;
       public static int total = 0;
       public Person() {
 	total++;
 	id = total;
       }
 }

 

```java
class Person {
           private int id;
           public static int total = 0;
           public Person() {
 	         total++;
 	         id = total;
           }
           public static void main(String args[]){
         	Person Tom=new Person();
	Tom.id=0;
	total=100; // 不用创建对象就可以访问静态成员
         }
 }
``public class OtherClass {
            public static void main(String args[]) {
 	         Person.total = 100;  // 不用创建对象就可以访问静态成员
                           //访问方式：类名.类属性，类名.类方法
	         System.out.println(Person.total);
	         Person c = new Person(); 
	         System.out.println(c.total);	//输出101
            }}

类方法

没有对象的实例时，可以用类名.方法名()的形式访问由static标记的类方法。
在static方法内部只能访问类的static属性，不能访问类的非static属性。

单例(Singleton)设计模式-饿汉式

class Single{
 	//private的构造器，不能在类的外部创建该类的对象
     private Single() {} 
	 //私有的，只能在类的内部访问
     private static Single onlyone = new Single();
 	//getSingle()为static，不用创建对象即可访问
     public static Single getSingle() {
		return onlyone;
 	}
}
 public class TestSingle{
	public static void main(String args[]) {		
		Single  s1 = Single.getSingle();      //访问静态方法
		Single  s2 = Single.getSingle();
		if (s1==s2){
			System.out.println("s1 is equals to s2!");
		}}}

## 单例(Singleton)设计模式-懒汉式

```java
class Singleton{
	//1.将构造器私有化，保证在此类的外部，不能调用本类的构造器。
	private Singleton(){
	}
	//2.先声明类的引用
	//4.也需要配合static的方法，用static修饰此类的引用。
	private static Singleton  instance = null;
	//3.设置公共的方法来访问类的实例
	public static Singleton  getInstance(){
	//3.1如果类的实例未创建，那些先要创建，然后返回给调用者：本类。因此，需要static 修饰。
		if(instance == null){
			instance = new Singleton();
		}
	//3.2 若有了类的实例，直接返回给调用者。
		return instance;
	}  }

初始化块

一个类中初始化块若有修饰符，则只能被static修饰，称为静态代码块(static block )，当类被载入时，类属性的声明和静态代码块先后顺序被执行，且只被执行一次。

static块通常用于初始化static (类)属性
class Person {
public static int total;
static {
total = 100;//为total赋初值
}
…… //其它属性或方法声明
}

非静态代码块：没有static修饰的代码块
1.可以有输出语句。
2.可以对类的属性声明进行初始化操作。
3.可以调用静态和非静态的变量或方法。
4.若有多个非静态的代码块，那么按照从上到下的顺序依
次执行。
5.每次创建对象的时候，都会执行一次。且先于构造器执行
静态代码块：用static 修饰的代码块
1.可以有输出语句。
2.可以对类的属性声明进行初始化操作。
3.不可以对非静态的属性初始化。即：不可以调用非静态的属
性和方法。
4.若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5.静态代码块的执行要先于非静态代码块。
6.静态代码块只执行一次

关键字

在Java中声明类、属性和方法时，可使用关键字final来修饰,表示“最终”。
final标记的类不能被继承。提高安全性，提高程序的可读性。
String类、System类、StringBuffer类
final标记的方法不能被子类重写。
Object类中的getClass()。
final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。
final标记的成员变量必须在声明的同时或在每个构造方法中或代码块中显式赋值，然后才能使用。
final double PI=3.14;

抽象类

用abstract关键字来修饰一个类时，这个类叫做抽象类；
用abstract来修饰一个方法时，该方法叫做抽象方法。
抽象方法：只有方法的声明，没有方法的实现。以分号结束：abstract int abstractMethod( int a );
含有抽象方法的类必须被声明为抽象类。
抽象类不能被实例化。抽象类是用来作为父类被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。

abstract class A{   
       abstract void m1( );
       public void m2( ){
	    System.out.println("A类中定义的m2方法");
       }
}

class B extends A{
       void m1( ){
	     System.out.println("B类中定义的m1方法");
       }
}

public class Test{
       public static void main( String args[ ] ){
	     A a = new B( );
	     a.m1( );
	     a.m2( );
       }
}

接口

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
接口(interface)是抽象方法和常量值的定义的集合。
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
实现接口类：
class SubClass implements InterfaceA{ }
一个类可以实现多个接口，接口也可以继承其它接口

接口的特点：
用interface来定义。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有方法都默认是由public abstract修饰的。
接口没有构造器。
接口采用多层继承机制。
接口定义举例

 public interface Runner {
(public static final)int ID = 1;
	(public abstract)void start();
	public (abstract)void run();
	(public abstract)void stop();
    }

实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
接口的主要用途就是被实现类实现。（面向接口编程）
与继承关系类似，接口与实现类之间存在多态性
定义Java类的语法格式：先写extends，后写implements

< modifier> class < name> [extends < superclass>]
	[implements < interface> [,< interface>]* ] {
		< declarations>*
	}

如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类
接口也可以继承另一个接口，使用extends关键字。

interface MyInterface{
		String s=“MyInterface”;
		public void absM1();
	}
	interface SubInterface extends MyInterface{
		public void absM2();
	}
	public class SubAdapter implements SubInterface{
		public void absM1(){System.out.println(“absM1”);}
		public void absM2(){System.out.println(“absM2”);}
	}

实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface中所有方法的实现。

内部类

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
Inner class的名字不能与包含它的类名相同；
Inner class可以使用外部类的私有数据，因为它是外部类的成员，同一个类的成员之间可相互访问。而外部类要访问内部类中的成员需要:内部类.成员或者内部类对象.成员。
分类：成员内部类（static成员内部类和非static成员内部类）
局部内部类（不谈修饰符）、匿名内部类

class A {
	private int s;
	public class B{
	        public void mb() {
		s = 100;     
		System.out.println("在内部类B中s=" + s);
	        }  }
	public void ma() {
		B i = new B();
		i.mb();
	}  }

       public class Test {	
	public static void main(String args[]){
	        A o = new A();
	        o.ma();
	}   } 

内部类的特性

Inner class作为类的成员：
可以声明为final的
和外部类不同，Inner class可声明为private或protected；
Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；
Inner class作为类：
可以声明为abstract类 ，因此可以被其它的内部类继承
【注意】非static的内部类中的成员不能声明为static的，只有在外部类或static的内部类中才可声明static成员。
、

匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

new 父类构造器（实参列表）|实现接口(){
//匿名内部类的类体部分
}

interface  A{
	public  abstract void fun1();
}
public class Outer{
	public static void main(String[] args) {
		new Outer().callInner(new A()){
               //接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名
			public void fun1() {
				System.out.println(“implement for fun1");
			}
		});// 两步写成一步了
	}
	public void callInner(A a) {
		a.fun1();
	}
}