public class SingletonTest1 {
public static void main(String[] args) {
Bank bank1 = Bank.getInstance();
Bank bank2 = Bank.getInstance();
System.out.println(bank1.equals(bank2));
}
}
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须声明为静态的
private static Bank instance = new Bank();
//3.提供公共的静态的方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
public class SingletonTest2 {
}
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;
}
}
单例模式的优点：由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置 、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决举例：java.lang.Runtime单例模式–应用场景
1.网站计数器
2.应用程序的日志应用
3.数据库连接池
4.项目中，读取配置文件的类
5.Apllication
6.Windows的Task Manager(任务管理器)
7.Windows的Recycle Bin(回收站)
理解main方法语法
public class MainTest {
public static void main(String[] args){//入口
Main.main(new String[100]);
MainTest test = new MainTest();
test.show();
}
public void show(){
}
}
class Main{
public static void main(String[] args){
for(int i = 0; i < args.length; i++){
args[i] = "args_"+i;
System.out.println(args[i]);
}
}
}
public class MainDemo {
public static void main(String[] args) {
for(int i = 0; i < args.length; i++){
System.out.println("*******"+args[i]);
int num = Integer.parseInt(args[i]);
System.out.println("######"+num);
}
}
}
代码块
public class BlockTest {
public static void main(String[] args) {
String desc = Person.desc;
Person p1 = new Person();
Person p2 = new Person();
Person.info();
}
}
class Person{
String name;
int age;
static String desc = "我是一个人";
//构造器
public Person(){
System.out.println("hello！！！");
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//static代码块
static{
System.out.println("hello, static block-1");
}
//static代码块
static{
System.out.println("hello, static block-2");
//调用静态结构
desc = "www.com.com";
info();
}
//非static代码块
{
System.out.println("hello, block");
//调用静态结构
desc = "www.com.com.com";
info();
//调用非静态结构
age = 19;
eat();
}
//方法
public void eat(){
System.out.println("吃饭");
}
@Override
public String toString(){
return "Person [name=" + name +",age="+ age +"]";
}
public static void info(){
System.out.println("www.com");
}
}
关键字：final
final可以用来修饰的结构：类、方法、变量final用来修饰一个类:此类不能被其他类所继承。比如：String类、System类、StringBuffer类final用来修饰方法，表明此方法不可以被重写。比如Object类中getClass();final用来修饰变量，此时的“变量”就称为一个常量
final修饰属性，可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值
static final 用来修饰属性：全局常量（只能用于修饰属性和方法） 抽象类与抽象方法
abstract:抽象的abstract可以用来修饰的结构：类、方法abstract修饰类：抽象类
此类不能实例化
此类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
abstract修饰方法：抽象方法
抽象方法只有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类
若子类重写了父类中的所有的抽象方法后，此子类方可实例化；若子类没有重写父类中的所有的抽象方法后，则此子类也是一个抽象类，需要使用abstract修饰。
abstract使用上的注意点
abstract不能用来修饰：属性、构造器等结构
abstract不能用来修饰私有方法、静态方法、final的方法、final的类
抽象类的应用：模板方法的设计模式
import javax.swing.plaf.synth.SynthSeparatorUI;
public class TemplateTest {
public static void main(String args[]){
SubTemplate t = new SubTemplate();
t.spendTime();
}
}
abstract class Template{
//计算某段代码执行所需要花费的时间
public void spendTime(){
long start = System.currentTimeMillis();
this.code();//不确定的部分、易变的部分
long end = System.currentTimeMillis();
System.out.println("花费的时间为："+(end-start));
}
public abstract void code();
}
class SubTemplate extends Template{
@Override
public void code(){
for(int i = 2;i <= 1000; i++){
boolean isFlag = true;
for(int j = 2;j <= Math.sqrt(i);j++){
if(i%j==0){
isFlag = false;
}
}
if(isFlag){
System.out.println(i);
}
}
}
}
//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {
public static void main(String[] args) {
BankTemplateMethod btm = new DrawMoney();
btm.process();
BankTemplateMethod btm2 = new ManageMoney();
btm2.process();
}
}
abstract class BankTemplateMethod {
// 具体方法
public void takeNumber() {
System.out.println("取号排队");
}
public abstract void transact(); // 办理具体的业务 //钩子方法
public void evaluate() {
System.out.println("反馈评分");
}
// 模板方法，把基本操作组合到一起，子类一般不能重写
public final void process() {
this.takeNumber();
this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码
this.evaluate();
}
}
class DrawMoney extends BankTemplateMethod {
public void transact() {
System.out.println("我要取款！！！");
}
}
class ManageMoney extends BankTemplateMethod {
public void transact() {
System.out.println("我要理财！我这里有2000万美元!!");
}
}
接口(interface)
public class InterfaceTest {
public static void main(String[] args){
System.out.println(Flyable.MAX_SPEED);
System.out.println(Flyable.MIN_SPEED);
Plane plane = new Plane();
plane.fly();
}
}
interface Flyable{
//全局常量
public static final int MAX_SPEED = 7900;//第一宇宙速度
int MIN_SPEED =1;//省略了public static final
//抽象方法
public abstract void fly();
//省略了public abstract
void stop();
}
interface Attackable{
void attack();
}
class Plane implements Flyable{
@Override
public void fly(){
System.out.println("通过引擎起飞");
}
@Override
public void stop(){
System.out.println("驾驶员减速停止");
}
}
class Bullet extends Object implements Flyable,Attackable,CC{
@Override
public void attack(){
}
@Override
public void fly(){
}
@Override
public void stop(){
}
@Override
public void method1(){
}
@Override
public void method2(){
}
}
/
public class NetworkTest {
public static void main(String[] args) {
Server server = new Server();
ProxyServer proxyserver = new ProxyServer(server);
proxyserver.browse();
}
}
interface Network{
public void browse();
}
//被代理类
class Server implements Network{
@Override
public void browse(){
System.out.println("真实的服务器访问网络");
}
}
//代理类
class ProxyServer implements Network{
private Network work;
public ProxyServer(Network work){
this.work = work;
}
public void check(){
System.out.println("联网之前的检查工作");
}
@Override
public void browse(){
check();
work.browse();
}
}
public class StaticProxyTest {
public static void main(String[] args) {
Star s = new Proxy(new RealStar());
s.confer();
s.signContract();
s.bookTicket();
s.sing();
s.collectMoney();
}
}
interface Star {
void confer();// 面谈
void signContract();// 签合同
void bookTicket();// 订票
void sing();// 唱歌
void collectMoney();// 收钱
}
class RealStar implements Star {
public void confer() {
}
public void signContract() {
}
public void bookTicket() {
}
public void sing() {
System.out.println("明星：歌唱~~~");
}
public void collectMoney() {
}
}
class Proxy implements Star {
private Star real;
public Proxy(Star real) {
this.real = real;
}
public void confer() {
System.out.println("经纪人面谈");
}
public void signContract() {
System.out.println("经纪人签合同");
}
public void bookTicket() {
System.out.println("经纪人订票");
}
public void sing() {
real.sing();
}
public void collectMoney() {
System.out.println("经纪人收钱");
}
}
public class SubClassTest {
public static void main(String[] args){
SubClass s = new SubClass();
// s.method1();
// SubClass.method1();
//知识点1：接口中定义的静态方法，只能通过接口来调用
CompareA.method1();
//知识点2：通过实现类的对象，可以调用接口中的默认方法
//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
s.method2();
//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的方法，
//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法-->类优先原则
s.method3();
//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
//这就需要我们必须在实现类中重写此方法
}
}
class SubClass extends SuperClass implements CompareA,Compare8{
public void method2(){
System.out.println("上海11");
}
//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
public void myMethod(){
method3();//调用自己定义的重写方法
super.method3();//调用的是父类中声明的
//调用调用接口中的默认方法
CompareA.super.method3();
Compare8.super.method3();
}
}
public interface CompareA {
//静态方法
public static void method1(){
System.out.println("北京");
}
//默认方法
public default void method2(){
System.out.println("上海");
}
default void method3(){
System.out.println("广州");
}
}
public class SuperClass {
public void method3(){
System.out.println("Super:北京");
}
}
public interface Compare8 {
default void method3(){
System.out.println("Compare8:广州");
}
}
内部类
public class InnerClassTest {
public static void main(String[] args){
//创建Dog实例(静态的成员内部类)
Person.Dog dog = new Person.Dog();
dog.show();
//创建Bird实例(非静态的成员内部类)
//Person.Bird bird = new Person.Bird();//错误的，必须先实例化Person类再通过对象去调用
Person p = new Person();
Person.Bird bird = p.new Bird();
bird.sing();
System.out.println();
bird.display("黄鹂");
}
}
class Person{
String name = "小明";
int age;
public void eat(){
System.out.println("人：吃饭");
}
//静态成员内部类
static class Dog{
String name;
int age;
public void show(){
System.out.println("卡拉是条狗");
}
}
//非静态成员内部类
final class Bird{
String name = "杜鹃";
public Bird(){
}
public void sing(){
System.out.println("我是一只小鸟");
Person.this.eat();//调用外部类属性
eat();
}
public void display(String name){
System.out.println(name);//方法的形参
System.out.println(this.name);//内部类的属性
System.out.println(Person.this.name);//外部类的属性
}
}
public void method(){
//局部内部类
class AA{
}
}
{
//局部内部类
class BB{
}
}
public Person(){
//局部内部类
class CC{
}
}
}
public class InnerClassTest1 {
//开发中很少见
public void method(){
//局部内部类
class AA{
}
}
//返回了一个实现了Comparable接口的类的对象
public Comparable getComparable(){
// //创建了一个实现了Comparable接口的类:局部内部类
// //方法一
// class MyComparable implements Comparable{
// @Override
// public int compareTo(Object o){
// //
// return 0;
// }
// }
// return new MyComparable();
//方式二
return new Comparable(){
@Override
public int compareTo(Object o){
return 0;
}
};
}
}
