1.什么是对象?
public class Cat { public int age; public String name; public char sex; public void run(int ag) { this.age=ag; } public static void main(String[] args) { Cat cat1=new Cat(); Cat cat2=new Cat(); Cat cat3=new Cat(); cat1.run(10); cat2.run(11); System.out.println(cat1.age); System.out.println(cat2.age); } }
我们调用cat1的run()方法和cat2的run()方法,执行run()方法,然后在去操作我们的变量进行值得更改,最后我们输出每一个cat1和cat2的age值,我们会发现输出并不一致,那么这就说明了我们在内存当中至少有两个age变量,分别属于cat1和cat2,那么我们也可以以此推出cat3当中有一个age变量。
那么我们在上边至少能说明在内存当中分别一块属于cat1、cat2、cat3管理的有着数据和方法所组成的内存空间。
上图我们可以得知这一块内存就是我们的对象
2.什么是类,什么是对象,类与对象的关系是什么?
类当中只有关于信息的定义而对象有这些信息的值
类是对象的模板,我们可以将类想象成制作小甜饼的切割机,将对象想象成小甜饼,由类构造对象的过程叫做类的实例化。
3. this
Java 中为解决变量的命名冲突和不确定性问题,引入关键字 this 代表其所在方法的当前对象的引用
this代表当前对象
1.this.属性名
一个方法当中的局部变量和成员变量名称相同,我们的程序需要在这个方法当中访问成员变量,这个时候就必须使用this关键字,用来区分成员变量和方法当中的参数。例如,我们set方法
private String name; public void setName(String name) { this.name = name; }
2.this.方法名
让类中的一个方法来访问类中的另一个方法或者实例变量
public void souPerson() { System.out.println("我是一个人。。。。"); } public void name() { this.souPerson(); } public static void main(String[] args) { Person person = new Person(); person.name(); }
static关键字是对类而言的,this关键字是指当前对象,因此staic修饰的方法中不能使用this
3.this()---this访问构造函数
this()可以用来访问本类的构造方法
public Person(String name,int age) { this.age = age; this.name = name; } public Person() { this("张三",10); }
注意:
①this()不能在普通方法中使用,只能在构造方法中使用
②this()在构造方法中使用必须是第一条语句
③在一个类下两个构造方法中不能通过this()相互调用
④不能与super()同时使用
4.static
static方便在没有创建对象的情况下来进行调用(方法/变量)。很显然,被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问。
public class Person { static String from; public static void Run() { System.out.println("run"); } public static void main(String[] args) { Person.from = "中国"; Person.Run(); } }
方便在没有创建对象的情况下来进行调用(方法/变量)
1、static内存使用
static关键字存储在我们的方法区当中的静态常量池当中,static修饰的方法、变量和代码块都是可以被用来共享的
public class Person { private int age ; private String name; static String from; public Person(int age, String name) { this.age = age; this.name = name; } @Override public String toString() { return "Person [age=" + age + ", name=" + name + ", from=" + from + "]"; } public static void main(String[] args) { Person person1 = new Person(20,"张三"); Person person2 = new Person(21,"李四"); Person.from = "中国"; System.out.println(person1.toString()); System.out.println(person2.toString()); } } /* Person [age=20, name=张三, from=中国] Person [age=21, name=李四, from=中国] */
person1和person2的name和age属性的值都在堆内存当中进行存储,且是该对象私有的,但是from属性扥值是存储在方法区的静态常量池当中的,是属于公共的。
2.static修饰符
static属于类
5.类的加载顺序
public class Test extends Base{ // 扫描(受检异常)-----》加载父类-----》子类-----》创建父类对象----》子类对象 // 子类调用父类的方法 static{ System.out.println("test static"); } public Test(){ System.out.println("test constructor"); } public static void main(String[] args) { new Test(); } } class Base{ static{ System.out.println("base static"); } public Base(){ System.out.println("base constructor"); } }
先来想一下这段代码具体的执行过程,在执行开始,先要寻找到main方法,因为main方法是程序的入口,但是在执行main方法之前,必须先加载Test类,而在加载Test类的时候发现Test类继承自Base类,因此会转去先加载Base类,在加载Base类的时候,发现有static块,便执行了static块。在Base类加载完成之后,便继续加载Test类,然后发现Test类中也有static块,便执行static块。在加载完所需的类之后,便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器,然后再调用自身的构造器。因此,便出现了上面的输出结果。
所有的静态的类的初始化都交给类的第一个对象去执行
public class Demo { public Demo(String aa){ System.out.println("===="+aa); } static { System.out.println("11"); } public static Demo demo = new Demo("+++"); static { System.out.println("22"); } } class Test{ public static void main(String[] args) { Demo demo = new Demo("----"); } }