java语言入门（三）类与对象（1）

谁借莪１个温暖的怀抱￠ 2022-05-27 11:21 141阅读 0赞

### 1.0 类的定义 ###

类的定义的语法格式是：

[修饰词]  class 类名 [extends 父类名字] [implments 接口名] { 
            [修饰符] 数据类型   变量名;//这是成员属性定义
            [修饰符] 返回值类型   函数名(参数列表)[throws 异常列表]{
                方法体
        };
    
    }
    
    public class Cat{ 
        private int a;
        public void setA(int args){
        this.a = args;
        }
    
    }

注意：

1.  \[ \] 里的是可有可无的
2.  修饰符包括访问控制修饰符（public private protected）和类型修饰符 例如 abstract final
3.  类名为标识符 通常首字母大写
4.  剩下的关键字分别是继承和实现接口
5.  多个修饰符修饰的时候 可以用空格分隔 与顺序无关

### 2.0 对象的创建于引用 ###

#### 2.1 创建对象及访问对象成员 ####

创建对象： 定义java类后 可以用 new + 构造方法来创建对象，并且将创建的对象赋给某个引用变量
    eg:
    Cat a = new Cat();
    new cat()  叫做创建对象  也叫实例化
    Cat a;中的a 就是引用变量

下面在讲 访问对象成员的时候我们先知道几个知识点

<table> 
 <thead> 
  <tr> 
   <th>作用域</th> 
   <th>当前类</th> 
   <th>子类</th> 
   <th>同一个包的其他类</th> 
   <th>不同包的其他类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public （公共的）</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>不写（默认的）</td> 
   <td>√</td> 
   <td></td> 
   <td>√</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>protected（受保护的）</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>private（私有的）</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

说明：
    在Java语言中访问控制权限就有以上4中   画对号代表可以访问
    在实际使用时，类声明的访问控制符只有2个：public和无访问控制符，
    属性声明、构造方法声明和方法声明的访问控制符可以是以上4种中的任何一个。

那么我们如何访问时对象成员呢？

package a;
    
    public class Hello {
            private int a = 5;
    
            public int getA() {
                return a;
            }
    
            public void setA(int a) {
                this.a = a;
            }
    
            public static void main(String[] args) {
                Hello m = new Hello();
                System.out.println(m.a);
    
                m.setA(10);
                System.out.println(m.a);
                System.out.println(m.getA());
            }
    }
    
    
    结果：
    5
    10
    10

由此可见 我们访问这个类的属性或者方法的时候分为以下几步

1.  创建相应类的对象并且赋给他的引用 Hello m = new Hello();
2.  引用.属性或者方法  
    
    
    1.  m.a
    2.  m.setA(10);
    3.  m.getA()

问题来了 我们可以用m.a 获取a的值 也可以用m.getA()获取，有什么区别呢？

a的修饰符是private 只能在本类访问 getA()修饰符是public 可以在任何地方使用  
这样我们修改a就不会影响其他程序的使用了

> 类中的属性一般用private修饰 方法用public 也可以不这么用

注意：  
java对象和引用变量是两个不同的东西， new Hello()是对象  
Hello m = new Hello(); 等号前面是引用

--------------------

#### 2.2 对象的初始化和构造方法 ####

对象的初始化有下面三种方法  
1.0 定义属性成员时，指定初值

public class Hello {
            private int a = 5;
    }

2.0 在初始化块中设置

public class Hello {
            private int a;
    
            {
                a = 5;
            }

3.0 在构造方法中设置

public class Hello {
            private int a;
            //无参构造函数 如果不写 并且没有其他构造函数 则系统会自动提供
            // 若已经有了其他有参数的构造函数 则系统不再提供
            public Hello(){
    
            }
            //下面这个是构造函数
            public Hello(int b){
                a =b;
            }
            //主方法
            public static void main(String[] args) {
                //动态的赋初值 这时候a的初值是123 系统调用的是
                //Hello(int b)这个构造函数
                Hello m = new Hello(123);
                //下面这个系统调用的是Hello(){}这个构造函数，.
                //这就是重载 体现了多态性
                Hello q = new Hello();
    
                //注意上面的两个对象的操作不会互相影响 也就是 m.a = 3
                //但是q.a 不是3 他俩互不影响
                /* 可以这么理解 人类是类 我和你是两个人类的两个对象 我是m 你是q 我的身高m.a = 170;你的身高q.a = 10 这是不影响的 */
                }
        }

> 构造函数的名称必须与类名相同，没有返回值 就是为了初始化用的  
> 一个类可以用有多个构造方法，系统根据需要自己调用相应的构造方法

new Hello()的时候 赋值顺序是  
1 定义属性成员时，指定初值  
2 在初始化块中设置  
3 在构造方法中设置

package interfaceimp;
    
