摘要：如果我们给出了构造方法，系统将不再提供默认的无参构造方法。概念方便在没有创建对象的情况下来进行调用方法变量。因为它的成员全部是静态的所以私有了构造方法获取随机数的方法返回带正号的值，该值大于等于
1.构造方法Constructor概述和格式(掌握)
A:构造方法概述和作用
给对象的数据(属性)进行初始化
B:构造方法格式特点
a:方法名与类名相同(大小写也要与类名一致)
b:没有返回值类型，连void都没有
c:没有具体的返回值return;
public class JavaObject { //创建对象JavaObject
public static void main(String [] args) {
Person p = new Person(); //在一创建对象的时候，系统就帮我们调用了构造方法
//p.Person(); //构造方法不能用对象调用
p.show();
Person p = new Person(); //再次创建对象
p.show();
}
}
class Person {
private String name; //成员变量都私有
private int age;
//构造方法
public Person() {
//System.out.println("hello");
//return; //构造方法也是有return语句的；
name = "张三";
age = 23;
}
public void show() {
System.out.println(name + "..." + age);
}
}
2.构造方法的重载及注意事项(掌握)
A:案例演示
构造方法的重载
重载:在同一类中,方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
有参构造的好处:可以动态的给属性赋值
B:构造方法注意事项
a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己手动给出，应自己给出无参构造方法。
public class JavaObject { //创建对象
public static void main(String [] args) {
Person p1 = new Person();
p1.show();
System.out.println("-------------------");
Person p2 = new Person("张三",23);
p2.show();
System.out.println("-------------------");
Person p3 = new Person("李四",24); //初始化，并动态的赋值
p3.show();
}
}
class Person {
private String name;
private int age;
public Person() {
System.out.println("空参的构造");
}
public Person(String name,int age) {
this.name = name;
this.age = age;
System.out.println("有参的构造");
}
public void show() {
System.out.println(name + "..." + age);
}
}
3.给成员变量赋值的两种方式的区别
A：setXxx()方法—— 修改属性值(开发中用的多一些,因为灵活)
B：构造方法—— 给对象中属性进行初始化。
public class JavaObject { //创建对象phone
public static void main(String [] args) {
Person p1 = new Person("张三",23);
p1 = new Person("李天一",25); //将元对象变成了垃圾
System.out.println(p1.getName() + "..." + p1.getAge());
System.out.println("-------------------");
Person p2 = new Person(); //空参构造创建对象
p2.setName("李四");
p2.setAge(24);
p2.setName("李鬼")；
System.out.println(p2.getName() + "..." + p2.getAge());
}
}
class Person {
private String name;
private int age;
public Person() { //空参构造
}
public Person(String name,int age) { //有参构造
this.name = name;
this.age = age;
}
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;
}
}
4.学生类的代码及测试(掌握)
A:案例演示 学生类：
成员变量：name，age
构造方法：无参，带两个参
成员方法： getXxx()/setXxx() java bean类(实体类) show()：输出该类的所有成员变量值
B:给成员变量赋值：
a:setXxx()方法
b:构造方法
C:输出成员变量值的方式：
a:通过getXxx()分别获取然后拼接
b:通过调用show()方法搞定
c:两者区别:
getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作
show()只是为了显示属性值
class Student {
private String name;
private int age;
public Student() { //空参构造
}
public Student(String name,int age) { //有参构造
this.name = name;
this.age = age;
}
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 void show() {
System.out.println("我的姓名是" + name + "我的年龄是" + age);
}
}
public class JavaObject {
public static void main(String [] args) {
Student s1 = new Student(); //空参构造创建对象
s1.setName("李四"); //设置姓名
s1.setAge(24); //设置年龄
System.out.println("我的姓名是" + s1.getName() + "..." + "我的年龄是" + s1.getAge());
System.out.println("-------------------");
//getXxx()获取属性值，可以打印，也可以赋值给其他的变量，做其他的操作
Student s2 = new Student("张三",23); //使用有参构造
s2.show(); //只是为了显示属性值
}
}
5.手机类案例(掌握)
成员变量：品牌brand，价格price
构造方法：无参有参
成员发法：setXxxh和getXxx、show
class Phone {
private String brand;
private int price;
public Phone() { //空参构造
}
public Phone(String brand,int price) { //有参构造
this.brand = brand;
this.price = price;
}
public void setBrand(String brand) { //设置品牌
this.brand = brand;
}
public String getBrand() { //获取拼拍
return brand;
}
public void setPrice(int price) { //设置价格
this.price = price;
}
public int getPrice() { //获取价格
return price;
}
public void show() {
System.out.println(brand + "..." + price);
}
}
public class JavaObject {
public static void main(String [] args) {
Phone s1 = new Phone(); //空参构造创建对象
s1.setBrand("小米"); //设置品牌
s1.setPrice(2400); //设置价格
System.out.println("品牌名称是" + s1.getBrand() + "..." + "价格是" + s1.getPrice());
System.out.println("-------------------");
//getXxx()获取属性值，可以打印，也可以赋值给其他的变量，做其他的操作
Phone s2 = new Phone("张三",23); //使用有参构造
s2.show(); //只是为了显示属性值
}
}
6.创建一个对象的步骤(掌握)
画图说明一个对象的创建过程(如何加载到内存)做了哪些事情?
Student s = new Student();
1,Student.class加载进内存
2,声明一个Student类型引用s
3,在堆内存创建对象,
4,给对象中属性默认初始化值
5,属性进行显示初始化
6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
7,将对象的地址值赋值给s
class Student {
private String name = "张三";
private int age = 23;
public Student() {
name = "李四";
age = 24;
}
public void show() {
System.out.println(name + "..." + age);
}
}
class JavaObject {
public static void main(String [] args) {
Student s = new Student(); //空参构造创建对象
s.show(); //只是为了显示属性值
}
}
7.长方形案例练习(掌握)
A:案例演示
需求：
定义一个长方形类,定义 求周长和面积的方法，
然后定义一个测试类进行测试。
分析
成员变量：宽width，高height，空参有参构造setXxxx和getXxx;
求周长getLength()，求面积getArea()
class Rectangle {
private int width;
private int height;
public Rectangle() { //空参构造
}
public Rectangle(int width,int height) { //有参构造
this.width = width;
this.height = height;
}
public void setWidth(int width) { //设置宽
this.width = width;
}
public int setWidth() { //获取宽
return width;
}
public void setheight(int height) { //设置高
this.height = height;
}
public int setheight() { //获取高
return height;
}
public int getLenght() { //获取周长
return 2 * (width + height);
}
public int getArea() { //获取面积
return width * height;
}
}
class JavaObject {
public static void main(String [] args) {
Rectangle s = new Rectangle(10,20); //空参构造创建对象
System.out.println(s.getLenght()); //周长
System.out.println(s.getArea()); //面积
}
}
8.员工类案例练习(掌握)
A:案例演示
需求：定义一个员工类Employee
自己分析出几个成员，然后给出成员变量
姓名name,工号id,工资salary
构造方法，
空参和有参的
getXxx()setXxx()方法，
以及一个显示所有成员信息的方法。并测试。
work
class Employee {
private String name;
private String id;//
private double salary;//工资
public Employee() { //空参构造
}
public Employee(String name,String id,double salary) { //有参构造
this.name = name;
this.id = id;
this.salary = salary;
}
public void setName(String name) { //设置姓名
this.name = name;
}
public String setName() { //获取姓名
return name;
}
public void setId(String id) { //设置工号
this.id = id;
}
public String setId() { //获取工号
return id;
}
public void setSalary(double salary) { //设置工资
this.salary= salary;
}
public double setSalary() { //获取工资
return salary;
}
public void work() { //获取信息
System.out.println("我的姓名是" + name + "，工号是" + id + "，工资是" + salary);
}
}
class JavaObject {
public static void main(String [] args) {
Employee e = new Employee("令狐冲","20000",40000); //空参构造创建对象
e.work();
}
}
9.static关键字及内存图(了解)
A:案例演示
通过一个案例引入static关键字。
人类：Person。每个人都有国籍，中国。
B:概念
方便在没有创建对象的情况下来进行调用（方法/变量）。
static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。
class Person {
String name;
static String country;
public void speak() { //说话的方法
System.out.println(name + "..." + country);
}
}
class JavaObject {
public static void main(String [] args) {
Person e = new Person(); //创建对象
e.name = "张老师"; //调用姓名属性并赋值
e.country = "中国"; //调用国籍属性并赋值
e.speak();
Person f = new Person(); //创建对象
f.name = "李老师"; //调用姓名属性并赋值
//f.country = "中国"; //调用国籍属性并赋值
f.speak();
}
}
static关键字的特点(掌握)
A:static关键字的特点
a:随着类的加载而加载
b:优先于对象存在
c:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)
水杯(不能用静态修饰)
共性用静态,特性用非静态
d:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员
B:案例演示
static关键字的特点
class Person {
String name;
static String country;
public void speak() { //说话的方法
System.out.println(name + "..." + country);
}
}
class JavaObject {
public static void main(String [] args) {
Person.country = "日本"; //静态多了一种调用方式，可以通过类名。
System.out.println(Person.country);
}
}
static的注意事项(掌握)
A:static的注意事项
a:在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
b:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：
静态只能访问静态。
B:案例演示
static的注意事项
class Demo {
int num1 = 10; //非静态的成员变量
static int num2 = 20;//静态的成员变量
//public void print1() { //非静态的成员方法，既可以访问静态的成员也可以访问费静态的成员
//System.out.println(num1);
//System.out.println(num2);
//}
public static void print2() { //静态的成员方法
System.out.println(num1); //静态的成员方法不能访问费静态的 变量 num1
System.out.println(num2);
}
}
class JavaObject {
public static void main(String [] args) {
// Demo d = new Demo(); //静态多了一种调用方式，可以通过类名。
// d.print1();
Demo.print2();
}
}
静态变量和成员变量的区别(掌握)
静态变量也叫类变量 成员变量也叫对象变量
A:所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对 象名调用
main方法的格式详细解释(了解)
A:格式
public static void main(String[] args) {}
B:针对格式的解释
public 被jvm调用，访问权限足够大。
static 被jvm调用，不用创建对象，直接类名访问
void被jvm调用，不需要给jvm返回值
main 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args 以前用于接收键盘录入的
C:演示案例
通过args接收键盘例如数据
class JavaObject {
public static void main(String [] args) {
/*
public:被jvm调用，所以权限要足够大
static：被jvm调用，不需要创建对象，直接类名.调用即可
void：被jvm调用不需要有任何的返回值。
main：只有这样写才能被jvm识别，main不是关键字
String [] args:以前是用来接收键盘录入的
*/
System.out.println(args.length);
for (int i = 0;i < args.length ;i ++ ) {
System.out.println(args[i])
}
}
}
工具类中使用静态(了解)
A:制作一个工具类
ArrayTool
1,获取最大值
2,数组的遍历
3,数组的反转
加static静态化
如果一个类中所有的方法都是静态的，需要多做一步，私有构造方法，
private ArrayTool(){}
目的是不让其他类创建本类对象,直接用类名调用即可.
//文件ArrayTool.java
class ArrayTool {
public static int getMax(int[] arr) {
int max = arr[0]; //记录第一个元素
for (int i= 1 ;i < arr.length ;i++) {//从第二个元素开始遍历
if (max < arr[i]) {//max与数组中其他的元素比较
max = arr[i];//记录较大的
}
}
return max;//将最大值返回
}
public static void print(int[] arr) {
for (int i = 0;i < arr.length ; i++ ) { // 遍历数组
System.out.print(arr[i] + " ");
}
}
public static void revArray(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) { //循环次数是元素个数的一半
//arr[0]与arr[arr.length-1-0]交换
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
}
//文件Demo_ArrayTool.java
class Demo_ArrayTool {
public static void main(String[] args) {
int[] arr = {11,66,22,33,44,55,};
/*
非静态的调用方法
ArrayTool at = new ArrayTool();
int max = at.getMax(arr);
System.out.println(max);
System.out.println("----------------");
at.print(arr);
System.out.println();
System.out.println("----------------");
System.out.println("反转后");
at.revArray(arr);
at.print(arr);*/
//静态的调用方法
ArrayTool.print(arr);
}
}
说明书的制作过程(了解)
A:对工具类加入文档注释
B:通过javadoc命令生成说明书
@author(提取作者内容)
@version(提取版本内容)
javadoc -d 指定的文件目录 -author -version ArrayTool.java
@param 参数名称//形式参数的变量名称@return 函数运行完返回的数据
/**
这是一个数组工具类，里面封装了查找数组最大值，打印数组，数组反转方法。
@author zhengaidong
@version v1.0
*/
public class JavaObject {
/**
私有构造方法
*/
private JavaObject(){
}
/**
这是获取数组中最大值得方法
@param arr 接收一个int类型的数组
@return 返回数组中的最大值
*/
public static int getMax(int[] arr) {
int max = arr[0]; //记录第一个元素
for (int i= 1 ;i < arr.length ;i++) {//从第二个元素开始遍历
if (max < arr[i]) {//max与数组中其他的元素比较
max = arr[i];//记录较大的
}
}
return max;//将最大值返回
}
/**
这是遍历数组的方法
@param arr 接收一个int类型的数组
*/
public static void print(int[] arr) {
for (int i = 0;i < arr.length ; i++ ) { // 遍历数组
System.out.print(arr[i] + " ");
}
}
/**
这是数组反转的方法
@param arr 接收一个int类型的数组
*/
public static void revArray(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) { //循环次数是元素个数的一半
//arr[0]与arr[arr.length-1-0]交换
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
}
如何使用JDK提供的帮助文档(了解)
A:找到文档，打开文档
B:点击显示，找到索引，出现输入框
C:你应该知道你找谁?举例：Scanner
D:看这个类的结构(需不需要导包)
成员变量 字段
构造方法 构造方法
成员方法 方法
学习Math类的随机数功能(了解)打开JDK提供的帮助文档学习
A:Math类概述
类包含用于执行基本数学运算的方法
B:Math类特点
由于Math类在java.lang包下，所以不需要导包。
因为它的成员全部是静态的,所以私有了构造方法
C:获取随机数的方法
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数，肿么办?
int number = (int)(Math.random()*100)+1;
public class JavaObject {
public static void main(String [] args) {
//double d = Math.random();
//System.out.println(d);
//Math.random()会生成大于等于0.0并且小于1.0的伪随机数
for (int i = 0;i < 10;i++ ) {
System.out.println(Math.random());
}
//生成1到100的随机数0.00000000000000-0.999999999999999
//Math.random() * 100 ==>0.000000 - 99.9999999999
//(int)(Math.random() * 32) ====> 0 - 99
//(int)(Math.random() * 100) + 1
for (int i = 0;i < 7 ;i++ ) {
System.out.println((int)(Math.random() * 32) + 1);
}
}
}
猜数字小游戏案例(了解)
A:案例演示
需求：猜数字小游戏(数据在1-100之间)
import java.util.Scanner;
public class JavaObject {
public static void main(String [] args) {
Scanner sc = new Scanner(System.in);//创建键盘录入对象
System.out.println("请输入一个整数，范围在1-100之间");
int guessNum = (int)(Math.random() * 100) + 1;//心理想的随机数
while (true) {
int x = sc.nextInt();
if (x > guessNum) {
System.out.println("大了");
} else if (x < guessNum) {
System.out.println("小了");
} else {
System.out.println("中了");
break;
}
}
}
}
文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。
转载请注明本文地址：https://www.ucloud.cn/yun/76913.html
摘要：每次调用构造都执行，并且在构造方法前执行静态代码块在类中方法外出现，并加上修饰用于给类进行初始化，随着类加载而加载，一般用来给类进行初始化，在加载的时候就执行，并且只执行一次。的构造方法这是一条隐藏语句，用来访问父类中的空参构造。 1.代码块的概述和分类(了解)(实际不用） A:代码块概述 在Java中，使用{}括起来的代码被称为代码块。 B:代码块分类 根据其位置和声明的不同...
摘要：案例演示抽象类的成员特点抽象类的成员方法特性抽象方法强制要求子类做的事情。抽象类中定义的是该继承体系的共性功能。 1.多态的概述及其成员访问特点代码体现 A:多态(polymorphic)概述 事物存在的多种形态 B:多态前提- 1.要有继承关系 2.要有方法重写 3.要有父类引用指向子类对象。 C:多态中的成员访问特点之 成员变量：编译和运行都看父类。 成员方法：编...
摘要：外部类要访问内部类的成员，必须创建对象。前提存在一个类或者接口这里的类可以是具体类也可以是抽象类。 1.package关键字的概述及作用(了解) A:为什么要有包 将字节码(.class)进行分类存放 包其实就是文件夹 B:包的概述 举例： 学生：增加，删除，修改，查询 老师：增加，删除，修改，查询 ... 方案1：按照功能分 com.heima.add ...
摘要：正则表达式的概述和简单使用正则表达式是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。例如，在表达式中，存在四个这样的组组零始终代表整个表达式。 1_正则表达式的概述和简单使用 A:正则表达式 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个...
摘要：很多情况下，通常一个人类，即创建了一个具体的对象。对象就是数据，对象本身不包含方法。类是相似对象的描述，称为类的定义，是该类对象的蓝图或原型。在中，对象通过对类的实体化形成的对象。一类的对象抽取出来。注意中，对象一定是通过类的实例化来的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 马上就要到七夕了，离年底老妈老爸...
阅读 2077·2023-04-25 19:15
阅读 2244·2021-11-23 09:51
阅读 1263·2021-11-17 09:33
阅读 2164·2021-08-26 14:15
阅读 2475·2019-08-30 15:54
阅读 1581·2019-08-30 15:54
阅读 2166·2019-08-30 12:50
阅读 1131·2019-08-29 17:08
