2022Java学习笔记(初识Java_05)

最新推荐文章于 2024-07-09 16:46:46 发布

苡荏

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量151

点赞数 1

分类专栏： 2022Java学习专栏文章标签： java JAVA 语言开发语言

本文链接：https://blog.csdn.net/weixin_52117223/article/details/123963972

版权

2022Java学习专栏专栏收录该内容

6 篇文章 0 订阅

订阅专栏

2022Java05

1. 面向对象与面向过程

面向过程：当需要实现一个功能的时候具体每一步都要亲力亲为详细处理每一个细节
面向对象：当需要实现一个功能的时候不关心具体步骤只是找一个可以实现该功能的对象

示例

	//打印输出 [10,20,30,40,50]
	//面向过程：
   //打印[10,20,30,40,50]
      int[] array={10,20,30,40,50};
      System.out.print("[");
      for (int i = 0; i < array.length; i++) {
          if(i==array.length-1){
              System.out.println(array[i]+"]");
          } else {
              System.out.print(array[i]+",");
          }
      }
      System.out.println("================");
      //面向对象 打印[10,20,30,40,50]
      System.out.println(Arrays.toString(array));

2. 类

类的定义：
- 成员变量：
  String name;
  int age;
- 成员行为：
  public void eat(){}
  public void sleep(){}
成员变量直接定义在类中在方法外
成员方法不要写static关键字
通常情况下一个类不能直接使用需要根据类创建一个对象才能使用
- 1.导包：指出需要使用的类在什么位置
  import 包名称.类名称;
  import demos.democlass;
- 对于和当前类属于同一个包的情况可以省略包语句不写
- 2.创建格式：
  类名称对象名 = new 类名称();
  democlass stu = new democlass();
- 3.使用：
  使用成员变量：对象名.成员变量名
  使用成员方法：对象名.成员方法名(参数);

 		//导包
        //创建：类名称 对象名 = new 类名称();
        democlass stu = new democlass();
        //使用成员变量
        System.out.println(stu.name);// null
        System.out.println(stu.age);// 0

        System.out.println();
        //改变对象当中的成员变量内容
        //将右侧的字符串赋值交给stu对象当中的name成员变量
        stu.name="cow";
        stu.age=20;
        System.out.println(stu.name);
        System.out.println(stu.age);

		public class Phone {
		    public String brand;
		    public double price;
		    public String color;
		    //成员方法
		    public void call(String who) {
		        System.out.println("给" + who + "打电话");
		    }
		    public void sendMessage(){
		        System.out.println("群发短信");
		    }
		}

		import demodemos.Phone;//导入包
        Phone iphone = new Phone();
        iphone.call("1234567890");
        iphone.sendMessage();

        System.out.println(iphone.price);
        System.out.println(iphone.color);

        iphone.brand="iphone";
        iphone.price=4222;
        iphone.color="green";
        System.out.println(iphone.brand);
        System.out.println(iphone.price);
        System.out.println(iphone.color);

    //对象作为形参
    public static void method(Phone iphone){
        System.out.println(iphone);// 传址 demodemos.Phone@5b480cf9
        System.out.println(iphone.brand);
        System.out.println(iphone.price);
        System.out.println(iphone.color);
    }

    public static Phone getPhone(){
        Phone xiaomi = new Phone();
        xiaomi.brand="xiaomi";
        xiaomi.price=1999;
        xiaomi.color="Green";
        return xiaomi;
    }
    
	//使用对象类型作为方法返回值：
    Phone xiaomi = getPhone();
    System.out.println(xiaomi.brand);
    System.out.println(xiaomi.color);
    System.out.println(xiaomi.price);

3. 局部变量和成员变量

 1.定义位置不一样
 	局部变量：在方法的内部
 	成员变量：在方法的外部 直接写在类中
 2.作用范围不一样
 	局部变量：只有在方法当中才可以使用 除了方法就不能再用
 	成员变量:整个类全都可以通用
 3.默认值不一样：
 	局部变量：没有默认值 如果想要使用必须手动进行赋值
 	成员变量：如果没有赋值 会有默认值
 4.内存位置不一样：
 	局部变量：位于栈内存
 	成员变量：位于堆内存
 5.生命周期不一样：
 	局部变量：随着方法进栈而诞生 随着方法出栈而消失
 	成员变量：随着对象的创建而诞生 随着对象被垃圾回收而消失

public class Demo{
	String name;// 成员变量
	public void methodA(){
		int num=20;// 局部变量
		System.out.println(num);
		System.out.println(name);
	}
	public void methodB(int param){//方法的参数就是局部变量
		//参数在方法调用的时候 必然会被赋值
		System.out.println(param);
		int age;// 局部变量
		System.out.println(age);// 错误写法 没有赋值不能用
		System.out.println(num);// 错误写法 超出使用范围
		System.out.println(name);
	}	
}

4. 面向对象的三大特征

