第五章 JAVA类的特性（自用）

最新推荐文章于 2024-01-03 22:01:01 发布

不更了

最新推荐文章于 2024-01-03 22:01:01 发布

阅读量484

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_41048982/article/details/108421896

版权

java基础专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1. 类的私有成员与公共成员

实验指导：类的私有成员只能被该类自身访问修改，而不能被任何其他类（包括该类的子类）来获取或引用，因此达到了对数据最高级别的保护。可以通过类的公共方法来访问类的私有成员，即公共get方法。

2. 类的构造方法重载与默认构造方法

实验目的: <1> 理解类的构造方法的作用

<2> 理解默认构造方法的执行过程

package java类的特性;

//构造方法重载
public class Student {
    String name;
    int age;
    public Student(){
        System.out.println("构造方法被调用");
    }
    public Student(String newName){
        name=newName;
        System.out.println("Student(String newName) 构造方法被调用");
    }
    public Student(String newName,int newAge){
        name=newName;
        System.out.println("Student(String newName,int newAge) 构造方法被调用");
    }
    public static void main(String[] args) {
        Student s1=new Student();
        Student s2=new Student("李四");
        Student s3=new Student("李四",25);
    }
}

"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA Community Edition 2020.2.1\lib\idea_rt.jar=50526:D:\IntelliJ IDEA Community Edition 2020.2.1\bin" -Dfile.encoding=UTF-8 -classpath F:\java\out\production\TestP java类的特性.Student
构造方法被调用
Student(String newName) 构造方法被调用
Student(String newName,int newAge) 构造方法被调用

Process finished with exit code 0

实验指导：

构造方法是一种特殊的方法,构造方法定义后,创建对象时就会自动调用它,因此构造方法不需要在程序中直接调用,而是在创建对象时自动执行。构造方法的名称必须与它所在的类的名称完全相同,构造方法没有返回值,但在定义构造方法时,构造方法名前不能用修饰符void来修饰,这是因为一个类的构造方法的返回值类型就是该类本身。

如果省略构造方法,Java会自动调用默认的构造方法(default constructor)默认的构造方法没有参数,在其方法体中也没有任何代码,即什么也不做。一旦用户为该类定义了构造方法,系统就不再提供默认的构造方法,这是Java的覆盖( overriding)所致。所以这时候要自行添加默认构造函数。

3. 在构造方法内调用另一个构造方法

实验目的： <1>:学习类的构造方法之间的调用

<2> 学习关键字this的使用

package java类的特性;
//this 关键字的使用
public class Emplore {
    private String name;
    private  int age;
    private  double salary;
    public Emplore(String newName,int newAge,double newSalary){
        this(newAge,newSalary);
        System.out.println("三 被调用");
        name=newName;
    }
    public Emplore(int newAge,double newSalary){
        this(newSalary);
        System.out.println("二 被调用");
        age=newAge;
    }
    public Emplore(double newSalary){
        this();
        System.out.println("一 被调用");
        salary=newSalary;
    }
    public Emplore(){
        System.out.println("无参函数被调用");
    }
    void setAge(int newAge){
        int age=0;
        this.age=newAge;// 确定是哪个对象的
//【代码4】设置age属性的值为age
    }
    int getAge(){
        return  age;
    }

    public static void main(String[] args) {
        Emplore s1= new Emplore("李四",30,8000);
        s1.setAge(31);
        System.out.println("年龄是"+s1.getAge());
    }

}

"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA Community Edition 2020.2.1\lib\idea_rt.jar=50664:D:\IntelliJ IDEA Community Edition 2020.2.1\bin" -Dfile.encoding=UTF-8 -classpath F:\java\out\production\TestP java类的特性.Emplore
无参函数被调用
一 被调用
二 被调用
三 被调用
年龄是31

Process finished with exit code 0

实验指导：

为了某些特定的运算,Java允许在类内从某一构造方法内调用另一个构造方法。利用这个方法,可减少程序代码,缩短程序开发时间。从某一构造方法内调用另一构造方法,是通过关键字this来调用的,this关键字必须写在构造方法内的第一行位置,否则会出现编译错误。
this关键字的另一用法是,如果在方法内局部变量与类的成员变量同名,这时直接通过变量名访问的是局部变量,例如程序模板中的 setAge方法中的代码4,如果输入的是 newAge;",则改变的是局部变量age的值,而不是Emplore类的属性age的值;如果需要改变类的属性age的值,必须通过关键词this来指定,这时,代码4中应该输入“this.age=newAge;”。

4. 方法的重载：

实验目的：<1>:理解类的方法重载的作用

<2> 掌握方法重载的关键点

public class FirstJava {
    private int value;
    private int count;
    public void setValue(int value) {
        this.value = value;
    }

    public int setValue(int value) {
        this.value = value;
        return value;
    }
    
    public void setValue(int value, int count) {
        this.value = value;
        this.count = count;
    }
}

实验指导：

上面典型错误：因为规则中没有通过方法的返回值来区分方法重载的，所以第二个setValue不能那样写。

方法的重载中的参数类性是关键，即参数个数不同，参数类型不同，或者参数顺序不同。

5. 类的静态成员

实验目的：<1> 掌握类的静态成员的定义

<2> 掌握静态成员和非静态成员的访问方式

public class Static {
	static int num = 4;
	String name;//成员变量
	static String country = "CN";//静态变量，类变量
	public   void show(){
		System.out.println(Static.country+":"+this.name);//静态成员省略的是类名，成员变量省略的是this
	}
	public static void print(){
		System.out.println(num);
	}
	
