面向对象（上）
类与对象
类的定义
类的定义格式如下：`
class 类名{ 成员变量； 成员方法； }
class student{
String name;
int age;
String sex;
//定义read方法
void read(){
System.out.println("大家好，我是"+name+",我在阅读");
}
}
以上代码中定义了Student类，在成员方法中可以直接访问成员变量name.。1
class student{
int age=30;
void read(){
int age=50;
System.out.println(age);
}
}
对象的创建和使用
使用new关键字创建对象的具体格式如下：
类名 对象名=null;
对象名=new 类名();
上述格式中，创建对象分为声明对象和实例化对象两步。声明和实例化可合为一步。
类名 对象名=new 类名();
创建对象后，可以使用对象访问类中的某个属性和方法，对象属性和方法的访问通过点(.)运算符实现，具体格式如下：
对象名.属性名
对象名.方法名
class student{
String name;
void read(){
System.out.println("大家好，我是"+name+",我在阅读");
}
}
public class test1 {
public static void main(String args[]){
student stu=new student();
}
}
上述代码在main方法中实例化了Student对象，对象名为stu。使用new关键词创建的对象在堆内存中分配空间。
对象的引用传递
类属于引用数据类型，引用数据类型的内存空间可以同时被多个栈内存使用。
class student{
String name;
int age;
void read(){
System.out.println("大家好,我是"+name+",年龄"+age);
}
}
public class test1 {
public static void main(String args[]){
student stu1=new student();
student stu2=null;
stu2=stu1;
stu1.name="小明";
stu1.age=20;
stu2.age=50;
stu1.read();
stu2.read();
}
}
stu1和stu2共用一个栈内存。stu1和stu2对象输出的内容是一致的。实际上所谓的引用传递，就是将一个堆内存空间的使用权分配给多个栈内存空间使用，每个栈内存空间都可以修改堆内存空间的内容。
一个具有注脚的文本。2
访问控制权限
在java中，针对类、成员方法和属性，java提供了4种访问控制权限，分别是private、default、protect和public。这四种访问控制权限按级别由低到高的次序：
private:私有访问权限。用于修饰类的属性和方法，看也可以修饰内部类。类的成员一旦使用了private关键字修饰，则该成员只能在本类中访问。
default:默认访问权限。如果一个类中的属性或方法没有任何访问或权限声明，则该属性或方法就是默认访问权限，可以被本包中的其他类访问，但是不能被其他包的类访问。
protected:受保护的访问权限。如果一个类中的成员使用了protected关键字修饰，则只能被本包及不同包中的子类访问。
public:公共访问权限。如果一个类中的成员使用了public关键字修饰，则该成员可以在所有类中被访问，不管是否在同一个包中。
局部成员是没有访问控制权限的，因为局部成员只在其所在的作用域内起作用，不可能被其他类访问。如果在程序中对局部成员使用访问控制权限修饰符，编译器会报错，错误示例代码如下：
public class Test{
void cc(){
public int aa;
protected boolean bb;
System.out.println("包访问权限");
}
}
注3
封装性
为什么要封装
在java面向对象的思想中，封装是指将类的实现细节包装，隐藏起来的方法。防止本类的代码和数据被外部类定义的代码随机访问。
如何实现封装
在定义一个类时，将类中的属性私有化，即使用private关键字修饰类我的属性。如果外界要访问私有属性，需要提供一些使用public修饰的公有方法，获取属性值的getXXX()方法和设置属性值的setXXX()方法。
package com.se;
class student{
private String name;
private int age;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public void setAge(int age){
if(age<0)
System.out.println("您输入的年龄有误！");
else
this.age=age;
}
public void read(){
System.out.println("大家好，我是"+name+",年龄"+age);
}
}
public class test2 {
public static void main(String[] args) {
student stu=new student();
stu.setName("张三");
stu.setAge(-18);
stu.read();
}
}
构造方法
实例化一个对象后，如果要为这个对象中的属性赋值，则必须直接访问对象的属性或调用setter方法。如果要在实例化这个对象的同时为这个对象的属性赋值，可以通过构造方法实现。构造方法是类的一个特殊成员方法，在类实例化对象时自动调用。
定义构造方法
1.构造方法的名称必须与类名一致
2.构造方法名称前不能有任何返回值类型的声明
3.不能在构造方法中使用return返回一个值，但可以单独写return语句作为方法的结束
public student1(){
System.out.println("调用无参的构造方法");
}
}
public class test3 {
public static void main(String[] args) {
System.out.println("声明对象...");
student1 stu=null;
System.out.println("实例化对象...");
stu=new student1();
}
}
在一个类中除了可以定义无参构造方法外，还可以定义有参构造方法，通过
有参构造方法可以实现对属性的赋值。
class student3{
private String name;
private int age;
public student3(String n,int a){
name=n;
age=a;
System.out.println("调用了有参构造方法");
}
public void read(){
System.out.println("我是:"+name+",年龄:"+age);
}
}
public class test4 {
public static void main(String[] args) {
student3 stu=new student3("张三",18);
stu.read();
}
}
构造方法的重载
在一个类中可以定义多个构造方法，但是要求每个构造方法的参数类型或参数个数不同。在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。
class student4{
private String name;
private int age;
public student4(){};
public student4(String n){
name=n;
System.out.println("调用了一个参数的构造方法");
}
public student4(String n,int a) {
name = n;
age = a;
System.out.println("调用了两个参数的构造方法");
}
public void read(){
System.out.println("我是:"+name+",年龄:"+age);
}
}
public class test5{
public static void main(String[] args) {
student4 stu1=new student4("张三");
student4 stu2=new student4("张三",18);
stu1.read();
stu2.read();
}
}
默认构造方法;
在java中的每个类都至少有一个构造方法。如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，这个默认的构造方法没有参数，方法体中没有任何代码，所以java中默认的构造方法在程序运行时什么也不做。
class student{
}
class student{
public student(){
}
}
对于第一种方法，类中虽然没有声明构造方法，但仍然可以用new student()语句创建Student类的实例对象，在实例化对象时调用默认构造方法。
一旦类定义了构造方法，系统就不在提供默认的构造方法了。
this关键字
当成员变量和局部变量发生重名问题时，需要用this关键字分辨成员变量和局部变量。
this关键字作用：
this关键字调用本类中的属性。
this调用成员方法。
this关键字调用构造方法。
使用this关键字调用本类中的属性
class student5{
private String name;
private int age;
public student5(String name,int age){
name=name;
age=age;
}
public String read(){
return"我是:"+name+",年龄:"+age;
}
}
public class test6 {
public static void main(String[] args) {
student5 stu=new student5("张三",18);
System.out.println(stu.read());
}
}
构造方法中的赋值并没有成功，这是因为构造方法参数名称与对象成员变量名称相同，编译器无法确定哪个名称是当前对象的属性。
public student5(String name,int age){
this.name=name;
this.age=age;
}
使用this关键字，进行赋值操作时不会产生歧义
使用this关键字调用成员方法
class student{
public void openMouth(){
...
}
public void read(){
this.openMouth();
}
}
this调用成员方法，此处关键字this可写可不写。
使用this关键字调用构造方法
构造方法在实例化对象时被java虚拟机自动调用。在程序中不能像调用其他成员方法一样调用构造方法，但可以在一个构造方法中使用"this(参数1，参数2)"的形式调用其他的构造方法。
class student6{
private String name;
private int age;
public student6(){
System.out.println("调用了无参的构造方法");
}
public student6(String name,int age){
this();
this.name=name;
this.age=age;
}
public String read(){
return"我是:"+name+",年龄:"+age;
}
}
public class test7 {
public static void main(String[] args) {
student6 stu=new student6("张三",18);
System.out.println(stu.read());
}
}
使用this调用类的构造方法时，应注意以下三点：
只能在构造方法中使用this调用其他的构造方法，不能在成员方法中通过this调用 构造方法。
在构造方法中，使用this调用其他构造方法的语句必须位于第一行，且只能
出现一次。
不能在一个类的两个构造方法中使用this互相调用。
代码块
普通代码块
public class test8 {
public static void main(String[] args) {
{
int age=18;
System.out.println("这是普通代码块。age:"+age);
}
int age=30;
System.out.println("age:"+age);
}
}
局部代码块对main()方法进行了“分隔”起限定作用域的作用。
构造块
构造块是直接在类中定义的代码块。
class student8{
String name;
{
System.out.println("我是构造块");
}
public student8(){
System.out.println("我是student类的构造方法");
}
}
public class test9 {
public static void main(String[] args) {
student8 stu1=new student8();
student8 stu2=new student8();
}
在实例化student类对象stu1,stu2时，构造块先于构造方法执行（这里和构造块写在前面还是后面没有关系）。
每当实例化一个student类对象时，都会在执行构造方法之前执行构造块。
static关键字
静态属性
static用来修饰类的成员，使用static修饰的属性为静态属性，静态属性可以使用类名直接访问。
class student10{
String name;
int age;
static String school="A大学";
public student10(String name,int age){
this.name=name;
this.age=age;
}
public void info(){
System.out.println("姓名:"+this.name+",年龄:"+this.age+",学校:"+school);
}
}
public class test10 {
public static void main(String[] args) {
student10 stu1=new student10("张三",18);
student10 stu2=new student10("李四",19);
student10 stu3=new student10("王五",20);
stu1.info();
stu2.info();
stu3.info();
stu1.school="B大学";
System.out.println("修改stu1学生对象为B大学后");
stu1.info();
stu2.info();
stu3.info();
}
}
static关键字修饰school属性,将其变成公共属性。这样，school属性只被分配一块内存空间，被Student类的所有对象共享。
static不能修饰局部变量，否则编译器会报错。例如，下面的代码是非法的。
public class student(){
public void study(){
static int num=10;
}
}
静态方法
如果想要使用类中的成员方法，就需要先将这个类实例化。而在实际开发时，开发人员希望在不创建对象的情况下，通过类名就可以直接调用某个方法，这时就需要使用静态方法。
class student11{
private String name;
private int age;
private static String school="A大学";
public student11(String name,int age){
this.name=name;
this.age=age;
}
public void info(){
System.out.println("姓名:"+this.name+"年龄:"+this.age+",学校:"+school);
}
public static String getSchool(){
return school;
}
public static void setSchool(String s){
school=s;
}
}
public class test11 {
public static void main(String[] args) {
student11 stu1=new student11("张三",18);
student11 stu2=new student11("李四",19);
student11 stu3=new student11("王五",20);
System.out.println("------修改前-------");
stu1.info();
stu2.info();
stu3.info();
System.out.println("------修改后-------");
student11.setSchool("B大学");
stu1.info();
stu2.info();
stu3.info();
}
}
静态方法只能访问静态成员。非静态成员需要先创建对象才能访问，即随着对象的创建，非静态成员才会分配内存。而静态方法在被调用时可以不创建任何对象。
静态代码块
static关键字修饰的代码块称为静态代码块，当类被加载时，静态代码块就就会被执行，由于类只加载一次，所以静态代码块只执行一次。通常使用静态代码块对类的成员变量就行初始化。
class student12{
String name;
{
System.out.println("我是构造代码块");
}
static{
System.out.println("我是静态代码块");
}
public student12(){
System.out.println("我是student类中的构造方法");
}
}
public class test12 {
public static void main(String[] args) {
student12 stu1=new student12();
student12 stu2=new student12();
student12 stu3=new student12();
}
}
代码块的执行顺序为静态代码块——构造代码块——构造方法。static修饰的代码块会随着class文件一同被加载，属于优先级最高的代码块。静态代码块在类第一次使用时才会被加载，并且只被加载一次。
2997
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
