面向对象进阶

鑫儿...

已于 2022-02-24 16:26:22 修改

阅读量258

点赞数

分类专栏： Java基础信息文章标签： java 开发语言后端

于 2022-02-23 21:48:30 首次发布

本文链接：https://blog.csdn.net/weixin_55392255/article/details/123088024

版权

Java基础信息专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1、封装
封装的意义：保护或防止代码（数据）被我们无意中破坏了，
为避免逻辑错误，建议对所有属性进行封装，
并为其提供 getter、setter 进行设置和取得操作

get 、 set 的封装列子
public class demo10 {
public static void main(String[] args) {
person10 p = new person10();
p.name = “张三”;
p.setAge(99);
p.say();

}
class person10{
private int age ;
String name;

void setAge(int age2){
    if ( age2<10 || age2>150){
        System.out.println("年龄不合理，自动设置为1");
        age = 1;
    }else {
        age = age2;
    }
}

 int getAge() {
    return age;
}
void say(){
    System.out.println("自我介绍：姓名："+name+",年龄："+age);
}

}

2、this 关键字指的是当前对象

         ①②③④⑤⑥⑦⑧⑨⑩
         ①  调用类中的属性
         ②  调用类中的方法 和 构造方法
         ③  在一个构造方法中调用另一个构造方法时 
               调用的代码  必须写在构造方法的第一行
               原因：this 关键字调用的对象时在堆内存创建对象时（ 即对象在堆内存初始化 ）还没有完毕，
                         要等待对象在堆内存初始化完毕，然后再执行其他的逻辑，否则会报错

// 构造器是用于参数传入传出的，其实就是一个构造方法，
要传参数的话就肯定要有构造器

public class thisKeyword {

public static void main(String[] args) {
    person11 p1 = new person11("张三",18);
    person11 p2 = new person11("李四" ,18);
    p1.say();
    p2.say();

    person11  p3 = new person11();
    p3.say();

}

}
class person11{
private String name;
private int age;

public person11() {    //无参构造器，与有参构造器可以相互调用
    this("默认的年龄",1);  // 这里调用有参构造器
    System.out.println("这里逻辑的执行要在  “ this(\"默认的年龄\",1);”   这句话的下面，"+ "\n"+
            "因为构造器还没初始化设置完毕");
}

public person11(String name, int age) {   // 有参构造器，与无参构造器可以相互调用
    this.name = name;
    this.age = age;
}
void  say(){
    System.out.println("自我介绍：姓名："+this.name+",年龄："+this.age);
}

}
3、静态 static
静态的属性存放在方法区中的内存地址
类加载之后其内存就是加载在方法区中
静态的属性（加了 static 的属性）之后的属性直接用类名加点访问就可以了
一个类里面对象可以有很多个，但一个大类只能有一个
静态修饰的方法，被调用时，有可能对象还未创建
对象已经创建，说明类已经加载，又说明方法已经被调用
public class staticClass {

public static void main(String[] args) {

    emp e1 = new emp("张三","北京");
    emp e2 = new emp("李四","北京");
    emp e3 = new emp("王五","北京");
    emp e4 = new emp("赵六","北京");
    // 地址迁移到天津
    /*e1.setRegion("天津");
    e2.setRegion("天津");
    e3.setRegion("天津");
    e4.setRegion("天津");*/

    emp.region = "天津";  // 属性加了静态后，直接用类名调用静态属性就可以了

    e1.say();
    e2.say();
    e3.say();
    e4.say();

}

}

class emp{
private String name;
static String region;

// 有了有参、无参的构造器，就随便你传入传出单参数、双参数，都可以了
public emp(String name, String region) {  // 构造器是用于参数传入传出的，其实就是一个构造方法
    this.name = name;
    this.region = region;
}

public emp() {  // 构造器是用于参数传入传出的，其实就是一个构造方法
}

public String getName() {
    return name;
}

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

public String getRegion() {
    return region;
}

public void setRegion(String region) {
    this.region = region;
}
void say(){
    System.out.println("姓名："+name+",员工所在地："+region);
}

}

静态方法和非静态方法的调用区别

public class staticClass2 {
public static void main(String[] args) {

    static1.say();
    /*static1.say2();*/   //  非静态方法调用时不能直接用  类名加点  的方法调用

    static1 s = new static1();
    s.say2();
}

}

     //静态修饰的方法，被调用时，有可能对象还未创建

class static1{
static void say(){
System.out.println(“锄禾日当午”);

}

void say2(){
    System.out.println("从这里开始是非静态调用：\n 汗滴禾下土");
    say();  // 非静态方法可以调用静态方法，静态方法不能调用非静态方法，
            // 因为静态方法比非静态非法执行快很多，很多时候类加载时，非静态方法还没有创建对象呢！
}

}

static 静态，用于修饰成员变量、成员方法、代码块、内部类
static 主要作用在与创建独立与具体对象的域变量或者方法（被static 关键字修饰的
方法或者变量不需要依赖对象进行访问，只要类被加载了，就可以通过类名
去进行访问。并且不会因为对象的多次创建而在内存中建立多份数据）
static静态重点：
①静态成员在类加载时加载并初始化
②无论一个类存在多少对象，静态的属性，永远在内存中只有一份（可以理解为所有对象公用）
③在访问时：静态不可以访问非静态，非静态可以访问静态
// 静态方法不能调用非静态方法，非静态方法可以调用静态方法，
// 因为静态方法比非静态非法执行快很多，
// 很多时候类加载时，非静态方法还没有创建对象呢！

4、包
代码中写类的全名称时不用导包
如： Java . util . Scanner input = new Java . util . Scanner ( System . in ) ;

   String  这个代码不用导包  Java . lang   包里面，这个包里很多都是常用的代码

5、权限修饰符： public protected default private
default 是默认修饰符，什么都不写也是默认修饰符的意思
只有是 public 修饰的包才可以访问
private 是封装到了极致，只在一个类里进行封装成员属性、成员变量、成员方法等

6、普通代码块就是顺序执行的代码块
构造代码块：在类中编写的代码块成员，如 { } ，后面不用加分号

  构造代码块，随着对象的每次创建，执行一次，
  并执行在构造器（构造方法）之前，而构造器不一定执行，
  因为构造器可能有重载，可能有一参的、两参的、多参的、无参的，
  当构造器的其他参数没有执行是，构造器就不会被调用，即不会被执行

 构造代码块无论通过什么构造方法创建对象，构造代码块都会执行，也可以写多个构造代码块

构造代码块区别于构造方的是 ： 无论用户调用哪一个构造方法来创建对象，构造代码块都必然执行

静态代码块就是在构造代码块前加上 static ，如 static { } ，后面不用加分号

静态代码块，随着类的加载（第一次使用），静态代码块执行，
因为类只加载一次，所以静态代码块只执行一次

代码块的执行顺序：静态代码块 > 构造代码块 > 构造方法

7、main方法是 JVM （ Java Virtual Machine ）执行程序的入口
main方法中 String [ ] args 是字符串数组，接收参数用的
在这里插入图片描述