    public class Say {
        Say(){
            System.out.println("Say 这个类正在进行初始化 这个构造函数在北执行");
        }
    
        void s(){
            System.out.println("啥啊");
        }
    }

package interfaceimp;
    
    public class Test {
        protected People people = null;
        protected Say say = new Say();
        public Test()
        {
            System.out.println("test 的构造函数正在执行");
        }
        void say(){
    // people.say();
    
        }
        public static void main(String[] args) {
            Test test  = new Test();
            test.say();
        }
    
    }

结果  
![这里写图片描述][70]

可以看出来 类在实例化的时候 是先给属性值初始化 最后才是构造函数

### 3.0 变量的作用域 ###

1.  成员变量 范围整个类 系统会自动赋默认初值 引用的赋为null
2.  局部变量 方法内的变量在方法里有效，循环中定义的变量在循环内有效
3.  方法参数 方法内有效
4.  异常处理参数

try{
    
    }catch(Exception a){
        a就在这个大括号里有效
    }

### 4.0 类变量和静态方法 ###

类变量就是用static修饰的变量  
静态方法就是用static修饰的方法

public class Hello {
            //下面这个是静态变量 也叫类变量
             static int a = 5;
            public static void main(String[] args) {
                //访问类变量的三种方法
                //1.0 本类中直接访问
                System.out.println(a);//结果是5
                //2.0 通过类名访问 在其他类中使用 使用范围同修饰符有关
                //遵循 public private 等的作用域
                //这里是默认的作用域 本类和本包中可以直接类名+变量使用
                Hello.a
                //3.0对象引用 同其他普通变量一样
                Hello m = new Hello();
                m.a;
            }
    }

静态变量属于类空间不属于对象空间  
看下面的例子

package a;
    
    public class Hello {
            public  static int a = 5;
            public Hello(int aa){
                a =aa;
            }
    
    
            public static void main(String[] args) {
                Hello m = new Hello(123);
                System.out.println(m.a);
                Hello ma = new Hello(127897983);
    
                System.out.println(ma.a);
                System.out.println(m.a);
            }
    }
    
    
    结果
    123
    127897983
    127897983

也就是不同对象拥有通一个静态变量

除了上述赋值方法外还可以通过静态代码块赋初值

public  static int a ;
    static{
        a = 5;
    }

静态方法在访问本类的成员时，只允许访问静态成员  
其他同静态成员

### 5.0 理解this ###

this出现在类的实例方法或者构造方法 实例方法就是不是静态方法  
代表就是这个类 你可以翻译为 我所在类的

package a;
    
    public class Hello {
            private  int a = 5;
            public Hello(int a){
                this.a =a;
            }
    
            public String toString(){
                return this.a+" = a";
            }
    
            public static void main(String[] args) {
                Hello hello = new Hello(10);
    
                System.out.println(hello.toString());
            }
    }

或者说用this就是指向本类的成员变量

### 6.0 使用包组织类 ###

这个不多说了 自己建立包 然后在包下建立类 包用来划分不同的功能

#### 6.1 java api ####

我们除了学习java基础外,还要对java的类库的内容体系有一定的了解  
java 一般分为java.\* javax.\* org.\* 三个包 分为别可以叫做核心包 扩展包 组织扩展包

> 欢迎评论交流 一些东西因为懒 就不写了 不懂的欢迎评论交流 我会尽量解答

[70]: /images/20220527/cfb956e207fb4aa1bed54b7a45410118.png