-
static 静态的
-
所有static修饰的类都是类级别的。
-
所有static修饰的都是采用类名.方式访问。
-
static修饰的方法：静态方法
-
static修饰的变量：静态变量
-
变量分为：局部变量和成员变量
-
成员变量分为：实例变量和静态变量
class VarTest{ //需要对象的参与，可能出现空指针异常 int i; public void m2(){ } //以下不需要对象参与即可访问，没有空指针异常问题 static int k; public static void m1(){ } }//什么时候声明为实例，什么时候声明为静态 public class StaticTest{ public static void main(String[] args){ Chinese c1 = new Chinese("11","张三","中国"); Chinese c1 = new Chinese("11","李四中国"); } } class Chinese{ //身份证号 String idCard; //一个对象一份，每个人的身份证号不同 //姓名 String name; //一个对象一份，一个人一个姓名 //国籍 String country;//对于此类来说，不会随对象改变。是整个类的特征。 public Chinese{ } public Chinese(String s1,String s2,String s3){ idCard = s1; name = s2; country = s3; } }
image.png
image.png
//什么时候声明为实例，什么时候声明为静态
//如果这个类型的所有对象的某个属性都是一样的，不建议定义为实例变量，浪费内存空间，建议使用定义为static
public class StaticTest{
public static void main(String[] args){
Chinese c1 = new Chinese("11","张三");
Chinese c1 = new Chinese("11","李四");
}
}
class Chinese{
//身份证号
String idCard; //一个对象一份，每个人的身份证号不同
//姓名
String name; //一个对象一份，一个人一个姓名
//国籍
static String country = "中国";//对于此类来说，不会随对象改变。是整个类的特征。
//static默认值在类加载是初始化，不需要new对象，存储在方法区。
public Chinese{
}
public Chinese(String s1,String s2){
idCard = s1;
name = s2;
}
}
image.png
- static修饰的统一都是静态的，都是类相关的，不需要new对象，直接用类名.访问。
- 当一个属性是类级别的属性，所有对象的这个属性的值是一样的，建议定义为静态变量
public class StaticTest{
public static void main(String[] args){
StaticTest st = new StaticTest();
st = null;
st.doSome(); //这个会转换为StaticTest.doSome();
st.doOther(); //空指针异常。
}
//可以使用类名.访问，也可用对象.访问（不建议）
public static void doSome(){
System.out.println("doSome");
}
//通过对象.访问
public void doOther(){
System.out.println("doOther");
}
}
-
方法什么时候实例，什么时候静态。
-
此方法一般都是描述一个行为，如果需要对象触发则需要实例方法。
-
静态方法只能访问静态变量。
-
方法体中直接访问实例变量这个方法一定是实例方法。
-
如果工具类中方法大部分是静态方法。（静态方法是不需要new对象，工具类为了方便，所以一般都是static的。）
public class StaticTest{ public static void main(String[] args){ User.getId(); } } class User{ private int id; //实例变量，需要对象 private String name; //实例变量 public void printName(){ System.out.println(name); } public static void setId(int i){ id = i; //静态方法调用实例变量，错误 } public static int getId(){ return id;//静态方法调用实例变量，错误 } }
//使用static关键字可以定义：静态代码块
//什么事静态代码块：
static {
java语句;
}
//一个类中可以编写多个静态代码块。
//静态代码块在类加载时执行，并且只执行一次，在main之前执行，按照自上而下的顺序执行。
//静态代码块的作用：不常用；实际上是给Java程序员的一个特殊的时刻，一个时机：类加载时机。
//记录日志代码，类何时加载到JVM中？可以写到静态代码块中。
public class StaticTest{
public static void main(String[] args){
}
}
public class StaticTest{
//类加载时初始化
static int i = 100;
//类加载时执行
static{
System.out.println(i);
}
int k;
static {
System.out.println(k);//类加载时k还不存在，k在构造后才存在。
}
static {
System.out.println(name);//name在后面，执行时机相同，按顺序执行，name还不存在
}
static String name = "张三";
public static void main(String[] args){
}
}
-
静态区中存放静态变量+静态片段
-
方法执行过程需要压栈。
-
new出来的对象都在堆中。
-
Java程序要求有顺序的：
- 对于一个方法来说，自上而下
- 静态代码块和静态代码块有先后顺序。
- 静态代码块和静态变量有先后顺序。
-
实例代码块:实例语句块在构造方法之前执行，而且只有new一个对象就会在构造方法之前执行。实例代码块在类加载时并没有执行。
-
语法：{ java语句; }
public class InstanceCode{ public InstanceCode(){ System.out.println("无参"); new InstanceCode(); } { System.out.println("实例"); } public InstanceCode(String name){ System.out.println("有参"); } public static void main(String[] args){ System.out.println("main begin"); } } -
判断程序的执行顺序
publci class CodeOrder{ //静态代码块 static { System.out.println("a"); } //入口 public static void main(String[] args){ System.out.println("x"); new CodeOrder(); System.out.println("over"); } //构造函数 public CodeOrder(){ System.out.println("B"); } //实例语句块 { System.out.println("C"); } //静态代码块 static { System.out.println("X"); } } //a //X //x //C //B //over
-
this是一个关键字
-
this在内存方面怎样？
-
一个对象一个this，this是一个变量，是一个引用，this指向当前对象的内存地址。
-
从严格意义上讲，this代表的就是当前对象，this存储在堆内存当中对象的内部。
public class ThisTest{ public static void main(String[] args){ Customer c1 = new Customer("张三"); Customer c2 = new Customer("李四"); } } class Customer{ string name; public Customer(){ } public Customer(String s){ name = s; } public void shopping(){ System.out.println(name); } }
image.png
-
this只能使用在实例方法中，谁调用这个实例方法，this就是谁，所以this代表的是当前对象。
-
this大部分情况下可以省略。
-
public class ThisTest{ public static void main(String[] args){ Customer c1 = new Customer("张三"); c1.shopping(); Customer c2 = new Customer("李四"); c2.shopping(); } } class Customer{ string name; public Customer(){ } public Customer(String s){ name = s; } public void shopping(){ //这里的this是当前对象。 //c1调用shopping，this是c1，c2调用shopping，this是c2。 //this.省略的话，访问的还是当前对象的内容。 System.out.println(name); } public static void doSome(){ //this是代表当前对象，静态方法调用不需要对象。 System.out.println(this); } } class Student{ String name = "张三"; public static void m1(){ System.out.println(name); //错误 //this代表当前对象。 System.out.println(this.name);//error //以下两行可以 Student s = new Student(); System.out.println(s.name); } //如果方法中直接访问实例变量，该方法必须是实例方法。 //this用在当前对象，静态方法不能用于当前对象。 }public class ThisTest{ int i = 100; static int k = 100; public static void main(String[] args){ System.out.println(i); //无法从静态中访问。 //以下可以。 ThisTest t = new ThisTest(); System.out.println(i); System.out.println(k); //可以。 } }public class Date{ int year; int month; int day; } public class Man{ String idcard; String name; int age; static boolean sex = true; Woman w; }public class Woman{ String idcard; String name; int age; static boolean sex = false; Man m; }public class Account{ String actno; String password; double balance; }public class Wechat{ String no; String phone; String nickName; }public class Last{ public static void main(String[] args){ //创建丈夫（还没妻子） Husband h = new Husband("1111","张三","1999-10-19",null); //创建妻子（还没丈夫） Wife w = new Wife("2222","李四","1999-10-10",null); //结婚 h.w = w; w.h = h; System.out.println(h.name + "的妻子是" + h.w.name); System.out.println(w.name + "的妻子是" + w.h.name); } } class Husband{ String idCard; String name; String birth; Wife w; public Husband(){ } public Husband(String s1,String s2,String s3,Wife w){ idcard = s1; name = s2; birth = s3; w = w; } } class Wife{ String idCard; String name; String birth; Husband h; public Husband(){ } public Husband(String s1,String s2,String s3,Husband h){ idcard = s1; name = s2; birth = s3; h = h; } }public class Homework{ public static void main(String[] args){ Book b = new Book("高三数学人教版",20); b.detail(); //修改页数 b.setPageNum(100); b.detail(); Book b2 = new Book(); b.detail(); } } class Book{ private string title; private int pageNum; public Book(){ } public Book(String s,int i){ title = w; if(i < 200){ System.out.println("本书页数不能少于200页,默认赋值200"); pageNum = 200; return ; }else { pageNum = i; } } public void setTitle(String s){ title = s; } public String getTitle(){ return title; } public void setPageNum(int i){ if(i < 200){ System.out.println("本书页数不能少于200页,默认赋值200"); pageNum = 200; return ; } pageNum = i; } public int getPageNum(){ return pageNum; } public void detail(){ System.out.println("教程名称"+title,"总页数"+pageNum); } }
image.png
//this在构造方法中区分局部变量和实例变量。
public class ThisTest{
public static void main(String[] args){
Student s = new Student();
s.setNo(11);
s.setName("ag");
System.out.println(s.no);
System.out.println(s.name);
}
}
class Student{
//学号
private int no;
//姓名
private String name;
public Student(){
}
public Student(int no,String name){
this.no = no;
this.name = name;
}
public int getNo(){
return no;
}
public String getName(){
return name;
}
public void setNo(int no){
this.no = no; //this的作用区分局部变量和实例变量
}
public void setName(String name){
this.name = name;
}
}
//this除了使用在实例上，还可以使用在构造方法上。 //通过当前的构造方法调用另一个本类的构造方法，this(实际参数列表); //this()的作用：代码复用。构造方法1和构造方法2都是在同一个类中。 //this()只能出现在构造方法的第一行。 public class ThisTest{ public static void main(String[] args){ Date d = new Date(); d.detail(); Date d1 = new Date(2008,8,8); d1.detail(); } } class Date{ private int year; private int month; private int day; public Date(){ //year = 1970; //month = 1; //day = 1; this(1970,1,1);//与上三行一样。 } public Date(int year,int month,int day){ this.year = year; this.month = month; this.day = day; } public void setYear(int year){ this.year = year; } public int getYear(){ return this.year; } public void setMonth(int month){ this.month = month; } public int getMonth(){ return this.month; } public void setDay(int day){ this.day = day; } public int getDay(){ return this.day; } public void detail(){ System.out.println(this.year); System.out.println(this.month); System.out.println(this.day); } }
//面向对象思想程序：
public class Homewrok{
public static void main(String[] args){
Account a = new Account("111",2200,1.23);
Customer c = new Customer("Jamc",a);
c.getAct().deposit(100);
c.getAct().withdraw(960);
c.getAct().withdraw(2000);
}
}
class Account{
private String id;
private double balance;
private double annualInterestRate;
//
public Account(){
}
public Account(String id,double balance,double annualInteretRate){
this.id = id;
this.balance = balance;
this.annualInterestRate = annualInterestRate;
}
public String getId(){
return id;
}
public double getBalance(){
return balance;
}
public double getAnnualInterestRate(){
return annualInterestRate;
}
public void setId(String id){
this.id = id;
}
public void setBalance(String balance){
this.balance = balance;
}
public void setAnnualInterestRate(String annualInterestRate){
this.annualInterestRate = annualInterestRate;
}
public void deposit(double money){
//this.balance += money;
this.setBalance(this.getBalance() + money);
}
public void withdraw(double money){
if(money > this.getBalance()){
System.out.println("余额不足，取钱失败");
return;
}
//this.balance -= money;
this.setBalance(this.getBalance() - money);
}
}
class Customer{
private String name;
priavte Account act;
public Customer(){
}
public Customer(String name,Account act){
this.name = name;
this.act = act;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAct(Account act){
this.act = act;
}
public Account getAct(){
return act;
}
}
public class Homework{
public static void main(String[] args){
Student s1 = new Student();
}
}
class Student{
private String name;
private int age;
private String address;
private String zipoode;
private String mobile;
public Student(){
}
public Student(String name, int age, String address,String zipoode, String mobile){
this.name = name;
this.age = age;
this.address = address;
this.zipoode = zipoode;
this.mobile = mobile;
}
//get set
public setName(String name){
this.name = name;
}
public setAge(String age){
this.age = age;
}
public setAddress(String address){
this.address = address;
}
public setZipoode(String zipoode){
this.zipoode = zipoode;
}
public setMobile(String mobile){
this.mobile = mobile;
}
public void getName(){
return name;
}
public void getAge(){
return age;
}
public void getAddress(){
return address;
}
public void getZipoode(){
return zipoode;
}
public void getMobile(){
return mobile;
}
}
大总结
类体{
实例变量;
实例方法;
静态变量;
静态方法;
构造方法;
静态代码块;
实例代码块;
方法(){
int i = 100;
}
}
public class Review{
public static void main(String[] args){
int i = 100;
Student s = new Student();
s.study();
s.eat();
}
}
class Student{
static {
System.out.println("gdnzv");
}
private int no;
private String name;
static String job = "学习";
{
System.out.println("fff");
}
public Student(){
this(100,"张三");
}
public Student(int no,String name){
this.no = no;
this.name = name;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setNo(String no){
this.no = no;
}
public String getNo(){
return no;
}
public void study(){
System.out.println(this.name);
System.out.println(name);
System.out.println(getName());
System.out.println(this.getName());
//this.eat();
eat();
Student.m1(); //类名可以省略
m1();
}
pblic static void m1(){
System.out.println("1r32r"+job);//自动在job前添加类名。
}
public void eat(){
System.out.println();
}
}
public class Review{
int i;
static int j;
public void m1(){
}
public void m2(){
}
public void x(){
m1();//都可以。
m2();
m3();
m4();
T.t1();
T t = new T();
t.t2();
}
public static void m3(){
}
public static void m4(){
}
//main方法是静态的，JVM调用main方法的时候直接采用的是类名.的方法。没有this。
//m1()和m2()是实例方法，按照Java语法规则来说，实例方法必须new对象，再通过引用.的方式访问。
public static void main(String[] args){
m1();//错误
m2();//错误
m3(); //自动识别静态方法，自动Review.m3();
m4();
//i不能访问，j可以。
//调用实例变量或方法先new。
}
}
class T{
public static void t1(){
}
public void t2(){
}
}
- 只要负责调用的方法a和被调用的方法在同一个类中this. 可以省略 类. 可以省略
网友评论