1、构造方法
构造方法：给成员变量做初始化作用的
(1)构造方法可以发生重载
(2)如果我们没有提供构造方法，系统会默认提供一个无参空方法体的构造方法
(3)如果我们提供了构造方法，无论提供的是无参还是有参，系统都不会再提供了
(4)格式：方法名与类名一致，没有返回值类型，连return都没有。
(5) 构造方法在创建对象的时候调用。
/*
构造方法：
语句定义格式：
1、方法名与类名相同
2、构造方法是没有返回值的，连void都没有
3、没有具体的返回值
*/
class Student {
private String name;
private int age;
//定义一个构造方法
Student(){
System.out.println("这是一个构造方法");
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
public class StudentDemo1 {
public static void main(String[] args) {
//创建Student类的对象
//调用的是无参构造方法创建对象
Student s1 = new Student();
Student s2 = new Student();
// System.out.println(s1.getName()+"---"+s1.getAge());
}
}class Construction1{
private String name;
private int age;
Construction1(){
System.out.println("这是我们自己提供的无参构造方法");
}
Construction1(String name){
System.out.println("这是我们提供的带参数name的构造方法");
this.name = name;
}
Construction1(int age){
System.out.println("这是我们提供的带参数age的构造方法");
this.age = age;
}
Construction1(String name,int age){
System.out.println("这是我们提供的带两个参数name,age的构造方法");
this.name = name;
this.age = age;
}
public void show(){
System.out.println(name+"---"+age);
}
}
public class ConstructionDemo1 {
public static void main(String[] args) {
// Construction1 construction1 = new Construction1();
// construction1.show();
//使用带参数的构造方法来创建对象
// Construction1 c2 = new Construction1("周家祥");
// c2.show();
// Construction1 c3 = new Construction1(18);
// c3.show();
//使用带两个参数name,age的构造方法来创建对象
Construction1 c4 = new Construction1("阿杰", 18);
c4.show();
}
}
2、给成员变量赋值的两种方式：
1、无参构造+setXxx(...)
2、带参构造赋值，这里需要与this关键字配合使用
/*
类的组成：成员变量，成员方法
今天我们又学习了一个新的成员：构造方法。
一个标准类的3.0版本写法：
成员变量：被private修饰
构造方法：一个无参构造方法/一个带所有参数的构造方法
成员方法：getXxx()和setXxx(...)
show()：打印所有成员变量的值
无论我们提供的是带参构造还是无参构造，只要是我们自己提供了一个，系统就永远不会提供了
*/
class Teacher {
private String name;
private int age;
//构造方法：
Teacher() {
}
Teacher(String name, int age) {
this.name = name;
this.age = age;
}
//getXxx()
public String getName() {
return name;
}
public int getAge() {
return age;
}
//setXxx(...)
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
//show()
public void show() {
System.out.println(name + "---" + age);
}
}
public class TeacherDemo {
public static void main(String[] args) {
//使用无参构造方法创建对象，使用setXxx() 对成员变量进行赋值
//开发使用这种方法
Teacher t1 = new Teacher();
t1.setName("阿杰");
t1.setAge(18);
t1.show();
//使用带参数的构造方法创建对象并给成员变量进行赋值
//上课使用这种方法
Teacher t2 = new Teacher("阿豪", 18);
t2.show();
}
}3、创建对象初始化的流程
a:先将class文件加载到方法区中
b:在栈中为变量开辟空间
c:在堆内存中创建对象
d:系统给成员变量进行默认赋值
e:给成员变量进行显示赋值
f:构造方法给成员变量进行赋值
g:将堆内存中的地址赋值给栈内存中的变量、
4、static
它可以修饰成员变量，成员方法
被static修饰的成员随着类的加载而加载，加载到方法区中的静态区，又称之为类成员
被static修饰的成员可以直接通过类名访问，格式：类名.静态成员
属性静态的内存
5、静态变量与成员变量的区别：
(1)所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
(2)内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
(3)内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
(4)调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
6、static关键字使用注意事项：
(1)在静态方法中是没有this关键字的
this代表的是当前调用该方法的对象，而被static修饰的成员是优先于对象而存在的。 被static修饰的成员是随着类的加载而加载，这时候，还没有对象产生，也就说明没有this关键字 所以在静态方法中无法使用this关键字。
(2)将成员方法分成两类：
a、静态的成员方法：
访问的内容：
成员变量：只能访问静态的成员变量
成员方法：只能访问静态的成员方法
b、非静态的成员方法：
访问的内容：
成员变量：既可以访问非静态的成员变量，也可以访问静态的成员变量
成员方法：既可以访问非静态的成员方法，也可以访问静态的成员方法 如果 你实在记不住这些，总结一句话： 静态的只能访问静态的。
/*
定义一个人的类
我们定义完并使用后发现，姓名和年龄不一样，是变化的，我们可以理解，因为每个人的姓名和年龄都不一样。
但是，到目前位置，我们选的几个人都是中国人，他们的国籍都一样，都是中国。
一样的国籍，我们每次在创建的时候，都会在堆内存中开辟这样的成员变量的空间。
当一样国籍的人非常多的时候，这样就会造成内存浪费了，怎么办呢？
针对于多个对象有着共同的成员变量，值是一样的时候。
java就提供了一个关键字给我们使用，这个关键字叫做：static
static:静态的
它可以修饰成员变量和成员方法，它的作用是可以让所有的对象共享一个成员变量
*/
class Human {
//姓名
private String name;
//年龄
private int age;
//国籍
// private String country;
private static String country;
public Human() {
}
public Human(String name,int age){
this.name = name;
this.age = age;
}
public Human(String name, int age, String country) {
this.name = name;
this.age = age;
this.country = country;
}
//getXxx()和setXxx(...)
public void setCountry(String country) {
Human.country = country;
}
public void show() {
System.out.println("姓名：" + name + ",年龄：" + age + ",国籍：" + country);
}
}
public class HumanDemo {
public static void main(String[] args) {
//创建第一个对象
Human h1 = new Human("阿杰", 42, "中国");
h1.show();
//创建第二个对象
Human h2 = new Human("阿豪", 38);
h2.show();
//创建第三个对象
Human h3 = new Human("阿明", 22);
h3.show();
h3.setCountry("加拿大");
h1.show();
h2.show();
h3.show();
}
}7、工具类的创建：
a：构造方法私有化
b：方法被static修饰
8、定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。(两个数做操作)
class MyMath {
private int num1;
private int num2;
public MyMath() {
}
public MyMath(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
}
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
//加法运算
public int add() {
return num1 + num2;
}
//减法运算
public int sub() {
return num1 - num2;
}
//乘法运算
public int mul() {
return num1 * num2;
}
//除法运算
public double div() {
return (num1*1.0) / num2;
}
}
public class MyMathDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个操作数");
int number1 = sc.nextInt();
System.out.println("请输入第二个操作数");
int number2 = sc.nextInt();
MyMath myMath = new MyMath(number1, number2);
System.out.println("两数之和为："+myMath.add());
System.out.println("两数之差为："+myMath.sub());
System.out.println("两数之积为："+myMath.mul());
System.out.println("两数之商为："+myMath.div());
}
}9、 main方法的格式讲解：
public static void main(String[] args){....}
public: 公共的，访问权限是最大的，因为main是由JVM调用的，所以权限要足够大
static: 静态的，不需要创建对象，通过类名直接调用，方便JVM访问
void: 表示无返回值，因为我们直接说过返回值，是返回给调用者的，而调用main方法是 由JVM调用的，返回给他没有意义
String[] args: 参数是是一个字符串数组，数组形参名叫args?
这个东西怎么用？如果传参呢？值去哪里的呢？
早期JDK1.5之前，没有Scanner键盘录入的时候，那时候程序员如何给程序 传参呢？就是借助这里的args传参
怎么用呢？
(1)IDEA可以直接传参
(2)命令传参
java MainDemo hello world java
public class MainDemo {
public static void main(String[] args) {
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
}
}10、一个标准的手机类3.0版本：
成员变量：brand,price,color 他们都是被private修饰
构造方法：无参构造方法，带所有参数的构造方法
成员方法：getXxx()/setXxx(...) 打电话
show()：遍历所有的成员变量的值
class Phone {
//定义成员变量
private String brand;
private int price;
private String color;
//定义构造方法
Phone() {
}
Phone(String brand, int price, String color) {
this.brand = brand;
this.price = price;
this.color = color;
}
//setXxx()和getXxx()
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 setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
//手机特有的方法
//打电话
public void call(String name) {
System.out.println("给" + name + "打电话");
}
//show()
public void show() {
System.out.println(brand + "---" + price + "---" + color);
}
}
public class PhoneDemo {
public static void main(String[] args) {
//使用无参构造方法创建对象并使用setXxx进行赋值
Phone p1 = new Phone();
p1.setBrand("小米");
p1.setPrice(1999);
p1.setColor("黑色");
p1.call("阿杰");
p1.show();
//使用带参数的构造方法进行赋值
Phone p2 = new Phone("傻妞", 1000000, "透明");
p2.show();
p2.call("陆小千");
}
}11、定义一个数组：实现遍历，逆序
工具类创建注意事项：
(1)构造方法私有化，不能让外界创建对象
(2)将工具类中的方法用静态修饰，可以让外界直接通过类名访问
如何制作说明书（帮助文档）
(1)工具类
(2)借助文档注释生成帮助文档
怎么加注释？ 看ArrayTool
加什么东西呢？ 看ArrayTool
怎么用呢？格式：javadoc -d 目录 -author -version ArrayTool.java
（ 其中 -d <directory> 输出帮助文档的目录）
注意：需要我们手动创建
/**
* 这是针对数组相关操作的工具类
* @author 阿杰
* @version V.1.0
*
*/
public class ArrayTool {
/**
* 这是私有的无参构造方法
*/
private ArrayTool(){
}
/**
* 这是遍历数组的方法，遍历后的格式是[元素1,元素2,元素3...]
* @param array 这是调用该方法时需要传入的参数，数据类型是int类型的数组
*/
public static void printArray(int[] array){
for(int i=0;i<array.length;i++){
if(i==array.length-1){
System.out.print(array[i]+"]");
}else if(i==0){
System.out.print("["+array[i]+",");
}else {
System.out.print(array[i]+",");
}
}
System.out.println();
}
/**
* 这是数组逆序的方法
* @param array 这是调用该方法时需要传入的参数，传入的数据类型是int类型的数组
* @return 返回逆序后的数组
*/
public static int[] niXu(int[] array){
for(int start=0,end=array.length-1;start<=end;start++,end--){
int temp = array[start];
array[start] = array[end];
array[end] = temp;
}
return array;
}
}12、生成构造方法，get,set方法的快捷键
alt + Insert
13、定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试了Test，进行测试。
class Demo {
//方式1：虽然我们实现了两个数求和，但是值是固定的，没有灵活度
// int a = 10;
// int b = 20;
//
// public int sum() {
// return a + b;
// }
//方式2：
public int sum(int a, int b) {
return a + b;
}
//方式3：使用面向对象的思想
// private int a;
// private int b;
//
// Demo(int a, int b) {
// this.a = a;
// this.b = b;
// }
//
// public int sum() {
// return a + b;
// }
//这道题，最好的解决方式是方式2，为什么？
//方式3虽然使用了面向对象的思想，但是我们忽略了一个问题
//想一想，什么情况可以将一个变量作为成员变量呢？
//当成员变量是该类的相关属性的时候，可以去定义成成员变量
//这里的a,b仅仅表示的是一个方法中的两个参数，与我们Demo类没有关系
//所以不应该定义成成员变量
}
public class Test1 {
public static void main(String[] args) {
//创建对象调用方法
// Demo demo = new Demo();
// int sum = demo.sum();
// System.out.println(sum);
Demo demo = new Demo();
int sum = demo.sum(10, 20);
System.out.println(sum);
//方式3：
// Demo demo = new Demo(100, 200);
// int sum = demo.sum();
// System.out.println(sum);
}
}14、定义一个长方形类,定义 求周长和面积的方法，然后定义一个测试了Test2，进行测试。
class Rectangle {
//由于长和宽都是用来描述长方形的，和类有关系，是该类的属性
//所以定义成成员变量
private int length;
private int width;
public Rectangle() {
}
public Rectangle(int length, int width) {
// this.length = length;
// this.width = width;
if (length >= width) {
this.length = length;
this.width = width;
} else {
System.out.println("输入的数据不正确，请检查长宽的大小是否符合标准");
}
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
//定义求长方形周长的方法
public int getGirth() {
return 2 * (length + width);
}
//定义求长方形面积的方法
public int getArea() {
return length * width;
}
public void show() {
System.out.println("长：" + length + "宽：" + width);
}
}
public class Test2 {
public static void main(String[] args) {
// Rectangle rectangle = new Rectangle();
// rectangle.setLength(10);
// rectangle.setWidth(5);
// rectangle.setLength(5);
// rectangle.setWidth(10);
//使用构造方法赋值
Rectangle rectangle = new Rectangle(5, 10);
int girth = rectangle.getGirth();
System.out.println("周长为：" + girth);
int area = rectangle.getArea();
System.out.println("面积为：" + area);
}
}