java，

java，

一、静态成员和实例成员

1、static 静态成员：包含静态成员变量和静态成员方法
2、静态成员也叫类成员。非静态成员称为实例成员。
3、静态成员属于整个类所有，静态成员被整个类的所有对象所共享，若一个对象的静态成员改变，则所有对象的静态成员改变。
4、对于类变量（静态变量），在字节码加载到内存时，如果没有创建对象（也就是new ），则实例变量就不分配内存，而类变量分配了内存。
5、类变量类似于一个宿舍天花板的灯，在学生没来之前就已经存在，它属于整个宿舍，所有学生共享这个灯，宿舍的每个学生都可以操作它。

6、类成员方法只能对类成员变量进行操作。 
7、类方法不能调用实例变量，类方法只能调用类变量。，因为类方法在对象创建之前就可以使用，而此时实例化对象还没有分配空间。

8、静态方法中不能使用this和super

class S{
  static String  school="福州大学";
  String name;
  
  static void start(){
    System.out.println(name);//类方法不能调用实例变量  
}
}

8、类成员可以用类名或对象名来调用。
9、在System.out.println()中，println()是方法名，System是java.lang包里面的一个类，而out则是System类里面的一个静态成员变量。
10、out又是一个java.io.PrintStream类的对象，所有out必然可以调用java.io.PrintStream类里面的方法，println（）就是java.io.PrintStream类里面的一个方法。它的作用就是用来向控制台输出信息。

二、多态

1、面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。
2、多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
3、多态存在的三个必要条件

一、要有继承；

二、要有重写；

三、父类引用指向子类对象。

4、

A 为父类——————  B为子类
A a =new B();
称a是new B（）生成的对象的**上转型对象**（父类对象a称为上转型对象）
a（上转型对象）可以引用**子类B**继承的变量和方法，不可以引用子类B新增的变量和方法。

三、 若父类不想被继承，可以设为private或者final

1、final修饰变量：，变量就变成了常量，一般大写。
2、final修饰方法：，方法就不能重写；
3、final修饰类：，类就不能被继承。

四、克隆构造方法

class Tes{
  public static void main(String ags[]){
    Rect s[]=new Rect[3];//对象数组
    
    s[0]=new Rect(2,3);
    s[0].printInfo();
    
    s[2]=new Rect(2);//这里传的参数值不是对象，所有直接跳到Rect(double b)这个构造方法执行
    s[2].printInfo();
    
     s[1]=new Rect(new Rect(3));
    s[1].printInfo();
    
     s[1]=new Rect(new Rect(7,8));//传的参数为对象，会先跳到 Rect(double w,double h)这个构造方法，再跳到 Rect(Rect s)这个克隆构造方法
    s[1].printInfo();
    
     s[1]=new Rect( s[2]);//传的参数为对象，先跳到 Rect(double b)这个构造方法，再跳到Rect(Rect s)这个克隆构造方法
    s[1].printInfo();
  }
}
class Rect{
  private double w,h;
  Rect(double w,double h){
    this.w=w;
    this.h=h;
  }

  Rect(Rect s){// s 是克隆构造方法的对象，如果传值的参数到这，只能传对象为参数过来
    w=s.w*2;
    h=s.h;
}
   Rect(double b){
   w=h=b*2;
}
  double area(){
    return w*h;
  }
  void printInfo(){
    System.out.println(area());
}
}

输出结果为：

6.0
16.0
72.0
112.0
32.0

五、abstract 抽象

1、若一个类或者方法不具体或不完整，则需要定义为抽象的。
2、abstract修饰类：1）、必须被继承。。2）、不能由抽象类声明对象
3、abstract修饰方法：1）、抽象方法只需声明，无须实现。。2）、抽象方法必须被重写。
4、抽象类中可以包含抽象方法，为所有子类定义一个统一的接口，但并不是必须的。
5、一旦某个类中包含抽象方法，则这个类必须声明为抽象类。

六、内类

1、main函数包含在主类中

class a7{
    static int size=10;
    static class b{
     static int size=20;
     static void m2(){  System.out.println(size=30);} //哪个size？
     void ny(){System.out.println(a7.size=40);} //哪个size?
    }
     class c{
    // static int num=18; //错误，普通内部类不能声明static成员
     void m2(){System.out.println(size=50);}
    }
  public static void main(String args[]){
    b b1=new b();//静态main方法写在主类里面，则静态内类可以直接实例化对象
    b1.m2();
    b1.ny();
    
   // c c1=new c();//这句是错的——如果把main方法写在主类里面，则主类默认main方法是它的一个方法，
    //因为main方法是静态的，所以静态main只能访问静态的方法、属性以及静态的内类。

  }
}

