3.2类与对象
3.2.1类的定义
class student{//类名student
String name;//成员变量
int age;
String dex;
String sex;
void read(){//成员方法
System.out.println("大家好,我是"+name+",我在看书!");
}
}
public class java_code {
public static void main(String[] args)
{
student arr = new student();
arr.name = "remarkable";
arr.read();
}
}
3.2.2对象的创建与使用
创建student类的对象
student stu = new student();
class student{//类名student
String name;//成员变量
void read(){//成员方法
System.out.println("大家好,我是"+name+",我在看书!");
}
}
public class java_code {
public static void main(String[] args)
{
student stu1 = new student();
student stu2 = new student();
stu1.name = "Xiaoming";
stu1.read();
stu2.name = "Xiaohua";
stu2.read();
}
}
3.2.3对象的引用传递
class student{//类名student
String name;//成员变量
int age;
void read(){//成员方法
System.out.println("大家好,我是"+name+",年龄:" + age);
}
}
public class java_code {
public static void main(String[] args)
{
student stu1 = new student(); //给stu1分配堆内存,存储类
student stu2 = null;//不会重新开辟新的堆内存
stu2 = stu1;//将stu1对象的堆内存空间的使用权分配给stu2
stu1.name = "Xiaoming";
stu1.age = 18;
stu2.age = 20;//通过stu2对象去修改stu1对象
stu1.read();
stu2.read();
}
}
大家好,我是Xiaoming,年龄:20
大家好,我是Xiaoming,年龄:20
3.2.4访问控制
1、4种访问权限:
(1)private:私有访问权限,只能在本类中访问
(2)default:默认访问权限,只能在本包中访问
(3)protected:受保护的访问权限
(4)public:公共访问权限,
class Test{
public int aa; //aa可以被所有的类访问
protected boolean bb;
void cc(){
System.out.println("包访问权限");
}
//private权限的内部类,即这是私有的内部类,只能在本类中使用
private class InnerClass{
}
}
class Test{
{
public int aa; //报错,局部变量没有访问权限
protected boolean bb;
}
void cc(){
System.out.println("包访问权限");
}
//private权限的内部类,即这是私有的内部类,只能在本类中使用
private class InnerClass{
}
}
public class dfs {
public static void main(String[] args)
{
}
}
3.3封装性
3.3.1为什么要封装
class stu{
String name;
int age;
void read(){
System.out.println("name:"+name+" 年龄:"+age);
}
}
public class dfs {
public static void main(String[] args){
stu st = new stu ();
st.name = "zhangsan";
st.age = -18; //-18不符合年龄值,
//在设计类stu时,应对成员变量的访问做出一些限定,不允许外界随意访问,即就是要满足必要的约束条件
st.read();
}
}
name:zhangsan 年龄:-18
3.3.2如何实现封装
1、在定义一个类的时候,如果使用private修饰类的属性,被私有化的属性只能在类中被访问,
如果外界要访问私有属性,则必须通过setter和getter方法设置和获取属性值。
/*
* 1.set方法用处
* 从主函数中获取参数,并对参数加以约束,然后将满足条件的参数赋给类的属性
* 通过this.属性 来访问类中的属性
* 2.get方法用处
* 通过get方法,可以在主函数中访问类中的私有变量
*/
class stu{
private String name;
private int age;
//get方法,获取name和age,对外界提供公有的访问方法
public String getName(){
return name;
}
public int getAge(){
return age;
}
//set方法,对传入的属性加约束,注意set无返回值
public void setName(String name){
this.name = name; //this.name指类中私有变量name, name指本函数中的形参name
}
public void setAge(int age){
if(age <= 0){
System.out.println("input is waring");
} else {
this.age = age;//把满足条件的值赋给类属性name
}
}
void read(){
System.out.println("name:"+name+" 年龄:"+age);
}
}
public class dfs {
public static void main(String[] args){
stu st = new stu ();
st.setName("zhangsan");//通过set对传入的参数进行卡第一道关卡
st.setAge(-18);
st.read();
// System.out.println(st.name()); 报错,因为name是私有变量
System.out.println(st.getName()); //通过get方法可以在主函数中得到私有变量
}
}
input is waring
name:zhangsan 年龄:0
zhangsan
3.4构造方法
在实例化对象时为对象的属性赋值,可以通过构造方法实现,
3.4.1定义构造方法
class stu{
private String name;
private int age;
public stu(){ //无参构造方法
}
public stu(String name , int age){ //有参构造方法
this.name = name;
this.age = age;
}
void read(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
public class dfs{
public static void main(String[] args){
stu st = new stu("lihua",18);
st.read();
}
}
3.4.2构造方法的重载
class stu{
private String name;
private int age;
public stu(){ //无参构造方法
}
public stu(String name , int age){ //有参构造方法
this.name = name;
this.age = age;
}
public stu(String name){ //一个参数的构造方法,即重载
this.name = name;
}
public stu(int age){ //一个参数构造方法
this.age = age;
}
void read(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
public class dfs{
public static void main(String[] args){
stu st1 = new stu("lihua",18); //两个参数
stu st2 = new stu("zhongyuchen"); //一个参数name
stu st3 = new stu(20); //一个参数age
stu st4 = new stu();//无参构造方法
st1.read();
st2.read();
st3.read();
st4.read();
}
}
姓名:lihua 年龄:18
姓名:zhongyuchen 年龄:0
姓名:null 年龄:20
姓名:null 年龄:0
3.5 this关键字
this关键字主要用法有3如下:
(1)使用this关键字调用本类中的属性
(2)使用this关键字调用成员方法
(3)使用this关键字调用本类中的构造方法
3.5.1调用本类中的属性
通过this可以访问当前对象的成员
public stu(int age){ //一个参数构造方法
this.age = age;
}
3.5.2调用成员方法
class stu{
public void openMouth(){
}
public void read(){
this.openMouth(); //当然这里的this可省略
}
}
3.5.3调用本类中的构造方法
class stu{
private String name;
private int age;
public stu(){ //无参构造方法
System.out.println("这是一个通过this调用构造方法");
}
public stu(String name){ //一个参数的构造方法,即重载
this(); //调用无参构造方法
/*
* (1)只能在构造方法中使用this调用其他构造方法,不能在成员方法中使用
* (2)在构造方法中,使用this调用构造方法的语句必须放在第一行,且只能出现一次
* (3)不能在一个类的两个构造方法中使用this互相调用
*/
this.name = name;
}
void read(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
public class dfs{
public static void main(String[] args){
stu st2 = new stu("zhongyuchen"); //一个参数name
st2.read();
}
}
这是一个通过this调用构造方法
姓名:zhongyuchen 年龄:0
3.6代码块
3.6.1普通代码块
在方法或语句中定义的大括号
3.6.2构造块
又称构造代码块,直接在类中定义的代码块。
构造块的执行顺序优先于构造方法
3.7static关键字
希望某些属性被所有对象共享,就必须将其声明为static属性,随后该属性可以直接使用类名称进行调用。
3.7.1静态属性
也称全局属性,访问格式:
类名.属性名
stu.name
class stu{
private String name;
private int age;
static String school = "陕科大";
public stu(String name){ //一个参数的构造方法,即重载
this.name = name;
}
void read(){
System.out.println("姓名:"+name+" 年龄:"+age+" 学校:"+school);
}
}
public class dfs{
public static void main(String[] args){
stu st1 = new stu("zhongyuchen");
stu st2 = new stu("future");
stu st3 = new stu("remarkable");
st1.read();
st2.school = "北航";
/*
* 使用static修饰school属性,将其变成公共属性,这样school属性就被stu类的所有对象共享,
* 只要某个对象的该属性school进行一次修改,则后面的全部学生对象的school属性值都会被改变。
* static只能修饰成员变量,不能修饰局部变量如函数中的变量。
*/
st2.read();
st3.read();
}
}
姓名:zhongyuchen 年龄:0 学校:陕科大
姓名:future 年龄:0 学校:北航
姓名:remarkable 年龄:0 学校:北航
3.7.2静态方法
在不创建对象的情况下,通过类名直接调用某个方法,
因而在方法前加static,就可实现,这叫静态方法。
访问方式:
类名.方法
实例对象名.方法
stu.read();
st1.read();
class stu{
private static String name;
private static int age;
static String school = "陕科大";
public stu(String name){
this.name = name;
}
public static void read(){ //静态方法只能访问静态变量
System.out.println("姓名:"+name+" 年龄:"+age+" 学校:"+school);
}
}
public class dfs{
public static void main(String[] args){
stu st1 = new stu("zhongyuchen");
st1.read();
stu.read();
/*
* (1)静态方法通过类名直接访问
* (2)静态方法只能访问静态成员,所以name/age/school为static属性
* (3)所以在第一次赋name是zhongyuchen后面的所有都是zhongyuchen*/
}
}
姓名:zhongyuchen 年龄:0 学校:陕科大
姓名:zhongyuchen 年龄:0 学校:陕科大
3.7.3静态代码块
用static修饰的代码块称为静态代码块。
当类在执行时,类只加载一次,因此静态代码块只执行一次。
通常使用静态代码块对类的成员变量进行初始化
package review;
class Student{
{
System.out.println("构造代码块");
}
static{
System.out.println("静态代码块,只执行一次");
}
public Student(){
System.out.println("构造方法");
}
}
public class r1 {
public static void main(String[] args){
Student stu1 = new Student();
Student stu2 = new Student();
Student stu3 = new Student();
}
}
静态代码块,只执行一次
构造代码块
构造方法
构造代码块
构造方法
构造代码块
构造方法
代码块的执行顺序:
静态代码块 、 构造代码块 、 构造方法