这段时间比较系统地学习了Java方面的基础知识，其实就是结束实习后来填坑的（我自己太菜了）
今天学习的是几个关键字以及抽象类和接口。
1、static
public class Test_1 {
public static void main(String args[]){
Man m1 = new Man("June",17);
m1.nation = "China";
m1.name = "Tom";
System.out.println(m1);
}
}
class Man{
String name = "June";
int age;
static String nation ;
public Man(String name,int age){
super();
this.name = name;
this.age = age;
// this.nation = "zhongguo";没作用，赋值后还是改了类变量的值。
}
public String toString(){
return "Man [name="+ name + ",age=" + age +",nation="+nation +"]";
}
}
static修饰的属性为类变量，可以直接通过类.变量的方式调用，一般的变量为实例变量，属于对象的变量，先有的对象才有的实例变量，存在于堆空间中。而类变量的话存在于静态域中，先早于类的产生，结束的时间也比类的时间要晚，所以被static修饰的变量的生命周期比较长，这也是一大弊端。
另外，非静态方法中也可以调用静态的属性。
其次就是两种使用static修饰的变量的方式
（1）饿汉式
//饿汉式
class Singleton{
private Singleton(){
}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
} （2）懒汉式
//懒汉式
class Singleton1{
private Singleton1(){
}
private static Singleton1 instance = null;
public static Singleton1 getInstance(){
if(instance == null){
instance = new Singleton1();
}
return instance;
}
} 一般使用饿汉式，懒汉式有一个弊端就是，可能会引发线程安全的问题。
最后是初始化块，也称为代码块，用{ }表示。
class Order{
private static int orderid = 1001;
private String ordername;
public Order(){
super();
}
public Order(int orderid,String ordername){
super();
this.orderid = orderid;
this.ordername = ordername;
}
//代码块:初始化块 用static进行修饰的是静态代码块，没被修饰的是非静态代码块。
//非静态代码块的执行要早于构造器。静态代码块就加载一次，它的加载早于非静态代码块。
{
orderid = 1002;
ordername = "aa";
}
static {
System.out.println("我是静态代码块");
orderid = 1000; //静态代码块中只能执行静态的结构。
}
public int getOrderid() {
return orderid;
}
public void setOrderid(int orderid) {
this.orderid = orderid;
}
public String getOrdername() {
return ordername;
}
public void setOrdername(String ordername) {
this.ordername = ordername;
}
@Override
public String toString() {
return "Order{" +"orderid=" + orderid +", ordername='" + ordername + '\'' +'}';
}
}
2、final
标记的类不能被继承，修饰的方法不能被重写，修饰的属性不可被更改，就是一个常量。
3、抽象类（abstract)
abstract class Creator{
abstract void breath();
}
//抽象方法所在的类一定是抽象类；抽象类中可以没有抽象方法。
//abrstrct不能修饰属性、构造器、private、final、static。
abstract class AbstructPerson extends Creator{ //抽象方法只保存方法的功能，具体的执行由抽象类的子类执行。
public void eat(){
System.out.println("eat");
}
public void walk(){
System.out.println("walk");
}
}
//若子类继承抽象类，并重写了所有的抽象方法，则此类可以实例化。
//若子类没有重写所有的抽象方法，则还存在抽象方法。
class Student extends AbstructPerson{
public void eat(){
System.out.println("eating");
}
public void walk(){
System.out.println("walking");
}
@Override
void breath() {
System.out.println("Breath");
}
} 抽象类是没有具体实例的父类，也有构造器，不可以被实例化，abstract不能用来修饰属性、构造器、private 、 final 、static。
4、接口
接口可以形象地认为是抽象方法和常量值的定义的集合。接口中只有抽象方法和常量。
/*
接口可以看成一个特殊的抽象类，是与类并行的一个概念。
接口没有构造器。接口定义的就是一种功能，此功能可以被类所实现。
实现接口的类，必须要重写其中的所有功能的抽象方法,否则就定义类为抽象的类即可。
接口与接口之间是继承关系，而且可以实现多继承。
类可以实现多个接口，类的继承是单继承。
*/
interface AA{
//常量，所有的常量都是用public static final修饰的，所以可以忽略不写。
public static final int I = 10;
public static final boolean Flag = false;
//所有的抽象方法都用public abstract修饰。
void method1();
void method2();
}
//抽象类
abstract class BB implements AA{
}
//重写接口中所有的抽象方法
class CC implements AA{
@Override
public void method1() {
}
@Override
public void method2() {
}
}
958
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