输出结果为：30   、    40

2、main函数在主类外

class Test{
   public static void main(String arg[ ]){
    Parent.Inner1 i1=new Parent.Inner1();//当main方法在外部的时候，静态内部类实例化对象的方法。
    i1.m2();
    i1.ny();
    
   Parent p =new Parent();//当main方法在外部的时候，非静态内部类实例化对象的方法。
   Parent.Inner2 i2=p.new Inner2();
   i2.m2();
    }
}

class Parent{
     int size=10;
    static class Inner1{
     int size=20;
      void m2(){System.out.println(size=30);} //哪个size？
     void ny(){System.out.println(a7.size=40);} //哪个size?
    }
     class Inner2{
     //static int num=18; //错误，普通内部类不能声明static成员
     void m2(){System.out.println(size=50);}
    }
}

输出结果为：40  、50

七、重载和重写

1、重写的方法必须与父类中的方法名相同、参数个数相同和类型相同，返回类型相同或是子类。
2、方法重载：多个方法可以享有相同的名字，方法的参数个数必须不同或者参数类型不同，完成的功能相似，返回类型不能作为区分方法重载的标准，体现面向对象的多态性。
3、重写父类方法时，不能降低方法的访问权限：如父类的方法是protected，那么子类继承父类重写该方法时，该方法要么是protected权限，要么是public权限

八、访问权限

1、private：只能访问统一类中。

2、default：同类、同包可访问。
3、protected：同类、同包、不同包中的子类可访问。
4、public：同类、同包、不同包中的子类、不同包中的非子类可访问。

九、图说

十、继承父类构造方法和继承、重写父类方法

class c{
 public static void main(String args[]) {
  B b=new B(8,2,5);
  System.out.println(b.f());
  System.out.println(b.f(1,2,3));
 }}
class A{
  double x;
  double y;
  A(double x,double y){
    this.x=x;
    this.y=y;
    
  }
     double f(double x,double y)     {
         return x+y;
     } }
class B extends A{
  double z;
  B(double x,double y,double z){//继承父类构造方法，并新增新的变量
    super(x,y);
    this.z=z;
  }
     double f()     {//继承、重写父类无参方法，并新增一个变量
      double m=super.f(x,y);
         return m+z;
     }
      double f(double x,double y,double z)     {//继承、重写父类方法，并新增一个变量
      double m=super.f(x,y);
         return m+z;
     }
}

输出结果：15.0 和 6.0

十一、split用法

package ex3;

import java.util.*;

public class StringTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		System.out.println("请输入："+"");
		String a=s.nextLine();
		String aArray[] = a.split(" "); //表示输入时以7一个空格分隔
		System.out.println("输出："+aArray.length);		//求出输入的字符串个数
		for(double i=0;i<aArray.length;i++) {
			System.out.println(aArray[(int) i]+"\n");  		  //将每个字符串打印出来
		}
	}

}

结果如图

十二、StringBuffer类的方法

public class StringBufferTest{
	public static void main(String[] args) {
	StringBuffer s = new StringBuffer("123eedddddddddddd");   
		  s.append("abcdefg");                     /*append()是类StringBuffer的一个方法，
		 表示将append（）里的值添加到StringBuffer后面，相当于  " + "  */
		  System.out.println("append结果：" + s);
		  s.insert(2,"123");                     /*insert()是类StringBuffer的一个方法,insert()方法
		  将数据插入此StringBuffer的子字符串中。从第二位后面开始插入数123*/  
		  System.out.println("insert结果：" + s);
		  s.delete(2, 4);                         /*表示第一位数和第二位数不删除，删除第二位后面（4-2）位数*/  
		  System.out.println("delete结果：" + s);
		  s.deleteCharAt(0);                     /*以下标0为起始，删除第（0+1）位的数，即删除1*/  
		  System.out.println("delete结果：" + s);
		  s.setCharAt(1, 'a');                  /*以下标0为起始，将第（1+1）位数3换成a*/  
		  System.out.println("setCharAt结果：" + s);

		
	}

}

输出结果