第六章总结

丑丑又哪错了啊啊啊

已于 2023-04-04 15:40:31 修改

阅读量84

点赞数

文章标签： java 开发语言

于 2023-03-30 16:41:02 首次发布

本文链接：https://blog.csdn.net/cc3993/article/details/129689169

版权

一、面向对象

1、对象

世界万物皆对象，对象分为两个部分，即静态部分与动态对象部分

静态部分：就是不能动的部分，称为“属性”

动态部分：即对象可执行的动作，称为“行为”

2、类

类就是对象的设计图，是同一类事物的统称，如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称。类是封装对象的属性和行为的载体，也就是说，具有相同属性和行为的一类实体被称为类。

3、封装

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类

就是把对像的属性隐藏在对象内部，不允许外部对象直接访问内部信息

4、继承

继承性主要利用特定对象之间的共有属性，一个类处于继承体系中，它既可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类，继承父类的属性和方法。

特点：

1、子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法，子类是无法访问的，只是拥有

2、子类可以拥有自己属性和方法，子类可以对父类进行扩展

5、多态

表示一个对象多种形态，将父类对象应用于子类的特征就是多态

特点：

1、降低了维护的难度，节省了时间

2、多态不能调用只能子类存在但在父类不存在的方法

3、方法具有多态性，属性不具有

二、类

1、成员变量

对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围

public class lei {//类
	private String name;//String类型的成员变量
	public String getName() {//name的Getter方法
		return name;
	}
	public void setName(String name) {//name的Setter方法
		this.name=name;//将参数值赋予类中的成员变量
	}
}

2、成员方法

使用成员方法对应于类对象，包含getter和setter两种方法

语法：

权限修饰符返回值方法名（参数类型，参数名）{

... //方法体

return 返回值；}

getter和setter方法自动生成

传入参数的构造方法自动生成

3、权限修饰符

4、局部变量

在成员方法内定义一个变量，这个变量被称为局部变量。

局部变量是在方法被执行时创建，在方法执行结束时被销毁，局部变量在使用时必须进行赋值或被初始化，否则会出现编译错误

public class lei {
	public static int[]exchange(int[]arr){
		int tmp=arr[0];//创建局部变量tmp，保存数组第一个元素的值
		arr[0]=arr[1];//第二个元素赋值给第一个元素
		arr[1]=tmp;//第二个元素值改为tmp
		return arr;
	}
	public static void main(String[]args) {//定义主方法
		int arr[]= {17,29};//定义两个值
		System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
		arr=exchange(arr);//交换两个元素的值
		System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
	}
}

5、局部变量的有效范围

局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止

6、this关键字

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类，thia关键字只能在本类中使用，也就是说this是自身的一个对象，代表对象本身

"this ."是这个类的意思，可以调用成员变量和成员方法


public void setName(String name) {//定义一个setName()方法
		this.name=name;//将参数值赋予类中的成员变量
	}
	}

三、类的构造方法

构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的，每当类实列化一个对象时，类都会自动调用构造方法

特点：

1、构造方法没有返回值

2、构造方法的名称要与本类的名称相同

3、生成类的对象时自动执行，无需调用

语法：

public Book(){

... //构造方法体

}

public ：构造方法修饰符；Book：构造方法的名称

public class lei {
	int eggCount;//鸡蛋饼里蛋的个数
	public lei(int eggCount) {//参数为鸡蛋灌饼里蛋的个数的构造方法
		this.eggCount=eggCount;//将参数eggCount的值付给属性eggcount
	}
	public lei() {//无参数构造方法，默认给饼里加一个蛋
		//调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1
		this(1);
		}
	public static void main(String[]args) {//定义主方法
		lei lei1=new lei();
		System.out.println("顾客不要求加蛋的数量，饼里会有"+lei1.eggCount+"个蛋。");
		lei lei2=new lei(2);
		System.out.println("顾客要求加两个蛋，饼里会有"+lei2.eggCount+"个蛋。");
	}
	
}

四、静态变量和静态方法

由static修饰的变量和方法被称为静态变量和静态方法，被声明为static的变量和方法被称为静态成员，静态成员归类所有，区别于个别对象，可以在本类或其他类使用类名和 “ . ” 运用符调用静态成员

语法：类名.静态类成员

public class lei {//类名
	static int count=0;//定义共享的属性、人数
	String name;//名称属性
	public lei(String name) {
		this.name=name;//记录名称
		count++;//将人数递增
		
	}
	public static void main(String[]args) {
		lei c1=new lei("tom");
		System.out.println("我是第"+lei.count+"名顾客，我叫"+c1.name);//输出
		lei c2=new lei("张三");
		System.out.println("我是第"+lei.count+"名顾客，我叫"+c2.name);//输出
		lei c3=new lei("狗蛋儿");
		System.out.println("我是第"+lei.count+"名顾客，我叫"+c3.name);//输出
	}
}

static修饰只要有类名就可以使用，没有对象也可以使用

public class lei {
	static double PI=3.1415926;//静态变量  
	static final int i=3;//静态常量   
	static void method() {//静态方法   
		System.out.println("静态方法");
	}
	static {//静态代码块
		//1
		//2
		//3
	}
	public static void main(String[]args) {//定义主方法
		System.out.println(lei.PI);//调用静态变量
		System.out.println(lei.i);//调用静态变量
		lei.method();//调用静态方法
	}
}

其中ststic(静态)修饰加了static就是静态的 final（最终的）常量

特点：

1、静态方法只能访问静态成员

2、静态方法中不能使用this关键字

五、类的主方法

语法：

public static void main (String [] args){

//方法体

}

在主方法的定义中可以看到其具有以下特点：

主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。
主方法没有返回值。
主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数

String[]args的使用方法和作用

