Java面向对象下笔记&1000以内素数

面向对象(下)

Static关键字

无论是否产生了对象，或无论产生了多少个对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每个中国人都共享这个国家名称，不用在每个中国人的实例对象中都单独分配一个用于代表国家名称的变量

static的使用

可以用来修饰：属性、方法、代码块、内部类

static可以用来修饰属性：静态变量(类变量)

实例变量：我们创建了多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中一个实例对象的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：创建的类的多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的
静态变量随着类的加载而加载，即静态变量的加载要早于对象的创建，可以通过类.静态变量的方式进行调用
- 由于类只会加载一次，则静态变量在内存中存在一份，存在于方法区的静态域中
静态属性举例：System.out、Math.PI

使用static修饰方法：静态方法

随着类的加载而加载，可以通过类.静态方法的方式进行调用
静态方法中，只能调用静态的方法或属性，非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

static注意点

静态的方法内，不能使用this关键字、super关键字

单例设计模式(Singleton)

单例模式就是采取一定的方法保证在整个的软件系统中对某个类只能存在一个对象实例

单例模式实现

懒汉式：在对象使用时才创建，延迟创建对象节省内存空间

饿汉式：提前创建好对象，提前分配好内存空间

    //饿汉式单例模式
    class Bank{
        //1. 私有化类的构造器
        private Bank() {
        }
        //2. 内部创建类的对象
        //4. 必须要求此对象也必须是静态的
        private static Bank instance = new Bank();
        //3.提供公共的静态方法，返回类的对象
        public static Bank getInstance() {
            return instance;
        }
    }

    //懒汉式
    class Order{
        //1. 私有化类的构造器
        private Order() {	
        }

        //2.声明当前类的对象，没有初始化
        //4. 此对象也必须声明为static
        private static Order instance = null;

        //3. 声明public static的返回当前类对象的方法
        //注意：当前写法存在线程不安全问题（可能需要加锁）
        public static Order getInstance() {
            if(instance == null)
                instance = new Order();
            return instance;
        }	
    }

代码块(初始化块)

代码块用来初始化类、对象
代码块如果用修饰符修饰，只能用static
分类：静态代码块和非静态代码块
- 静态代码块：内部可以有输出语句，随着类的加载而执行，只执行一次；用于初始化类的一些静态属性；如果一个类中声明了多个代码块，则根据声明的先后顺序执行；静态代码块的执行优先于非静态代码块
- 非静态代码块：随着对象的创建而执行；没创建一个对象，执行一次；可以在创建对象时，对对象的属性等进行初始化

final关键字

final可以用来修饰结构、方法、类、变量

final用来修饰一个类：此类不能被其他类继承
- 比如String类、System类、StringBuffer类
final用来修饰方法：表明此方法不能被重写
final用来修饰变量：此时变量就称为是一个常量(类似于C++const关键字)
- 赋值方式：可以通过显示初始化；代码块中初始化；构造器初始化；
final修饰局部变量：
- final修饰形参时，表明此形参是一个常量，当我们调用此方法是，给常量形参一个实参，一旦赋值，方法体内就不可修改
static final 用来修饰属性(全局常量)、方法(用类来调用不可重写)

abstract关键字

abstract可以用来修饰结构、类、方法

abstract修饰类：抽象类
- 该类不能实例化
- 抽象类中一定有构造器，便于子类调用
- 开发中都会提供抽象类的子类，子类可以创建对象
abstract修饰方法：抽象方法
- 抽象方法只有方法声明，没有方法体
- 包含抽象方法的类，一定是抽象类，反之，抽象类中可以没有抽象方法
- 若子类子类重写了父类的所有抽象方法后，子类方可实例化，若没有，则子类也必须是抽象类
使用注意
- 不能用来修饰：属性、构造器等结构
- 不能修饰私有方法、静态方法、final方法、final类

匿名子类&匿名对象

使用抽象类可以直接实现匿名子类

	//Person是一个抽象类，eat()方法是一个抽象方法
	public static void main(String[] args) {
		method(new Student());//匿名对象
		//创建了一个匿名类的对象
		Person p1 = new Person() {
			@Override
			public void eat() {
				System.out.println("匿名对象，吃东西");
			}
		};
		//匿名子类的匿名对象
		method(new Person() {
			@Override
			public void eat() {
			}
		});
	}	
	public static void method(Person p) {
		p.eat();
		p.walk();
	}

模板方法的设计模式

abstract class Template{
	public void spendTime() {
		long start = System.currentTimeMillis();
		this.code();
		long end = System.currentTimeMillis();
		System.out.println("spend time is "+(end - start));
	}
	public abstract void code();
}
class SubTemplate extends Template{
	//1000以内的素数
	@Override
	public void code() {
		for(int i=2;i<=1000;i++) {
			boolean isFlag = true;
			//2,3不进入j层循环
			for(int j=2;j<=Math.sqrt(i);j++) {
				if(i % j == 0) {
					isFlag = false;
					break;
				}
			}
			if(isFlag) {
				System.out.println(i+" ");
			}
		}
	}
}

posted @ 2022-06-18 09:44 Isaac-- 阅读(80) 评论(0) 收藏举报

刷新页面返回顶部

Isaac--