static关键字
- static:静态的，可以用来修饰属性、方法、代码块（或初始化块）、内部类
2.static修饰属性（类变量）:
由类创建的所有的对象，都共用这一个属性
当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
类变量随着类的加载而加载的，而且独一份
静态的变量可以直接通过“类.类变量”的形式来调用
类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。
类变量存在于静态域中。
- static修饰方法（类方法）:
- 随着类的加载而加载，在内存中也是独一份
- 可以直接通过“类.类方法”的方式调用
- .内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
- 静态的方法内是不可以有this或super关键字的！
- 静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构
public class TestCircle {
public static void main(String[] args) {
Circle c1 = new Circle();
Circle c2 = new Circle(2.3);
System.out.println(c1);
System.out.println(c2);
System.out.println(Circle.getTotal());
}
}
class Circle{
private double radius;
private static String info = "我是一个圆";
private int id;//编号
private static int init = 1001;//控制每个对象的id
private static int total = 0;//记录创建了多少个对象
public Circle(){
this.id = init++;
total++;
}
public Circle(double radius){
this.radius = radius;
this.id = init++;
total++;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public static String getInfo() {
return info;
}
public static void setInfo(String info) {
Circle.info = info;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public static int getTotal() {
return total;
}
public static void setTotal(int total) {
Circle.total = total;
}
@Override
public String toString() {
return "Circle [radius=" + radius + ", id=" + id + "]";
}
public static void show(){
System.out.println(Circle.info);
}
public void desc(){
System.out.println(this.info);
}
}
单例设计模式
解决的问题：如何只让设计的类只能创建一个对象
如何实现：饿汉式 & 懒汉式
- 饿汉式1
class Bank{
//1.私有化构造器
private Bank(){}
//2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
//4.要求此对象也为static的
private static Bank instance = new Bank();
//3.此公共的方法，必须为static
public static Bank getInstance(){
return instance;
}
}
- 饿汉式2
class Bank{
//1.私有化构造器
private Bank(){}
//2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
//4.要求此对象也为static的
private static Bank instance = null;
static{
instance = new Bank();
}
//3.此公共的方法，必须为static
public static Bank getInstance(){
return instance;
}
}
- 懒汉式
class Bank{
private Bank(){}
private static Bank instance = null;
public static Bank getInstance(){
if(instance == null){//可能存在线程安全问题的！
instance = new Bank();
}
return instance;
}
}
main()方法
public static void main(String[] args){
//方法体
}
//1.main()是一个方法，是主方法，为程序的入口
//2.权限修饰符：public protected 缺省 private ---面向对象的封装性
//3.对于方法来讲：static final abstract
//4.方法的返回值：void / 具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return
//5.方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意
//6.形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。 形参 & 实参---方法的参数传递机制：值传递
//7.方法体：方法定义的是一种功能，具体的实现由方法体操作。
代码块
代码块：是类的第4个成员
作用：用来初始化类的属性
分类：只能用static来修饰。-
静态代码块：
- 里面可以有输出语句
- 随着类的加载而加载，而且只被加载一次
- 多个静态代码块之间按照顺序结构执行
- 静态代码块的执行要早于非静态代码块的执行。
- 静态的代码块中只能执行静态的结构(类属性，类方法)
-
非静态代码块：
- 可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
- 里面可以有输出语句
- 一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
- 每创建一个类的对象，非静态代码块就加载一次。
- 非静态代码块的执行要早于构造器
-
关于属性赋值的操作：
- 默认的初始化
- 显式的初始化或代码块初始化(此处两个结构按照顺序执行)
- 构造器中；
- 以上是对象的属性初始化的过程------
- 通过方法对对象的相应属性进行修改
final关键词
final:最终的 ，可以用来修饰类、属性、方法
final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类
final修饰方法：不能被重写。如：Object类的getClass()
final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示
此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。变量用static final修饰：全局常量。比如：Math 类的PI
class D{
final int I = 12;
final double PI;
final String NAME;
public void m1(){
System.out.println(I);
// I = 10;
}
{
PI = 3.14;
}
public D(){
NAME = "DD";
}
public D(String name){
this();
//NAME = name;
}
}
抽象 abstract
abstract：抽象的，可以用来修饰类、方法
- abstract修饰类：抽象类
- 不可被实例化
- 抽象类有构造器 (凡是类都有构造器)
- 抽象方法所在的类，一定是抽象类。
- 抽象类中可以没有抽象方法。
- 当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化
2.abstract修饰方法：抽象方法
- 格式：没有方法体，包括{}.如：public abstract void eat();
- 抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
- 若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的
//模板方法设计模式
public class TestTemplate {
public static void main(String[] args) {
new SubTemplate().spendTime();
}
}
abstract class Template {
public abstract void code();
public void spendTime() {
long start = System.currentTimeMillis();
this.code();
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));
}
}
class SubTemplate extends Template {
public void code() {
boolean flag = false;
for(int i = 2;i <= 10000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){
flag = true;
break;
}
}
if(!flag){
System.out.println(i);
}
flag = false;
}
}
}
接口 interface
接口（interface） 是与类并行的一个概念
- 接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
- 接口是没有构造器的
- 接口定义的就是一种功能。此功能可以被类所实现（implements）。
比如：class CC extends DD implements AA - 实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
- 类可以实现多个接口。----java 中的类的继承是单继承的
- 接口与接口之间也是继承的关系，而且可以实现多继承
5,6描述的是java中的继承的特点。
- 接口与具体的实现类之间也存在多态性
工厂方法的设计模板
//接口的应用：工厂方法的设计模式
public class TestFactoryMethod {
public static void main(String[] args) {
IWorkFactory i = new StudentWorkFactory();
i.getWork().doWork();
IWorkFactory i1 = new TeacherWorkFactory();
i1.getWork().doWork();
}
}
interface IWorkFactory{
Work getWork();
}
class StudentWorkFactory implements IWorkFactory{
@Override
public Work getWork() {
return new StudentWork();
}
}
class TeacherWorkFactory implements IWorkFactory{
@Override
public Work getWork() {
return new TeacherWork();
}
}
interface Work{
void doWork();
}
class StudentWork implements Work{
@Override
public void doWork() {
System.out.println("学生写作业");
}
}
class TeacherWork implements Work{
@Override
public void doWork() {
System.out.println("老师批改作业");
}
}
代理模式
//接口的应用：代理模式（静态代理）
public class TestProxy {
public static void main(String[] args) {
Object obj = new ProxyObject();
obj.action();
}
}
interface Object{
void action();
}
//代理类
class ProxyObject implements Object{
Object obj;
public ProxyObject(){
System.out.println("代理类创建成功");
obj = new ObjctImpl();
}
public void action(){
System.out.println("代理类开始执行");
obj.action();
System.out.println("代理类执行结束");
}
}
//被代理类
class ObjctImpl implements Object{
@Override
public void action() {
System.out.println("=====被代理类开始执行======");
System.out.println("=====具体的操作======");
System.out.println("=====被代理类执行完毕======");
}
}