	public static void main(String[] args) {
		Static s = new Static();
		s.name = "小强";
		s.country = "ss";
		s.show();
		System.out.println(Static.country);
		print();
		
	}
}

6. 静态初始化器

<1> 构造方法是对每个新创建的对象进行初始化，而静态初始化器是对类自身进行初始化。

<2> 构造方法是在用new运算符创建新对象时由系统自动执行，而静态初始化器一般不能有程序调用，他是在所属的类被加载入内存时由系统调用执行的。

<3> 用new运算符创建多少个新对象，构造方法就会被调用多少次，但静态初始化器在类加载进入内存时只执行一次，与创建对象多少无关。

<4> 静态初始化器不是方法。

7. 引用变量作为方法的返回值

//filename：App7_12.java
class Person
{
  private String name;
  private int age;
  public Person(String name, int age) 
  {
    this.name=name;
    this.age=age;
  }
  public Person compare(Person p)
  {
    if (this.age>p.age)
      return this;
    else
      return p;
  }
}
public class App7_12
{
  public static void main(String[] args)
  {
    Person per1=new Person("张三",20);
    Person per2=new Person("李四",21); 
    Person per3;
    per3= per1.compare(per2);
    if(per3==per1)
      System.out.println("张三年龄大");
    else
      System.out.println("李四年龄大");
  }
}

"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA Community Edition 2020.2.1\lib\idea_rt.jar=64073:D:\IntelliJ IDEA Community Edition 2020.2.1\bin" -Dfile.encoding=UTF-8 -classpath F:\java\out\production\myideaTest App7_12
李四年龄大

Process finished with exit code 0

8. 类类型数组

//filename：App7_13.java
class Person
{
  private String name;
  private int age;
  public Person(String name, int age) 
  {
    this.name=name;
    this.age=age;
  }
  public void show()
  {
    System.out.println("姓名："+name+"  年龄："+age);
  }
}
public class App7_13
{
  public static void main(String[] args)
  {
    Person[] per;
    per=new Person[3];
    per[0]=new Person("张三",20);
    per[1]=new Person("李四",21);
    per[2]=new Person("王二",19);
    per[2].show(); 
    per[0].show();
  }
}

"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA Community Edition 2020.2.1\lib\idea_rt.jar=64287:D:\IntelliJ IDEA Community Edition 2020.2.1\bin" -Dfile.encoding=UTF-8 -classpath F:\java\out\production\myideaTest App7_13
姓名：王二  年龄：19
姓名：张三  年龄：20

Process finished with exit code 0

9. 以对象数组为参数进行方法调用

//filename：App7_14.java
class Person
{
  private String name;
  private int age;
  public Person(String name, int age) 
  {
    this.name=name;
    this.age=age;
  }
  public static int minAge(Person[] p)/2
  {
    int min=Integer.MAX_VALUE;
    for (int i=0;i<p.length;i++)
      if (p[i].age<min)
        min=p[i].age;
    return min;
  }
}
public class App7_14
{
  public static void main(String[] args)
  {
    Person[] per=new Person[3];
    per[0]=new Person("张三",20);
    per[1]=new Person("李四",21);
    per[2]=new Person("王二",19);
    System.out.println("最小的年龄为："+ Person. minAge(per));///1
  }
}

"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA Community Edition 2020.2.1\lib\idea_rt.jar=64527:D:\IntelliJ IDEA Community Edition 2020.2.1\bin" -Dfile.encoding=UTF-8 -classpath F:\java\out\production\myideaTest App7_14
最小的年龄为：19

Process finished with exit code 0

10. 对象的比较

//filename：App7_11.java
class Cylinder
{
  private static double pi=3.14;
  private double radius;
  private int height;
  public Cylinder(double r, int h) 
  {
    radius=r;
    height=h;
  }
  public void compare(Cylinder volu)
  {
    if (this==volu)
      System.out.println("这两个对象相等");
    else
      System.out.println("这两个对象不相等");
  }
}
public class App7_11
{
  public static void main(String[] args)
  {
    Cylinder volu1=new Cylinder(1.0,2);
    Cylinder volu2=new Cylinder(1.0,2); 
    Cylinder volu3= volu1;
    volu1.compare(volu2);
    volu1.compare(volu3);
  }
}

"C:\Program Files\Java\jdk-11.0.2\bin\java.exe" "-javaagent:D:\IntelliJ IDEA Community Edition 2020.2.1\lib\idea_rt.jar=63759:D:\IntelliJ IDEA Community Edition 2020.2.1\bin" -Dfile.encoding=UTF-8 -classpath F:\java\out\production\myideaTest App7_11
这两个对象不相等
这两个对象相等

Process finished with exit code 0

不更了

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
第五章 JAVA类的特性（自用）

目录：1. 类的私有成员与公共成员2. 类的构造方法重载与默认构造方法3. 在构造方法内调用另一个构造方法4. 方法的重载5. 类的静态成员类的私有成员与公共成员实验指导：类的私有成员只能被该类自身访问修改，而不能被任何其他类（包括该类的子类）来获取或引用，因此达到了对数据最高级别的保护。可以通过类的公共方法来访问类的私有成员，即公共get方法。类的构造方法重载与默认构造方法实验目的: <1>理解类的构造方法的作用 ...
复制链接

扫一扫