main语法
package chapter10.D1类变量和类方法;
public class Main01 {
private static String name="征途";
private int n1=1000;
private void cry(){
System.out.println("main02方法");
}
public static void hi(){
System.out.println("main01方法");
}
public static void main(String[] args) {
//静态方法可访问本类静态成员
System.out.println(name);
hi();
//静态方法不能调用本类非静态成员,只能创建对象
new Main01().n1=10;
new Main01().cry();
System.out.println(new Main01().n1);
}
}
package chapter10.D1类变量和类方法;
//传参数按 Main02>edit configuration>program auguements
public class Main02 {
public static void main(String[] args) {
for (int i = 0; i < args.length ; i++) {
System.out.println("args["+i+"]="+args[i]);
}
}
}
代码块
package chapter10.D2代码块;
public class CodeBlock {
public static void main(String[] args) {
Movie xx = new Movie("你好");
Movie yy = new Movie("阴天", 200);
}
}
class Movie{
private String name;
private double price;
private String director;
//3个构造器构成重载,可以把相同语句放入代码块,如此不管调用哪个构造器(创建对象)都会调用代码块内容
//代码块优先于构造器调用
//以下是普通代码块,每创建一个对象就执行
{
System.out.println("方法");
System.out.println("应用");
}
public Movie(String name) {
System.out.println("(String name)代码被调用");
this.name = name;
}
public Movie(String name, double price) {
System.out.println("(String name, double price)构造器被调用");
this.name = name;
this.price = price;
}
public Movie(String name, double price, String director) {
this.name = name;
this.price = price;
this.director = director;
}
}
package chapter10.D2代码块;
import chapter07.D5多态.Detail.Animal;
//静态代码块随类的加载而执行,只执行一次
public class CodeBlockDetail {
public static void main(String[] args) {
//类被加载情况举例
AA aa = new AA();//创建对象实例时会被调用
BB bb = new BB();//创建子类对象,父类会优先被加载
System.out.println(Cat.n1);//使用类静态成员时被调用,但会优先调用父类
System.out.println(Cat.n2);//只执行父类
//普通代码块只在创建对象时执行,创一次调用一次
}
}
//静态代码块
class AA{
static {
System.out.println("AA的静态代码块1被执行....");
}
}
class BB extends AA{
static {
System.out.println("BB 的静态代码块1被执行");
}
}
class Animal2{
public static int n1=99;
public static int n2=9;
static {
System.out.println("Animal2类的代码块被执行");
}
}
class Cat extends Animal2 {
public static int n1=999;//静态属性
static {
System.out.println("Cat的静态代码块被执行");
}
{
System.out.println("普通代码块执行");
}
}
package chapter10.D2代码块;
public class CodeBlockDetail02 {
public static void main(String[] args) {
A a = new A();//1.getN1() 2.n1 3.静态代码块 顺序可反 4.普通代码块 5.getN2 6.n2 7构造器
}
}
class A{
public A() {
System.out.println("构造器执行");
}
//静态代码块和静态属性初始化优先级一样,按顺序执行
private static int n1=getN1();//静态属性初始化
{
System.out.println("A 普通代码块01");
}
private int n2=getN2();
static {//静态代码块
System.out.println("A 静态代码块01");
}
public int getN2(){
System.out.println("getN2被调用");
return 50;
}
public static int getN1(){
System.out.println("getN1被调用...");
return 100;
}
}
package chapter10.D2代码块;
public class CodeBlockDetail03 {
public static void main(String[] args) {
BBB bbb = new BBB();
}
}
class AAA{
public AAA(){
System.out.println("AAA构造器被调用");
}
}
class BBB extends AAA{
{
System.out.println("BBB普通代码块");
}
public BBB(){
//super
//普通代码块
System.out.println("BBB构造器被调用");
}
}
package chapter10.D2代码块;
//父静态(代码块、属性),子静,父普(代码块、属性),父构,子普,子构
public class CodeBlockDetail04 {
public static void main(String[] args) {
B02 b02 = new B02();//1类的加载 2创建对象
new C02();
}
}
class A02{
private static int n1=getVal01();
static {
System.out.println("A02静态代码块");//2
}
{
System.out.println("A02普通代码块");//5
}
public int n3=getVal02();
public static int getVal01(){
System.out.println("getVal01");//1
return 10;
}
public int getVal02(){
System.out.println("getVal02");///6
return 10;
}
public A02() {//类加载完,创建对象,执行隐藏语句,转到5
//super
//普通代码块,属性
System.out.println("A02无参构造器");//7
}
}
class B02 extends A02{
private static int n3=getVal03();
static {
System.out.println("B02静态代码块");//4
}
public int n5=getVal04();
{
System.out.println("B02普通代码块");//9
}
public static int getVal03(){
System.out.println("getVal03");//3
return 10;
}
public int getVal04(){
System.out.println("getVal04");//8
return 10;
}
public B02() {//跳转super
System.out.println("B02无参构造器执行");//10
}
}
//静态代码块只能调用静态成员(属性,方法),普通代码块可以调用任意成员
class C02{
private int n1=100;
private static int n2=200;
private void m1(){
}
private static void m2(){
}
static {
System.out.println(n2);//静态代码块只能调用静态成员
m2();
}
{
System.out.println(n1);//普通代码块可以调用所有
System.out.println(n2);
m1();
m2();
}
}
设计模式
单例模式懒汉式
package chapter10.D3设计模式.单例模式懒汉式;
//懒汉式单例模式,只有当用户使用getInstance时候才返回对象,再次调用时仍然返回上次对象,保证对象单例
public class single02 {
public static void main(String[] args) {
System.out.println(Cat.n1);//加载类同时加载静态成员,但对象没创建
Cat instance = Cat.getInstance();//这时候才创建
System.out.println(instance);
Cat instance1 = Cat.getInstance();//不会再创建新的
System.out.println(instance1);
}
}
//程序运行中只能创一个Cat对象,单例模式
class Cat{
private String name;
public static int n1=999;
private Cat(String name) {
System.out.println("构造器被调用");
this.name = name;
}
private static Cat cat;//定义一个static 静态属性对象,不创建对象
public static Cat getInstance(){//有线程安全问题
if (cat==null){//若没创建对象
cat=new Cat("小可爱");
}
return cat;
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
单例模式饿汉式
package chapter10.D3设计模式.单例模式饿汉式;
public class Single {
public static void main(String[] args) {
//GirFriend xh = new GirFriend("小红");避免多个对象
GirFriend gf = GirFriend.getGf();//拿到对象,再拿一次也是同一个对象
System.out.println(gf);
System.out.println(GirFriend.n1);//会加载类,加载静态成员,饿汉式可能创建了对象,但没使用
}
}
class GirFriend{
private String name;
public static int n1=100;
//保证只能创建一个GirFriend对象 1.构造器私有化(防止类外部创建) 2.内部类中创建对象(static) 3.提供公共static方法,返回gf对象
private GirFriend(String name) {
this.name = name;
}
private static GirFriend gf =new GirFriend("小红");//若不加static,则无法在静态方法中使用,方法不静态,则又要创建对象调用
public static GirFriend getGf(){
return gf;
}
@Override
public String toString() {
return "GirFriend{" +
"name='" + name + '\'' +
'}';
}
}