java基础第一篇: 基础介绍

1.本篇包括对面向对象的基本介绍;
2.类,抽象类,接口的介绍;
3.this和super的介绍;
4.statie关键字的介绍;
5.final关键字的介绍;
6.基本数据类型的介绍;

面向对象三大特征

1. 封装:将重要信息隐藏,合理的隐藏,使得数据更加安全
2. 继承:基于两类之间,子类继承父类的非private修饰的方法和属性(变量),注意的是继承属于强耦合关系
3. 多态:实现多态的三个条件(继承,重写,向上转型)

类的组成

• 定义类:
  • 当多个类class定义在同一个文件中,只能有一个类class用public修饰,且被public修饰的类class的类名必须与java文件名相同
• 类的五大成分:
  • 成员变量:描述类或对象的属性信息
  • 成员方法:描述类或对象的行为
  • 构造器:初始化类的一个对象返回
  • 代码块:类的所有成员
  • 内部类:类定义的类
• 注意:java类只能单继承,但可以多层继承

构造器

• 构造器的名字要与类名相同,形参列表不同的构造器,初始化的对象不同,一般分为无参和满参,也可以自己定义不同的形参

抽象类的组成

• 抽象类前缀为 public abstract class的类,可以理解为被abstract修饰的类
• 可以有私有属性和私有方法
• 被声明的抽象方法必须在抽象类中,被声明的抽象类不一定要有抽象方法,但所有的抽象方法在子类中必须实现,否则子类也定义成抽象类
• 可以有构造器,但不能实例化
• 抽象方法不能被private修饰

抽象类定义格式:

/**
抽象类格式
*/
abstract class 类名字 { 
  
}
/**
代码举例
*/
public abstract class Animal {
    public abstract void run()；
}

抽象类的使用案例:

// 父类,抽象类
abstract class AbstractEmployee {
	private String id; //成员变量
	private String name;
	private double salary;
	//抽象类中的构造器供子类创建对象时,初始化父类成员使用
	//无参构造器
	public AbstractEmployee() {
	}
	//有参构造器
	public AbstractEmployee(String id, String name, double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	//抽象方法没有方法体
	//抽象类可以没有抽象方法,当时抽象方法一定要存在于抽象类或者接口中
	abstract public void work();
}

// 抽象类透过继承实现
class Manager extends AbstractEmployee {
	public Manager() {
	}
	public Manager(String id, String name, double salary) {
		super(id, name, salary);
	}
	// 重写父类的所有抽象方法
	// 如果不重写抽象类所有方法,继承类就要变成抽象类
	@Override
	public void work() {
		System.out.println("管理其他人");
	}
}
//同上
class Cook extends AbstractEmployee {
	public Cook() {
	}
	public Cook(String id, String name, double salary) {
		super(id, name, salary);
	}
	@Override
	public void work() {
		System.out.println("厨师炒菜多加点盐...");
	}
}

public class CaseShow {
	public static void main(String[] args) {
		// 抽象类不能创建对象,抽象类的抽象方法没有方法体,无法执行,所以不能创建成对象.
		//创建子类
		Manager m = new Manager();
		m.work();
		
		Cook c = new Cook("p2", "库克", 1);
		c.work();
	}
}

接口的组成

• 关键字 interface 修饰的(public interface)
• 必须公开,因为本身是要被实现的,私有会使接口无意义
• 接口中的方法是没有方法体,可以看作是实现类方法的一种规范
• 接口与类之间是实现关系,使用关键字 implements 实现
• 接口中不能实例化
• 接口与接口之间可以多继承,接口与实现类可以多实现
• 接口成员变量默认为public static final 修饰,且必须赋值,不能修改
• 接口中的方法默认定义为public abstract 不论写没写
• 1.8以后接口还有默认方法(实例方法),静态方法,还包含私有实例方法和私有静态方法
  接口的定义

/**
接口可以多继承
*/
public interface InterfaceName{
    //抽象方法
    //接口中定义的成员变量默认加上public static final 修饰
    //接口中定义的方法默认 public abstract 修饰
    void run(); //public abstract void run();
    //默认方法
    //子接口重写默认方法时,default可以保留
    //实现类重写默认方法时,default不可以保留
    public default void method1(){
        //执行语句
    }
    //静态方法
    public static void method2(){
        //执行语句
    }
    //私有方法
    private void method3(){
       //执行语句
    }
}

接口实现

/**
接口可以多实现
*/
[修饰符] class ClassName implement interface1,interface2,interface3...{

}

this关键字和super关键字

• this代表所在类的当前对象引用(表示当前对象)
• super代表所在类的上一级对象(表示父类对象)
• 所有类的最高父类Object
• this()或super();都只能存在构造器中的第一行,且两者在同一个构造器中只能存在一个.
• 都不能用于static修饰的变量,方法,代码块中;

static关键字

• 被static修饰的成员,是属于类的,存放在静态区中,没有static修饰的是属于对象的.
• 可以修饰方法,内部类,变量
• 静态代码块:必须static修饰,必须放在类下,与类一起加载,只要一启动程序,就会执行一次

final关键字

• 可以修饰类变量和方法
  - 被修饰的类不能被继承
  - 被修饰的方法不能被重写
  - 被修饰的变量有且仅能赋值一次

基本数据类型

序号	类型	字节大小	包装类	数据范围
1	byte	8-bit(1字节)	Byte	-128 ~ 127
2	char	16-bit(2字节)	Character	0~65535
3	boolean		Boolean	true或false
4	short	16-bit (2字节)	Short	-32768-32767
5	int	32-bit(4字节)	Integer	-2147483648-2147483647
6	long	64-bit(8字节)	Long
7	float	32-bit(4字节)	Float
8	double	64-bit(8字节)	Double