类和对象要点归纳

最新推荐文章于 2022-10-12 00:03:34 发布

wave_xiong

最新推荐文章于 2022-10-12 00:03:34 发布

阅读量413

点赞数 2

分类专栏： java 文章标签： java 类和对象

本文链接：https://blog.youkuaiyun.com/wave_xiong/article/details/102670979

版权

java 专栏收录该内容

5 篇文章

订阅专栏

什么是类？什么是对象？
类就是一个模板，对象就是这个模板产生出的实例。比如说类是一张图纸，根据这个图纸可以造出不同的房子（对象）
Java是面向对象的语言
oop（面向对象）语言的三大特征：
1.封装性：用private修饰成员属性，可以使该成员属性仅在此类中有权访问；
2.继承性：java中可以使用继承（extends）这种操作，来提高代码重用性；
3.多态性：基类引用派生类对象，并且基类和派生类有同名的覆盖
面向过程和面向对象的比较
面向过程（C）：
程注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象（java，c++）：
注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。

举例:
面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来
面向对象：打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

java(面向对象)编程开发思路

1.找对象，
2.创建对象
3.使用以及扩展对象
成员方法的调用要通过实例化对象的引用来调用。
一个类可以实例化多个对象
当属性值未初始化时，值为对应类型的0值(如布尔为flase)

class Person {
//属性 
    public String name; 实例变量
    public int age;
    boolean flg;
    public  static int count;
    public final  int SIZE =  666;//实例变量
    public static final  int SIZE2 =  666;
    
    //功能
    public  void fun() {
        count++;
    }

    public static void fun2() {
        System.out.println("count:"+count);
        //System.out.println("name:"+name);
        //eat();
    }
    public  void  eat() {
        System.out.println(name+" "+age+"吃饭！");
    }
    public void sleep() {
        System.out.println("睡觉!");
    }
}

然后在主函数中实例化对象并进行相应操作

public class Main{    
public static void main(String[] args) {        
Person person = new Person();//通过new实例化对象        
person.eat();//成员方法调用需要通过对象的引用调用        
person.sleep();       
 //产生对象     
 实例化对象        
 Person person2 = new Person();        
 Person person3 = new Person(); 
    }
 }

静态成员（static修饰）不属于对象，不依赖与对象，无法通过对象的引用来调用，但可以通过类名来调用，类中static修饰的函数（静态成员方法）无法访问成员实例变量，因为它不属于对象。

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);   
       } 
 }

为什么main函数是（static）静态的？
如果没有static，main函数就是一个普通的成员方法，想要运行就必须new一个对象对main函数进行引用，这样主函数就没有入口无法运行。
封装将成员属性定义为私有（private），只能通过类内部进行直接访问

class Person { 
 private String name = "张三";    
 private int age = 18;         
 public void show() {         
   System.out.println("我叫" + name + ", 今年" + age + "岁");   
    }
 } 
 
class Test {    
 public static void main(String[] args) {        
 Person person = new Person();       
 person.show();  
    } 
    } 
 
// 执行结果 我叫张三, 今年18岁

除此之外，还可以在类内通过getter和setter函数间接访问和初始化属性值

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

实例化一个对象步骤：
1.为对象分配内存（new）
2.调用合适的构造函数（如果没写，会自己生成不带参数的一个构造函数）

在这里插入图片描述
构造方法：是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.
1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
构造函数可以重载（改变函数参数的个数及其类型）

this 代表当前对象的引用（并不是指当前对象）（地址）因为
实例化一个对象分为两步：
1.为对象分配内存（new）
2.调用合适的构造函数（如果没写，会自己生成不带参数的一个构造函数）
编程中要习惯使用this
（当一个构造函数内用this调用另一个构造函数时，那一句只能放在第一句）
实例代码块一般用于初始化实例成员变量。
静态代码块一般用于初始化静态成员属性
实例代码块先于构造函数执行，静态代码块（只会执行一次）优先于实例代码块执行
静态>–实例>–构造函数
匿名对象
匿名只是表示没有名字的对象. 没有引用的对象称为匿名对象. 匿名对象只能在创建对象时使用. 如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.

class Person {   
   private String name;   
   private int age;     
   public Person(String name,int age) {      
   this.age = age;       
   this.name = name;   
     }    
     
      public void show() {        
       System.out.println("name:"+name+" " + "age:"+age);  
          }
          
      } 
      
public class Main { 
public static void main(String[] args) {   
 new Person("张三",18).show();//通过匿名对象调用方法   
   } 
} 
// 执行结果 name：张三：18