大丰网站建设,网站建设方案书是啥,怎么根据网站前端做网站后台,优化seo方案一、类变量、静态变量static static访问方式#xff1a;
public class VisitStatic {public static void main(String[] args) {//方法一://类名.类变量名//说明#xff1a;类变量是随着类的加载而创建#xff0c;所以即使没有创建对象实例也可以访问System.out.println(A.…一、类变量、静态变量static static访问方式
public class VisitStatic {public static void main(String[] args) {//方法一://类名.类变量名//说明类变量是随着类的加载而创建所以即使没有创建对象实例也可以访问System.out.println(A.name);//方法二:A a new A();//通过对象名.类变量名System.out.println(a.name a.name);}
}class A {//类变量//类变量的访问必须遵守 相关的访问权限. public static String name 韩顺平教育;//普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量private int num 10;
}
二、静态方法,类方法static
public static void hi() {//类方法中不允许使用和对象有关的关键字//比如 this 和 super。普通方法(成员方法)可以。System.out.println(this.n1);(报错)
}静态方法(类方法)只能访问 静态方法或静态变量。 普通成员方法既可以访问 非静态成员也可以访问静态成 三、static课堂练习 答案9 10 11 因为count 所以先输出后 第一次 new count()方法先输出9后则等于10。 第二次虽然也是new但是是一个static方法所以new出来的也是count10。 四、main方法 五、代码块 作用 (1) 下面的三个构造器都有相同的语句 (2) 这样代码看起来比较冗余 (3) 这时我们可以把相同的语句放入到一个代码块中即可 (4) 这样当我们不管调用哪个构造器创建对象都会先调用代码块的内容 (5) 代码块调用的顺序优先于构造器.
public class CodeBlock01 {public static void main(String[] args) {Movie movie new Movie(你好李焕英);System.out.println();Movie movie2 new Movie(唐探 3, 100, 陈思诚);}
}class Movie {private String name;private double price;private String director;{System.out.println(电影屏幕打开...);System.out.println(广告开始...);System.out.println(电影正是开始...);};public Movie(String name) {System.out.println(Movie(String name) 被调用...);this.name name;}public Movie(String name, double price, String director) {System.out.println(Movie(String name, double price, String director) 被调用...);this.name name;this.price price;this.director director;}
}
输出结果
六、代码块的注意事项 七、单例设计模式
什么是单例
单例模式应用实例 以下代码不是单例模式因为单例模式只能有一个实例对象。(只能有一个女朋友)
public class SingleTon01 {public static void main(String[] args) {GirlFriend xh new GirlFriend(小红);GirlFriend xb new GirlFriend(小白);}
}//有一个类 GirlFriend
//只能有一个女朋友
class GirlFriend {private String name;public GirlFriend(String name) {this.name name;}
}修改为单例模式-饿汉式
public class SingleTon01 {public static void main(String[] args) {//通过方法可以获取对象GirlFriend instance GirlFriend.getInstance();System.out.println(instance);}
}//有一个类 GirlFriend
//只能有一个女朋友
class GirlFriend {private String name;//为了能够在静态方法中返回 gf 对象需要将其修饰为 static//[单例模式-饿汉式]缺点对象还没有创建就应该存在了。项目通常是重量級的對象, 饿汉式可能造成创建了对象但是沒有使用使得资源浪费 private static GirlFriend gf new GirlFriend(小红红);/**如何保障我们只能创建一个 GirlFriend 对象*步骤[单例模式-饿汉式] * 1. 将构造器私有化 * 2. 在类的内部直接创建对象(该对象是 static)* 3. 提供一个公共的 static 方法返回 gf 对象*/private GirlFriend(String name) {this.name name;}public static GirlFriend getInstance() {return gf;}Overridepublic String toString() {return GirlFriend [name name ];}
}懒汉式
public class SingleTon02 {public static void main(String[] args) {Cat instance Cat.getInstance();System.out.println(instance);//再次调用 getInstanceCat instance2 Cat.getInstance();System.out.println(instance2);System.out.println(instance instance2);// T}
}//希望在程序进行过程中只能创建一个 Cat 對象
//使用单例模式
class Cat {private String name;private static Cat cat; // 默认是 null/**步骤 * 1.仍然将造器私有化 * 2.定义一个 static 静态属性对象 * 3.提供一个 public 的 static 方法可以返回一个Cat 对象 * 4.懒汉式:只有當用戶使用 getInstance 時才返回 cat 对象, 后面再次调用时候会返回上次创建的cat对象* 从而保证了单例*/ private Cat(String name) {this.name name;}public static Cat getInstance() {if (cat null) { // 如果话沒有创建 cat 對象cat new Cat(小可爱);}return cat;}Overridepublic String toString() {return Cat{ name name \ };}
}运行结果
饿汉式 VS 懒汉式 个人总结 饿汉式中只要GirlFriend被调用则不管调用哪个函数或者属性 比如调用GirlFriend中的public static int a 1;的情况下 private static GirlFriend gf new GirlFriend(“小红红”);一定会被执行则“小红有可能就在不需要的情况下就会被创建。” 而懒汉式则应用到了 if (cat null) { cat new Cat(“小可爱…”); } 需要经过判断才会被执行 八、final关键字 一般情况下final和static一起使用效率更高不会导致类加载。
public class A {public static void main(String[] args) {System.out.println(AA.num);}
}class AA{public static int num 999;static {System.out.println(AA静态代码块被执行...);}
}输出结果 static的代码块会被默认执行. . .
加上final后
class AA{public final static int num 999;static {System.out.println(AA静态代码块被执行...);}
}final修饰的类或者属性被放在了常量池中 final练习//下面的代码是否有误为什么?
public int addOne(final int x) { x; //错误,原因是不能修改 final x 的值return x 1; //这里是可以因为没有改变x的值
}九、抽象类的介绍 抽象类细节 细节1 public static void main(String[] args) {new AA(); // 报错}
abstract class AA{
}练习题
十、模板模式——抽象类
//抽象类-模板设计模式
abstract class Template { // 抽象方法public abstract void job();// 实现方法调用 job 方法public void calculateTime() {//得到开始的时间long start System.currentTimeMillis();// 动态绑定机制job(); //得的结束的时间long end System.currentTimeMillis();System.out.println(任务执行时间 : (end - start));}
}// AA 类
class AA extends Template {/** 计算任务* 1.... 800000* 实现 Template 的抽象方法 job*/Overridepublic void job() {long num 0;for (long i 1; i 800000; i) {num i;}}
}// BB 类
class BB extends Template {// 这里也去重写了 Template 的 job 方法public void job() {long num 0;for (long i 1; i 80000; i) {num * i;}}
}public class TestTemplate {public static void main(String[] args) {//子类调用父类方法。AA aa new AA();aa.calculateTime(); // 这里还是需要有良好的 OOP 基础对多态BB bb new BB();bb.calculateTime();}
}十一、接口 接口和抽象类里的方法 一样都不需要写具体的方法体。其实接口中的方法可以看似成抽象方法只不过在接口中的方法abstrac关键字可以省略。 默认方法需要在方法名前加关键字default。且default仅仅只能使用在接口中 接口的细节 细节6
interface A{int n 1; //实际上就等于 public static final int n 1
}十二、接口 VS 继承 继承 小结: 当子类继承了父类就自动的拥有父类的功能 如果子类需要扩展功能可以通过实现接口的方式扩展. 可以理解 实现接口 是对 java 单继承机制的一种补充 十三、接口多态特征
//Usb接口
interface Usb{void start();void stop();
}//手机
class Phone implements Usb {Overridepublic void start() {System.out.println(手机连接成功开始工作...);}Overridepublic void stop() {System.out.println(手机断开成功结束工作...);}
}//照相机
class Camera implements Usb {Overridepublic void start() {System.out.println(相机连接成功开始工作...);}Overridepublic void stop() {System.out.println(相机断开成功结束工作...);}
}//主机——电脑
class Computer {public void work(Usb usb) {usb.start();usb.stop();}
}public class TestInterface {public static void main(String[] args) {Phone phone new Phone(); Camera camera new Camera(); Computer computer new Computer();//将 相机 连接到主机电脑...computer.work(camera);//将 手机 连接到主机电脑...computer.work(phone);}
}
十四、接口多态传递 //通过BB bb new CC();AA aa new CC();}
}
interface AA {void getAA();
}
interface BB extends AA{}class CC implements BB {Override //必须重写public void getAA() {// TODO Auto-generated method stub }
}
类的五大成员属性、方法、构造器、代码块、内部类
十五、内部类 内部类一共有种
15.1 局部 内部类 public static void main(String[] args) {Outer02 outer02 new Outer02();outer02.m1();
}class Outer02 { // 外部类private int n1 100;private void m2() { System.out.println(Outer02 m2(私有方法));}public void m1() { //方法/** 局部内部类是定义在外部类的局部位置,通常在方法中* 作用域 : 仅仅在定义它的方法或代码块中。例如:内部类Inner02()只能在m1()方法体内使用*/class Inner02{private int n1 999;//可以直接访问外部类的所有成员包含私有的 属性 或 方法public void f1() {m2();//如果外部类和局部内部类的成员重名时System.out.println(内部类的属性: n1);System.out.println(外部类的属性: Outer02.this.n1);}}//外部类在方法中可以创建 Inner02 对象然后调用方法即可Inner02 inner02 new Inner02();inner02.f1();}
}15.2 匿名 内部类 public static void main(String[] args) {Outer03 out new Outer03();out.method();}
}interface IA{public void cry();
}class Outer03 { // 外部类public void method() {/**基于接口的匿名内部类*老韩解读 * 1.需求 想使用 IA 接口,并创建对象 * 2.传统方式是写一个类实现该接口并创建对象* 3.老韩需求是 Tiger/Dog 类只是使用一次后面再不使用* 4. 可以使用匿名内部类来简化开发 * 5. tiger 的编译类型 ? IA* 6. tiger 的运行类型 ? 就是匿名内部* 其实底层 会分配 匿名内部类一个类名 Outer03$1* jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例并且把地址返回给 tiger* 匿名内部类使用一次就不能再使用(这里指的是方法体中的内容不是指tiger对象tiger对象可以使用多次)*/ IA tiger new IA() {Overridepublic void cry() {System.out.println(老虎在叫唤...);}};tiger.cry();}
}
