大家都知道C语言是面向过程的，其关注的是问题的过程，分析出求解问题的步骤，通过函数调用逐步解决问题。而Java是基于面向对象的，其关注的是对象，也就是完成一件事情中所涉及的主体，将一件事情拆分成不同的对象，通过逻辑将一个个功能实现连接起来。靠对象之间的相互交互来完成。
目录
1.1面向对象的概念
1.2类和类的实例化
1.2.1创建类
1.2.2类的实例化
2.类的成员
2.1字段/属性/成员变量
2.2 方法
2.3static关键字
2.3.1访问静态成员变量
2.3.2在静态方法中访问静态成员
2.3.2 小结内存布局：
3.封装
3.1private实现封装
3.2 getter和setter方法
4.构造方法
4.1基本语法
4.2 this关键字
4.2.1 this.fun( )
4.2.2 this( )
5.1代码块
5.2普通代码块
5.3静态代码块
6.匿名对象
总结：
1.1面向对象的概念
类就是一类对象的统称，对象就是这一类具体化的一个实例。
一个完整的类包括属性和方法，其中属性也叫字段和成员变量，方法也被称为成员方法。
1.2类和类的实例化 1.2.1创建类 类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类，并且在一个.Java文件中只能有一个public修饰的类。
比如：
//class+类名，类名采用大驼峰的写法（每个单词的首字母都是大写）
class Person{
//属性->也叫字段->也叫成员变量
//方法
}
class Person {
public int age;//成员属性 实例变量
public String name;
public String sex;
public void eat() { //成员方法
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
}
1.2.2类的实例化
（1）.用类类型创建对象的过程，称为类的实例化
（2）.类只是一个模型一样的东西，限定了类有哪些成员
（3）.一个类可以实例化出多个对象，但类只是一个模板，只有实例化出的对象 才占用实际的物理空间，存储类成员变量
在Java中我们用new关键字创建一个对象的实例，用.来访问对象中的属性和方法，在同一个类里面可以创建多个实例。
class Person {
public int age;//成员属性 实例变量
public String name;
public String sex;
//成员方法
public void eat() {
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
}
public class Hang{
public static void main(String[] args) {
Person person = new Person();//通过new实例化对象
person.eat();//成员方法调用需要通过对象的引用调用
person.sleep();
//一个类里面可以产生多个对象，产生对象 实例化对象
Person person2 = new Person();
Person person3 = new Person();
}
注意在使用对象.(person.+字段）来访问对象的字段的时候有三点要求：
（1）.对于各种数字类型, 默认值为 0.
（2）.对于 boolean 类型, 默认值为 false.
（3）.对于引用类型(String, Array, 以及自定制类), 默认值为 null
类的成员包括：字段、方法、代码块、内部类和接口
但下面我们先来重点学习前三个
平常在类中, 但是方法外部定义的变量. 这样的变量我们称为 "字段" 或 "属性" 或 "成员变量，
如果我们需要访问类中的字段，我们则需要先new实例出一个对象，然后才能对里面的成员进行访问，如果通过类实例出多个对象，则互相之间是独立的，改变一个对象的值，另一个不受影。
class Person {
public String name; // 字段
public int age;
}
2.2 方法
就是描述一个对象的行为
class Person {
public int age = 18;
public String name = "张三";
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
此时我们通过new一个对象来访问方法show,如果我们想成员变量的信息，可以这样：
Person person2 = new Person(); person2.name = "李四"; person2.age = 20; person2.show()2.3static关键字 2.3.1访问静态成员变量
代码1：
class Person{
public static int count;//static修饰静态成员变量
}
public class Hang {
public static void main(String[] args) {
System.out.println(Person.count);//静态成员变量的访问不用new对象，可以直接访问
}
2.3.2在静态方法中访问静态成员
class TestDemo{
public int a;
public static int count;
public static void change() {
count = 100;//可以在静态方法中修改静态成员变量的值
//a = 10; error 不可以访问非静态数据成员
}
}
public class Main{
public static void main(String[] args) {
TestDemo.change()；//无需创建实例对象 就可以调用
System.out.println(TestDemo.count);
}
}
总结：因此静态方法内部不能调用普通的方法，而且方法内部不能定义静态变量。
利用普通成员方法可以调用静态成员方法，但反之利用静态成员方法不能调用普通成员方法
代码2：
class Person{
public int a;
public static int count;//默认值是0
}
public class Hang{
public static void main(String[] args) {
Person t1 = new Person();
t1.a++;//++之后是1
Person.count++;//++之后是1
System.out.println(t1.a);
System.out.println(Person.count);
System.out.println("============");
Person t2 = new Person();
t2.a++;
Person.count++;//count再++，结果是2
System.out.println(t2.a);
System.out.println(Person.count);
}
}
接下来我们来看看原因：
方法区存储代码的片段、Person.class、class、.class和静态成员变量（不属于对象，属于类）
Java文件运行的过程：
接下来我们回顾3个知识点：
1.
Person person = null;//表示这个引用不指向任何的对象
2.
Person person = new Person; Person person2 = person; //表示person2这个引用指向person这个引用所指向的对象
3.一个引用不可以同时指向多个对象
4.引用一定是在栈上吗？
答案肯定不是
如图所示，testDemo这个引用在栈上，其指向的对象TestDemo在堆上，而其内部所创建的对象person也在堆上。
2.3.2 小结内存布局：class Person {
public int age;//实例变量 存放在对象内，默认值是0
public String name;//实例变量，默认值是null
public String sex;//实例变量,默认值是0
public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
public static final int COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更改
//因此一个对象存储在哪里和是否被final修饰没有关系
//实例成员函数
public void eat() {
int a = 10;//局部变量
System.out.println("eat()!");
}
//实例成员函数
public void sleep() {
System.out.println("sleep()!");
}
//静态成员函数
public static void staticTest(){
//不能访问非静态成员
//sex = "man"; error
System.out.println("StaticTest()");
}
}
public class Hang {
public static void main(String[] args) {
//产生对象 实例化对象
Person person = new Person();//person为对象的引用
System.out.println(person.age);//默认值为0
System.out.println(person.name);//默认值为null
//System.out.println(person.count);//会有警告!
//正确访问方式：
System.out.println(Person.count);
System.out.println(Person.count);
Person.staticTest();//总结：所有被static所修饰的方法或者属性，全部不依赖于对象
//访问实例成员函数
person.eat();
person.sleep();
}
}
3.封装
在我们写代码的时候，经常会遇到两种角色，即类的实现者和类的调用者，而封装的本质就是让我们类的调用者不用关注类是怎样实现的，只知道如何来调用类就可以
3.1private实现封装class Person {
public String name = "张三";
public int age = 18;
}
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
}
}
这个代码里面，假如有一天将实例变量name改为myname,则我们需要修改的工程量太大，此时我们就需要private来封装一个函数，在类的调用里面，我们只需要拿到类的实现里面的一个免费的接口就行，这样无论实例变量如何改变，我们只需要在接口里面改变即可，类的调用里面直接使用就行。比如：
class Person {
private String name = "张三";
private int age = 18;
//封装的接口
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
public class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
3.2 getter和setter方法
前面我们已经讲过如何建立一个接口，来更方便的调用类。因为被private修饰的函数或者字段只能在此类里面调用，在别的类里面不能调用。我们试想如果在类的调用里面想修改类的实现里面的实例变量，那应该怎么办呢？那我们就需要使用getter（获取这个成员的值）和setter（设置这个成员的值）
代码1：
class Person {
private String name;//实例成员变量
private int age;
public void setName(String name){
//name = name;//不能这样写
this.name = name;//this引用，表示调用该方法的对象
}
public String getName(){
return name;
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
public static void main(String[] args) {
Person person = new Person();
person.setName("caocao");
String name = person.getName();
System.out.println(name);
person.show();
}
可是如果修改的实例变量太多，我们不可能每次都去建立setter和getter方法，所以Java就有了下面的实现
4.构造方法 4.1基本语法构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化 *** 作。我们都知道调用普通成员方法需要new一个对象，那么过程是怎么样的呢？
1.为对象分配内存空间
2.调用对象的构造方法
语法规则：
1. 方法名称必须与类名称相同
2. 构造方法没有返回值类型声明
3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造
接下来，我们先来写一个构造方法：
class Person {
private String name;//实例成员变量
private int age;//实例成员变量
private String sex;//实例成员变量
public Person(){
System.out.println("Person()::不带参数的构造方法");
}
public class Hang{
public static void main(String[] args) {
Person person = new person;
//结果是打印不带参数的构造方法
那如果我们将构造的不带参数的构造方法屏蔽掉呢：
class Person {
private String name;//实例成员变量
private int age;//实例成员变量
private String sex;//实例成员变量
}
public class Hang{
public static void main(String[] args) {
Person p =new Person();
}
因此就算我们屏蔽掉，结果还是没有报错，就是因为如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数。如果定义了构造方法，则默认的无参构造将不再生成。
下面我们来写带有多个参数的构造函数：
class Person {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
this.name = "caocao";
this.age = 10;
this.sex = "男";
}
//带有3个参数的构造函数
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main{
public static void main(String[] args) {
Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
p1.show();//因为字段都是被封装的，所以只能使用接口
Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
p2.show();
}
}
4.2 this关键字
this.data 调用当前的对象 ，即属性/字段/成员变量
this.fun( ) 调用当前的对象的方法
this( ) 调用当前对象的其他构造方法（存放在构造函数中）
4.2.1 this.fun( )class Person{
private String name;
public void eat(){
System.out.println(name+"正在吃饭");
}
public void print(){
this.eat();//调用当前对象的eat方法，但静态方法中不能使用this,否则会报错
System.out.println("姓名："+name);
}
}
4.2.2 this( )
class Person{
private String name;
public Person(){
this("张三");//在没有构造对象之前，不能先使用this( )
System.out.println("不带参数的构造方法");
}
public Person(String name){
System.out.println("带有一个参数的构造方法");
}
}
public class Hang{
public static void main(String[] args) {
Person person = new Person();//此刻通过new对象，来调用无参数的构造方法，先执行第一条语
//句，this("张三“），此刻再调用
//调用带有一个参数的构造方法，完成之后，再调用不带参数的
//构造方法,但此刻this()必须放在第一句的位置
}
}
5.1代码块
使用{ }定义的一段代码就是代码块
还可分为四种：本地代码块
构造块
静态块
同步代码块
但下面我们先学普通代码块和静态块
5.2普通代码块class Person{
private String name;
{
System.out.println("实例代码块");
}
static{
System.out.println("静态代码块")
}
其结果是先输出静态代码块，再输出实例代码块。
5.3静态代码块使用static定义的代码块。一般用于初始化静态成员属性
class Person{
private String name;
public static int count = 4;
{
this.name="张三";
System.out.println("实例代码块");
}
static {
count = 8;//static修饰的静态代码块不能使用this,因为因为这是属于类的，不属于对象
System.out.println("静态代码块");
}
}
public class Hang{
public static void main(String[] args) {
System.out.println(Person.count);
}
}
说明静态代码块不用实例化就可以被执行
还有两种情况可以反应静态代码块的执行过程：
代码一：
class Person{
private String name;
static {
count=8;
System.out.println("静态代码块");
}
public static int count =10;//如果此时count已经赋值，那么运行时就遵循静态变量
}
public class Hang{
public static void main(String[] args) {
System.out.println(Person.count);
}
}
代码二：
class Person{
private String name;
static {
count=8;
System.out.println("静态代码块");
}
public static int count ;//如果此时count没有赋值，则运行代码，count取静态方法中的count
}
public class Hang{
public static void main(String[] args) {
System.out.println(Person.count);
Person p1 = new Person();
Person p2 = new Person();
}
}
//静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的，因此p2不会运行
6.匿名对象
（1）匿名只是表示没有名字的对象.
（2）没有引用的对象称为匿名对象.
（3）匿名对象只能在创建对象时使用.
（4）如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象
一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为 类 属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
this关键字代表的是当前对象的引用。并不是当前对象。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）