public class lei {
	public static void main(String[]args) {//定义主方法
		for(int i=0;i<args.length;i++) {//根据参数个数做循环操作
			System.out.println(args[i]);//循环打印参数内容
		}
	}
	
}

运行代码前，先要在Eclipse中设置运行参数，步骤如下:
在Eclipse 中MainDemjava件上单击鼠标右键，在弹出的快捷菜单中选择“运行方式”/“运行配置”(文版为RunAs/Run Configrations)，弹出“运行配置”(Run Configrations)对话框
(2)在“运行配置”对话框中选择“自变量”(Arguments)选项卡，在“项目”(Program arguments)文本框中输入相应的参数，每个参数间按Enter键隔开。
(3)单击“运行”按钮，查看控制台运行结果
如果不按照以上步骤操作，直接运行源码，则不会输出任何结果。

六、对象

1、对象的创建

对象可以认为是在一类事物中抽象出某一个特列，可以通过这个特例来处理这类事物出现的问题，在Java语言中通过new操作符来创建对象

语法：

Test test=new Test();

Test test=new Test("a");

Test(类名） test（创建Test类对象）new（创建对象操作符）“a”构造方法的参数

test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了储存空间，可以在构造方法中初始化成因常量，当创建对象时自动调用构造方法，也就是说在Java语言中初始化与创建是被捆绑在一起的

每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成垃圾，由Java虚拟机自带的垃圾回收机制处理，不能再被使用

public class People {
    //成员变量
    private String name;//姓名
    private int age;//年龄
    private String sex;//性别
    private double height;//身高
    private double weight;//体重
    //对外提供 getter 和 setter 方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public double getHeight() {
        return height;
    }
    public void setHeight(double height) {
        this.height = height;
    }
    public double getWeight() {
        return weight;
    }
    public void setWeight(double weight) {
        this.weight = weight;
    }
//成员方法
//写代码 方法名：code 传入参数 语言 返回参数:"某某某正在写代码"
    public String code (String language) {
        return name + "正在写"+ language + "代码";
    }
    
    //做个人介绍 方法名：introduce 传入参数为空
    //返回参数：“某某某年龄X，性别X，身高X，体重X”
    public String introduce () {
        return name + "年龄" + age + ",性别" + sex +",身高" + height + ",体重" + weight ;
    }
    
    //查询BMI指数 方法名：getBMI 传入参数为空 返回参数：BMI指数
    //BMI指数 = 体重/(身高*身高)
    public double getBMI() {
        return weight/(height*height);
    }
    
    //构造方法 无参数
    public  People() {
        
    }
    
    //构造方法 传入参数：姓名，年龄，性别
    public  People(String name,int age, String sex) {
        this.name =name;
        this.age = age;
        this.sex = sex;    
    }
    
    //构造方法 传入参数：姓名，年龄，性别，身高，体重
    public People(String name, int age, String sex, double height, double weight) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.weight = weight;
    }
    
    
    
    
}

2、访问对象的属性和行为

用户使用new操作服创建一个对象后，可以使用对象点类成员来获取对象的属性和行为，对象的属性和行为在类中是通过类的成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应的获取了对象的属性和行为

3、对象的引用

在Java语言中，尽管一切都可以看作对象，但真正的操作标识符实质上是一个引用

语法：

类名对象的引用变量

例如：一个People类引用可以使用以下代码

People tom；

通常一个引用不一定需要有一个对象相关联，引用与对象相关的语法如下

People tom=new People();

People (类名） tom（引用）new People()（对象的实体）

4、对象的销毁

每个对象都有生命周期，当对象的生命周期结束时分配给给该对象的内存地址需要被收回， Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存垃圾回收器会自动收回无用且占用内存的资源

对象被被Java虚拟机视为“垃圾”主要包括两种情况

a、对象引用超过其作用范围，这个对象将被视为垃圾

b、将对象赋值为null（对象被制为NLP，值时将消亡）

虽然Java的垃圾回收机制已经很完善，但垃圾回收器只能回收那些由n1w操作服创建的对象。由于垃圾回收不受人为控制，具体执行时间也不确定，所以 finalize()方法也就无法执行

课后作业：

public class Parent {
	//变量
	String xing;
	String ming;
	String se;
	String jiao;
	//get   set
	public String getXing() {
		return xing;
	}
	public void setXing(String xing) {
		this.xing = xing;
	}
	public String getMing() {
		return ming;
	}
	public void setMing(String ming) {
		this.ming = ming;
	}
	public String getSe() {
		return se;
	}
	public void setSe(String se) {
		this.se = se;
	}
	public String getJiao() {
		return jiao;
	}
	public void setJiao(String jiao) {
		this.jiao = jiao;
	}
	
	//方法
	public String introduce() {
		return xing+"狗"+ming+"是"+se+"的";
	}
	public String bark() {
		return xing+"狗"+ming+"正在"+jiao+"叫";
		
	}
	//构造方法
	public Parent()
	{
		
	}
	public Parent(String xing, String ming, String se) {
		super();
		this.xing = xing;
		this.ming = ming;
		this.se = se;
	}
	public Parent(String xing, String ming, String se, String jiao) {
		super();
		this.xing = xing;
		this.ming = ming;
		this.se = se;
		this.jiao = jiao;
	}
	
	
}

public class Child {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用有三个参数的构造方法新建对象
		Parent rw1=new Parent("公","小花","黑色");
        //调用并打印introduce
		String introduce=rw1.introduce();
		System.out.println(introduce);
        //使用有四个参数的构造方法新建对象
		Parent rw2=new Parent("母","小黑","花色","汪汪汪");
        //调用并打印 bark
		String bark=rw2.bark();
		System.out.println(bark);
		}
 
}