设计师网上接单的网站营销号
1.类的信息加载完成后，会自动调用静态代码块，可以完成静态属性的初始化功能
对象准备创建时，也会自动调用代码块，但不是静态的；
public class java_3_24
{public static void main(String[] args) {new User08();}}
class User08{static {System.out.println("静态代码块执行1");}static {System.out.println("静态代码块执行2");}static void test(){System.out.println("test...");}{System.out.println("代码块执行");}static {System.out.println("静态代码块执行3");}
}
注意：先调用静态代码块，再调用了代码块，这是准备创建的情况，既会调用代码块，也会调用静态代码块；
public class java_3_24
{public static void main(String[] args) {User08.test(); //因为test是静态方法，所以可以通过类名直接调用；}}
class User08{static {System.out.println("静态代码块执行1");}static {System.out.println("静态代码块执行2");}static void test(){System.out.println("test..."); }{System.out.println("代码块执行");}static {System.out.println("静态代码块执行3");}
}
这是信息加载的情况，只会调用静态代码块；
2.包：package;
在包之中容纳类，调用包中的类：
java.lang.Object;
主要目的是分类管理；类可以没有包；
包的声明语句只能在一个源码文件中使用一次；
包名一般都是小写；
3.一般情况下，使用类时，都会使用类的全名：包名+类，但有例外：
（1）使用的类就在本包中，无需全名；
（2）java.lang中的类，无需全名;
（3）事先import一个类，也无需全名；
例如：
import java.util.Date;
public class java_3_24
{public static void main(String[] args) {Date d = new Date();}}
但import在使用时有需要注意的地方：
（1）import语句只能用于package后，class前；
（2）import可以多次使用，导入多个类；
如果要导入多个类，可以使用通配符*来操作：
import java.util.*;
public class java_3_24
{public static void main(String[] args) {Date d = new Date();}}
4.构建对象：
构造方法：在一个类中如果没有自己设置创建方法，那么JVM会自动添加一个公共的，无参的构造方法，方便使用；
（1）构造方法也是方法，但没void关键字；
（2）方法名和类名完全相同；
（3）构造方法可以传递参数，但是一般传递参数的目的是用于对象属性的赋值；
例如：
public class java_3_24
{public static void main(String[] args) {System.out.println("before");User11 user = new User11();System.out.println("after");user.test();}}
class User11{User11(){System.out.println("user...");}void test(){System.out.println("test...");}
}
在定义构造方法的同时，打印一个user；
例如:
public class java_3_24
{public static void main(String[] args) {User11 user = new User11("zhangsan");System.out.println(user.username);}}
class User11{String username;User11(String name){username = name;}}
打印结果为zhangsan；
5.面向对象编程中有3个非常重要的特征：继承，封装，多态；
下面介绍继承：
（1）类存在父子关系：子类可以直接获取到父类的成员属性和成员方法。
（2）类的继承只能单继承一个父类；
（3）一个父类可以有多个子类；
例如：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Child c = new Child();System.out.println(c.name);c.test();};}class Parent{String name = "zhangsan";void test(){System.out.println("test...");}
}
class Child extends Parent{}
6.如果父类和子类含有相同的属性，那么可以采用特殊的关键字来区分：
super & this. 例如：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Child c = new Child();c.test();};}class Parent{String name = "zhangsan";}
class Child extends Parent{String name = "lisi";void test(){System.out.println(super.name);System.out.println(this.name);}
}
父子类中的构造方法:
父类对象是在子类对象创建前创建完成，创建子类对象前，会调用父类的构造方法完成父类的创建
默认情况下，子类对象创建时，会默认调用父类的构造方法完成父类对象的创建，使用的是super方法；
例如：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Child c = new Child();};}class Parent{Parent(String name){System.out.println("parent...");}}
class Child extends Parent{Child() {super("zhangsan");System.out.println("child...");}
}
父类要求传参才能构建，所以这时省略super方法就行不通了，所以要手动的进行传参，注意super方法时在子类的构建方法中调用的；
7.多态：
所谓的多态，其实就是一个对象在不同场景下表现出来的不同状态和形态；
多态语法其实就是对对象的使用场景进行了约束；
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {Person p = new Person();p.testperson();Person p1 = new Boy();p1.testperson();p1.testboy(); //会报错Person p2 = new Girl();p2.testgirl(); //会报错};}
class Person{void testperson(){System.out.println("testperson");}
}
class Boy extends Person{void testboy(){System.out.println("testboy");}}
class Girl extends Person{void testgirl(){System.out.println("testgirl");}
}
一个对象可以使用的功能取决于引用变量的类型；上面的p1和p2都是person类型，所以可以引用person的功能；
8.一个类中，不能重复声明相同的方法（方法名、参数列表，但是和返回值类型无关），也不能声明相同的属性；
如果方法名相同，但参数列表不同，会被认为是不同的方法，只不过名称一样，这个操作在java中称之为方法的重载；
例如：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {User14 user = new User14();user.login(12321);user.login("nima", "cnm");user.login("123123");}}
class User14{void login(String account, String password){System.out.println("账号密码登录");}void login(int tel){System.out.println("手机号登录");}void login(String vx){System.out.println("weixin登录");}}
三个方法名字相同，执行不同功能；
9.方法的重载：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {User12 user = new User12();}}
class User12{User12(){this("zhangsan");}User12(String name){this(name, "男");}User12(String name, String sex){System.out.println(name + "," + sex);}
}
当调用无参构造方法时，用this来调用自身的构造方法，并传入参数，再调再传，然后执行打印操作；
10.匹配方法时的精度扩大：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {byte b = 10;test(b);}static void test(byte b){System.out.println("bbb");}static void test(short s){System.out.println("sss");}static void test(char c){System.out.println("ccc");}static void rest(int i){System.out.println("iii");}
}
此时打印bbb没毛病，但当我去掉test（byte b）这个方法时，就会打印sss，这是因为byte类型扩大精度优先转换为容易转换的类型；
注意：byte类型无法和char类型转换，因为byte类型有负数，而char类型没有负数；
11.重载和多态的综合:
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {AAA aaa = new AAA();BBB bbb = new BBB();test(bbb);}static void test(AAA aaa){System.out.println("aaa");}}
class AAA{}
class BBB extends AAA{}
打印结果为aaa，因为当前test方法应该接受AAA类型，但传入BBB类型，就会发生类似于基本类型的精度提升，只不过这里是从子向父提升；
12.方法的重写：父类对象的方法其实主要体现通用性，无法在特殊的场合下使用；
如果子类对象需要在特殊场合使用，那么需要重写方法的逻辑，这个操作在java中称为方法的重写；（并不影响父类的方法，使用super类型还是可以访问）；
重写方法：子类的方法和父类的方法，方法名相同，返回值类型相同，参数列表要相同；
总结：（1）一个对象使用什么方法，取决于引用变量的类型；
（2）一个对象能使用什么属性，取决于引用变量的类型；
（3）一个对象的方法具体的使用是需要看具体的对象的；
（4）一个对象的属性具体的使用是不需要看具体的对象的，属性在哪里声明就在哪里使用；
例如：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {CCC ddd = new DDD();System.out.println(ddd.sum());}}
class CCC{int i = 10;int sum(){return i + 10;}
}
class DDD extends CCC{int i = 20;int sum(){return i + 20;}
}
ddd是CCC类型，所以应该看CCC中有没有sum方法，有，那么能使用，但具体的实现过程是依靠DDD中的sum方法，所以输出结果为40；
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {CCC ddd = new DDD();System.out.println(ddd.sum());}}
class CCC{int i = 10;int sum(){return i + 10;}
}
class DDD extends CCC{int i = 20;}
当把子类中的sum类型去掉后，方法具体的实现在子类中没有，那么去父类中寻找，父类的sum实现时，默认使用的是this属性，也就是父类中的属性，所以结果为20；
再看：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {CCC ddd = new DDD();System.out.println(ddd.sum());}}
class CCC {int i = 10;int geti() {return i;}int sum() {return geti() + 10;}}class DDD extends CCC {int i = 20;int geti() {return i;}}
这串代码中，首先运行sum，在子类中没办法实现，最终要落回父类，再执行geti方法，这个需要子类中的方法进行实现，所以最终打印30；
13.访问权限：
public:公共的，访问权限修饰符，java源码中，公共类只能有一个，而且必须和源码文件名相同；
（1）private：私有的，同一个类中可以使用；
（2）（default）：默认权限，不设定时默认设定，同类同包可用；
（3）protected：受保护的：同包，同类，子类可用；
（4）public：公共的，任意使用；
14.Java中不允许外部类使用private，protected修饰；
所谓外部类，就是在源码中直接声明的类；
所谓的内部类，就是类中声明的类；
注意：内部类就当成外部类的属性使用即可，因为内部类可以看做内部类的属性，所以需要构造外部类对象才可以使用；
例如：内部类的创建过程：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {OuterClass outer = new OuterClass();OuterClass.InnerClass innerClass = outer.new InnerClass();}}
class OuterClass{public class InnerClass{}
}
15.类的单一创建：单例模式：
由于类的创建过程复杂，如果在外部直接创建类的对象，可能会丢失一些结构，使对象使用出现问题；
还有就是类占用内存较大，我们尽可能少创建类的对象，所以我们可以把类的构建方法进行private修饰，那么就只能在类中构建了；同时再加上if语句做判断，那么就保证了一个类只会产生一个对象；
例如：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {User19 instance = User19.getInstance();}}
class User19{private static User19 user19 = null;private User19(){}public static User19 getInstance(){if(user19 == null){user19 = new User19();}return user19;}
}
在这串代码中，创建了一个user19作为属性，然后设计getinstance方法，实现了在类的内部创建对象；
其中，由于静态方法只能访问静态属性，非静态方法既可以访问静态也可以访问非静态属性，那么就需要给属性前加上static；
16.Java中提供了一种语法，可以在数据初始化后不被修改，使用关键字final；
final可以修饰变量；变量的值一旦初始化后无法修改。
例如：
import java.util.concurrent.Callable;public class java_3_24
{public static void main(String[] args) {final String name = "zhangsan";name = "lisi";}}
会发生报错；
（1）final可以修饰变量：变量的值一旦初始化后无法修改；
（2）final可以修饰属性：那么JvM无法自动进行初始化，需要自己进行初始化，属性值不能发生变化；
（3）final可以修饰方法，这个方法不能被子类重写；
（4）final可以修饰类，这样的类就没有子类了；
（5）final不可以修饰构造方法
（6）final可以修饰方法的参数，一旦修饰，参数就无法修改了；