面向对象的三大特征：封装继承多态
封装性在Java的体现：
方法就是一种封装关键字private也是一种封装
封装就是将一些细节信息隐藏起来对于外界不可见

      public static  int getMax(int[] array){
          int max=array[0];
          for (int i = 0; i < array.length; i++) {
              if(array[i]>max){
                  max=array[i];
              }
          }
          return max;
      }
      
      int[] array={5,15,50,100};
      int max=getMax(array);
      System.out.println("最大值："+max);

private的作用及使用：
用private关键字来修饰需要保护的成员变量
- 一旦使用了private进行修饰那么本类当中仍然可以随意访问
  但是超出了本类范围之外就不能直接访问了
间接访问private成员变量就是定义一对Getter/Setter方法
对于boolean值 Getter方法一定要写成isXxx形式而setXxx规则不变

public class Person{
    String name;// 姓名
    private int age;// 年龄
    public void show(){
        System.out.println("My name is"+name+", I am "+age+" years old.");
    }

    //这个成员方法 专门用来向age设置数据 必须是setAge 必须有参数无返回值
    public void setAge(int num){
        if(num>0){
            age=num;
        } else{
            System.out.println("数据不合理");
        }
    }
    //这个成员方法 专门用来获取age的数据 必须是getAge 必须无参数有返回值
    public int getAge(){
        return age;
    }
}

public class coding{
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
        person.name="lix";
        //person.age=-20;
        //直接访问private的内容 错误写法
        person.setAge(20);//间接访问age赋值
        person.show();
        person.setAge(-20);//数据不合理
        person.show();
    }
}

练习：使用private定义学生类

public class Student{

    private String name;// 姓名
    private int age;// 年龄
    private  boolean male;// 性别

    public void setMale(boolean b){
        male=b;
    }
    public boolean isMale(){
        return male;
    }
    public void setName(String str){
        name=str;
    }
    public String getName(){
        return name;
    }
    public void setAge(int num){
        if(num>0){
            age=num;
        } else{
            System.out.println("数据不合理");
        }
    }
    public int getAge(){
        return age;
    }
}

Student stu = new Student();
stu.setName("myname");
set.setAge(20);
set.setMale(true);
System.out.println("姓名"+stu.getName());
System.out.println("年龄"+stu.getAge());
System.out.println("性别"+stu.isMale());

5. this方法介绍

当方法的局部变量和类成员变量重名的时候根据就近原则优先使用局部变量
如果需要访问本类的成员变量需要使用格式：this.成员变量名
通过谁调用的方法谁就是this

public class Person{
    String name;// 自己的名字
    //参数name是对方的名字 成员变量name是自己的名字
    public void sayHello(String name){
        System.out.println(name+",hello. I am "+this.name);
        System.out.println(this);//打印this地址
    }
}

public static void main(String[] args) {
    Person person = new Person();
    //设置自己的名字
    person.name="myname";
    person.sayHello("yourname");
    System.out.println(person);//地址值 这里和this的地址值相同
    //即 通过谁调用的方法 谁就是this
}

6. 构造方法

构造方法是专门用来创建对象的方法当我们通过关键字new来创建对象时其实就是在调用构造方法
格式：

public 类名称(参数类型 参数名称,...){
	方法体;
}

注意事项：

1.构造方法的名称必须和所在的类名称完全一样
2.构造方法不要写返回值类型 void不要写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法那么编译器会默认赠送一个构造方法没有参数方法体什么事情都不做-public Student(){}
5.一旦编写了至少一个构造方法那么编译器将不再赠送
6.构造方法也可以进行重载 - 重载：方法名称相同参数列表不同

public class Student{
    //成员变量
    private String name;
    private  int age;

    //无参数的构造方法
    public Student(){
        System.out.println("无参数的构造方法执行");
    }
    //全参数的构造方法
    public Student(String name,int age){
        System.out.println("全参数的构造方法执行");
        this.name=name;
        this.age=age;
    }

    //Getter Setter
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
}

public static void main(String[] args) {
    Student stu1 = new Student();// 无参构造
    System.out.println();
    Student stu2 = new Student("myname",20);// 全参构造
    System.out.println("姓名："+stu2.getName()+",年龄："+stu2.getAge());
    //如果需要改变对象中的成员变量的数据 仍需要使用setXxx的方法
    stu2.setAge(21);// 改变年龄
    System.out.println("姓名："+stu2.getName()+",年龄："+stu2.getAge());
}

7. 定义一个标准类

一个标准的类通常要拥有下面四个组成部分：
- 1.所有的成员变量都要使用private关键字修饰
- 2.为每一个成员变量编写一对儿Getter/Setter方法
- 3.编写一个无参数的构造方法
- 4.编写一个全参数的构造方法
快捷键 Alt+Insert

代码示例

public class Student{
    private String name;// 姓名
    private int age;// 年龄

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public static void main(String[] args) {
    Student stu1 = new Student();
    stu1.setName("myname");
    stu1.setAge(21);
    System.out.println("姓名："+stu1.getName()+",年龄："+stu1.getAge());
    System.out.println();
    Student stu2 = new Student("myname",18);
    System.out.println("姓名："+stu1.getName()+",年龄："+stu1.getAge());
    stu2.setAge(19);
    System.out.println("姓名："+stu1.getName()+",年龄："+stu1.getAge());
}