Java_Day03学习
Day03
构造方法目的
为类的属性赋值
构造方法调用
//调用带参方法时，要先实例化类，创建对象再调用；
eg：
public class Max_and_Min {
//方法:访问修饰符 返回类型 方法名(形式参数类型 形参，形参类型 形参) {}
public void sort_Data(int sss[]){
System.out.print("对对对" + "\t");
}
//主函数调用
public static void main(String[] args) {
//实例化对象
Max_and_Min mmm = new Max_and_Min();
//对"对象"的方法进行调用,调用方法时不能指定实参类型！
mmm.sort_Data(sss);
}
}
构造方法传参
//基本数据类型和引用数据类型再传参时的区别
Student_Manager.java
public class Student_Manager {
int age;
public static void main(String[] args) {
Test test=new Test();
int n=8;
test.calc1(n);
Student_Manager stu=new Student_Manager();
stu.age=18;
test.calc2(stu);
System.out.println(n+"---"+stu.age);
}
Test.java
public class Test {
//基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。
public void calc1(int num){
num=num+1;}
//引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用
public void calc2(Student_Manager student){
student.age=student.age+1;}
}
tips: 一个.java文件中，只能写一个class主类，且类名与文件名相同，在其后可以写一些子类;
//无参构造方法，每个类都有个默认无参构造方法
//class一个类，也是定义了一种数据类型，如下，创建了一个Student类型的数组，Student是自己定义的类
Student[] stus=new Student[3];
Student s1=new Student();s1.name="张三";
s1.score=40;
Student s2=new Student();s2.name="李四";
s2.score=90;
stus[0]=s1;
stus[1]=s2;
构造方法重载
自定义构造方法：
eg:
public Student(){} //无参构造方法
public Student(String name,int age){ //含参构造方法
//带参构造方法this关键字是对一个对象的默认引用
//这里用以区分同名成员变量， this.name是传过来的参数的name
this.name=name;
this.age=age;}
}
两个构造方法名相同、参数项不同、与返回值和访问修饰符无关系；
this的用法
//调用属性
this.health = 100;
this.name = "大黄";
//调用方法
this.print();
//调用构造方法
this();
this("小黑",100,100,"雄");
class Penguin {
int health;
String sex;
String name;
public void Penguin01() {
name ="Mark"
health=10;
sex="雄";
}
public void Penguin01(String name,int health,String sex){
this.name = name; //this.name 等同于全局变量的name;
this.health = health;
this.sex = sex;
System.out.println("企鹅的名字是" + name + ",健康值是" + health + ",性别是" + sex);
}
Penguin pgn3= new Penguin();
pgn3.print();
}
成员变量和局部变量
//变量声明的位置决定变量作用域
//变量作用域确定可在程序中按变量名访问该变量的区域
区别：
◆作用域不同
//局部变量的作用域仅限于定义它的方法
//成员变量的作用域在整个类内部都是可见的◆初始值不同
◆初始值不同
//Java会给成员变量一个初始值
//Java不会给局部变量赋予初始值
在同一个方法中，不允许有同名局部变量在不同的方法中，可以有同名局部变量
在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级
封装
1.定义：
//将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
2.封装的两个大致原则
//把尽可能多的东西藏起来，对外提供便捷的接口
//把所有的属性藏起来
3.封装的好处：
//◆便于使用者正确使用系统，防止错误修改属性
//◆有助于系统之间的松耦合，提高系统独立性
//◆提高软件的可重用性
//◆降低了构建大型系统的风险
public class Person {
/*
* 对属性的封装 一个人的姓名、性别和年龄都是这个人的私有属性
*/
private String name; //封装了name、sex、age等属性，仅供类的内部使用的权限
private String sex;
private int age;
/*
* setter()、getter()是该对象对外开放的接口
*/
//当外部的其他类调用Person的name属性时，因为name是private，外部的其他类没有调用权限，使用getName，来获取这个私有的private内部属性name
public String getName() {
return name;
}
//为Person这个类的name属性赋值，解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。
public void setName(String name) {
this.name = name;
}
}
包
1.Windows树形文件系统
//文档分门别类，易于查找和管理
//使用目录解决文件同名冲突问题
2.包的作用：
允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
防止命名冲突区分名字相同的类
有助于实施访问权限控制
3.包的使用
package cn.jbit.inherit; //声明包，作为Java源代码第一条语句，用package声明包，以分号结尾
4.包的命名
//package mypackage;
包名由小写字母组成，不能以圆点开头或结尾
//package net.javagroup.mypackage;
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
//package net.javagroup.research.powerproject;
包名后续部分依不同机构内部的规范不同而不同
5.包的导入
import java.util.*; //导入java.util包中所有类
import cn.jtest.classandobject.School; //导入指定包中指定类
6.使用包的注意事项
//一个类同时引用了两个来自不同包的同名类，必须通过完整类名来区分
//每个包都是独立的，顶层包不会包含子包的类
//package和import的顺序是固定的
//package必须位于第一行（忽略注释行），且只允许有一个package语句，其次是import，接着是类的声明
类的访问控制
1.public 修饰符：公有访问级别
2.protected 修饰符：
3.默认修饰符：包级私有访问级别
4.private 修饰符：
static 修饰符：
修饰对象：
1.修饰成员变量 //静态变量，可以直接通过类名访问
2.修饰成员方法 //静态方法，可以直接通过类名访问
3.代码块 //静态代码块，当Java虚拟机加载类时，就会执行该代码块
JVM加载类时，加载静态代码块
1.如果有多个静态块，按顺序加载
2.每个静态代码块只会被执行一次
eg:
public class StaticTest {
//静态代码块会在创建对象前执行
//再类加载的时候，已执行
//如果有多个静态块，就会顺序执行
public static int num=100;
static{
num+=100;
System.out.println(num);}
static{
num+=100;
System.out.println(num);}
//静态方法只能访问静态方法和静态成员，不能访问实例成员
public static void method1(){ }
StaticTest(){
System.out.println("这是一个构造方法！");
}
}
//调用Static代码块
class test001{
public static void main(String[] args) {
//静态成员，可以直接用 类名.静态成员 访问
System.out.println(StaticTest.num);
//静态方法，可以直接用 类名.静态方法 访问
StaticTest.method1();
}
}
4.类的成员变量包括
1.类变量（静态变量）
//被static修饰的变量
☆//在内存中只有一个拷贝，当是从内存上更改值的
//类内部，可在任何方法内直接访问静态变量
//其他类中，可以直接通过类名访问
2.实例变量
//没有被static修饰的变量
//每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响
eg:
public class StaticTest {
//全局的对象
public static int num=0;
//实例（单个对象）
public int a=0;
}
}
public class Test {
public static void main(String[] args) {
StaticTest st1=new StaticTest();
st1.num = 100; //静态变量，全局的 任何对象修改都会改变
st1.a = 50; //实例变量 （只会修改自己的属性和方法）
StaticTest st2=new StaticTest();
st2.num = 1000; //静态变量，全局的 任何对象修改都会改变
st1.a = 500; //实例变量 （只会修改自己的属性和方法）
//static修饰的变量 是全局的，任何对象修改都会改变
System.out.println(st1.num); //1000
System.out.println(st1.a); //50
System.out.println(st2.num); //1000
System.out.println(st2.a); //500
}
}
5.static变量的作用：
（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间
6.static方法
静态方法：可直接通过类名访问
//但静态方法中不能使用this和super
//不能直接访问所属类的实例变量和实例方法
//可直接访问类的静态变量和静态方法
实例方法：通过实例访问
//可直接访问所属类的静态变量、静态方法、实例变量和实例方法
//静态方法必须被实现，main()就是最常用的静态方法
继承
1.定义：//是指可以让某个类型的对象获得另一个类型的对象的属性的方法。以此减少重复的代码。
2.继承中 extends 作为关键词，在子类中，实现对父类的继承
eg:
//父类
class Pet { }
//子类Dog 继承 Pet类
class Dog extends Pet {}
//继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类
3.子类访问父类成员
//访问父类构造方法
super();
super(name);
//访问父类属性
super.name;
//访问父类方法
super.print();
（1）使用super关键字,super代表父类对象
（2）在子类构造方法中调用且必须是第一句
（3）不可以访问父类中定义为private的属性和方法
4.继承条件下的构造方法
◆继承条件下构造方法的调用规则
◼子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法
⚫系统默认调用父类的无参构造方法
◼子类构造方法通过super显式调用父类的有参构造方法
⚫执行父类相应构造方法，而不执行父类无参构造方法
◼子类构造方法通过this显式调用自身的其他构造方法，
在相应构造方法中应用以上两条规则