Java第二周小结（下）

目录

1.排序问题

      选择排序

冒泡排序

2.类和对象

1.从生活的角度去理解面向过程和面向对象思想

2.面向对象的重要的概念

3.声明一个类的语法格式

创建对象

创建类和带有main主函数的类可以写在一个文件中

3.构造方法

无参构造方法

有参构造方法

4.构造代码块【开发不用】

5.成员变量和局部变量

局部变量

成员变量

6.封装【重点】

---

1.排序问题

      选择排序

原理： 找到最小值的索引 ， 然后和第一个数据进行交换。。再除了第一个的剩余的数据的最小值索引

然后和第二个数据进行交换。以此类推即可

int[] = {4,3 ,2,1}

先遍历一遍 找到 最小值的索引 3 然后交换位置 ｛1， 3， 2， 4｝

再遍历一遍（除了第一个数） 找最小值的索引 2 然后交换位置 {1, 2, 3,4}

再遍历一遍（除了第前两个数） 找最小值的索引 {1, 2, 3,4}

package com.qf.test;

import java.util.Arrays;

public class Demo16 {
	public static void main(String[] args) {
		
		//选择排序
		int[] arr = {4, 3, 2, 1};
		/**
		 * i=0  0<3  minIndex=0  进入内层的for循环
		 * 		j=1 1<4  true if arr[0]>arr[1] 4>3 true  minIndex=1   j++
		 * 		j=2 2<4 true  if arr[1]>arr[2] 3>2 true minIndex=2  j++
		 * 		j=3 3<4 true if arr[2]>arr[3] 2>1 true  minIndex=3 j++
		 * 		j=4 4<4 false 内层循环结束
		 * 		//交换位置
		 * 		int temp = 4   arr[0] = arr[3]  ==>{1,3,2,1}
		 * 		arr[3] = 4====>{1,3,2,4} i++
		 * i=1 1<3  minIndex = 1 进入内层的for循环
		 * 		j=2 2<4 true if arr[1] >arr[2] 3>2 true  minIndex = 2 j++
		 * \	j=3 3<4 true  if arr[2] >arr[3] 2>4 false   minIndex = 2  j++
		 * 		j=4 4<4 false 内层循环结束
		 * //交换位置
		 * 		int temp = 3  arr[1]=arr[2] ==>{1,2,2,4}
		 * 		arr[2] = 3   ===>{1,2,3,4} i++
		 * i= 2  2<3 
		 * 		
		 * 		
		 */
		for (int i = 0; i < arr.length - 1; i++) {//控制轮数
			int minIndex = i;//最小值的索引的变量
			for (int j = i + 1; j < arr.length; j++) {//遍历按数据比较大小然后取 最小值的索引
				if (arr[minIndex] > arr[j]) {
					minIndex = j;
				}
			}
			//交换位置
			int temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = temp;
			
			
		}
		System.out.println(Arrays.toString(arr));
	}
}

冒泡排序

从小到大进行排序

原理： 比较两个相邻的元素的大小，如果左边比右边大，就交换位置。每一对都要比较

int[] arr = {1, 5, 2,3};

第一轮: for

{1, 5,2,3} 比较1和5

｛1,2,5,3｝比较5和2

｛1,2,3,5｝比较的是5和3

第二轮:

{1,2,3,5} 比较 1和2

{1,2,3,5} 比较2 和3

第三轮：

{1,2,3,5} 比较1和2

package com.qf.test;

import java.util.Arrays;

public class Demo17 {
	public static void main(String[] args) {
		
		int[] arr = {1,5, 3, 2};
		for (int i = 0; i < arr.length - 1; i++) {//轮数
			for (int j = 0; j < arr.length - i - 1; j++) {
				//两两比较，然后如果左边比右边大的话，就交换位置
				if (arr[j] > arr[j + 1]) {
					//交换位置
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));
	}
}

2.类和对象

1.类和对象

2.类和对象的内存分析【难点】

3.构造方法

1.从生活的角度去理解面向过程和面向对象思想

是两种编程思想：

Java 纯面向对象的 Arrays.sort(arr)

C 面向过程的 昨天的冒泡排序

面向过程: 亲力亲为

面向对象: 找一个对象然后让对象做一些事情，不用管中间是怎么操作的，然后只需要看结果

2.面向对象的重要的概念

类: 是一切具有相似事物的统称。是泛泛的概念。 可以描述一类事物的特征和行为

对象:是类的具体的实体，是类衍生出来的。有类才有对象

特征:  就是一类事物的属性 ， 比如 人类的  名字   年龄   身高  体重...
        他们是静的东西  在Java中使用变量来表示  一类事物的特征
行为:  就是动作 
        他们是动的东西  在Java中使用 方法来表示  一类事物的行为
        
一个类是由特征（变量）和行为（方法）组成
    一个类准确来说暂时由变量和方法组成的
    
    人类：
        特征:Java中用变量
            名字
            年龄
            身高
            体重
            
            
        行为:  Java中方法
            吃饭 
            睡觉

3.声明一个类的语法格式

public  class 类 {
        特征（Java中的变量）
        行为(java 中暂时不带static的方法)
}

package com.qf.test;

/**
 * 
 * @author bowang
 * 人类:
 * 		特征：Java使用变量    以后我叫属性
 * 			名字
 * 			年龄
 * 			身高
 * 		
 * 			
 *		行为: Java中使用方法来表示
 *			吃饭
 *			睡觉
 */
public class Person {
		//特征:
		//类中的变量不要赋值
		String name;//默认的值  null
		int age;//默认值是0
		double height;//默认值是0.0
		
		
		//行为：
		//Java中的方法来表示
		//在类中暂时不要加static
		public  void eat () {
			System.out.println("能吃饭");
		}
		public void sleep () {
			System.out.println("站着睡");
		}
		
		
		//以上就是声明好的一个类

}

创建对象

一个类声明好以后，不用它 的话，他就一直存在，但是得用这个类，可以使用类衍生出来对象

通过类创建对象。官方术语： 实例化对象

对象存在的目的: 对属性进行赋值，对方法调用

1.先有类才能有对象

2.对象的创建必须在main主函数中

对象创建的语法格式:

类  对象的名字= new  类();

package com.qf.test;

//测试类  带有main主函数的
public class Demo1 {
	public static void main(String[] args) {
		//创建对象必须在main主函数中创建
		//类  对象的名字 = new 类();  想创建人类的对象
		Person  person1 = new Person();//person1  具体的对象  人
		//person1 是Person类衍生出来的 
		//person1对象的特征和行为要参考Person类
		
		//person1的 名字 为  狗蛋
		person1.name = "狗蛋";//对对象中的属性进行赋值
		person1.age = 12;
		person1.height = 167;
		//以上对对象进行赋值
		
		//以下在打印数据
		System.out.println("person1这个对象的名字为:"+person1.name);
		System.out.println("person1这个对象的年龄为:"+person1.age);
		System.out.println("person1这个对象的身高为:"+person1.height);
		
		//类中有方法， 咱们可以使用 对象.方法的名字来调用方法
		person1.eat();
		person1.sleep();
		
		//通过类去创建一个对象，然后对对象的属性进行赋值，对对象的方法进行调用
		
	}
}

创建类和带有main主函数的类可以写在一个文件中

现在写的额类和带有main主函数 不在同一个文件中，分开写的

但是也可以写在用一个Java文件中。新建的文件的名字应该是 测试类类名

package com.qf.test;


//当一个文件中有两个类的时候 ，只能有一个public 来修饰类
//The public type Pig must be defined in its own file
class Pig {
	String name;//名字属性
	double price;//猪肉的价格
	String color;//猪肉的颜色
	
	//行为
	public  void  upTree() {
		System.out.println("猪能上树");
	}
	
}



public class Demo3 {
	public static void main(String[] args) {
		//创建对象
		Pig pig1 = new Pig();
		pig1.name = "佩琪";
		pig1.price = 18.9;
		pig1.color = "pink";
		
		System.out.println("pig1的名字:" + pig1.name);
		System.out.println("pig1的价格:" + pig1.price);
		System.out.println("pig1的颜色:" + pig1.color);
		
		
		pig1.upTree();
		
	
	}
	
}

3.构造方法

1.构造方法是用来初始化对象的（和创建对象有关的！！！）

2.构造方法必须写在实体类中 不是带有main主函数的类中

写在类似于 Person类 Dog类中

无参构造方法

语法格式：

public  类名 () {
    语句体
}

package com.qf.test;

class People {
	//属性
	String name;
	int age;
	
	//定义一个无参构造方法
	public People () {
		System.out.println("嘻嘻");
		//this  当前对象
		name = "狗蛋";
		age = 12;
	}
}

public class Demo4 {
	public static void main(String[] args) {
		//依靠构造方法去创建 对象
		People people = new People();
		
		
		people.name = "二狗";
		people.age = 22;
		System.out.println(people.name);//
		System.out.println(people.age);//
		
		People people2 = new People();
	}
}

有参构造方法

语法格式:

public 类名 (参数) {

}

package com.qf.test;

class Cat {
	String name;
	int age;
	char sex;
	
	
	
	
	//一旦在类中写了有参构造方法，默认无参构造方法就不在了
	//有参构造方法 是特殊的方法
	public  Cat (String name, int age, char sex) {
		//this 代表是当前对象  
		//this.name  当前对象的name属性
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	
	
	
}
public class Demo6 {
	public static void main(String[] args) {
		//创建对象和构造方法有关系，  new Cat();  依靠类中无参构造方法
		Cat cat = new Cat("二虎", 1, '公');
		
		cat.name = "二牛";
		cat.age = 12;
		cat.sex = '母';
		System.out.println(cat.name);//
		System.out.println(cat.age);//
		System.out.println(cat.sex);//
		
	}
}

4.构造代码块【开发不用】

现在开发不用了，以后会讲一个叫静态代码块的

构造代码块的目的:也是可以对对象的属性进行赋值。功能是和构造方法是一样的

语法格式：

{
    语句体
}

1.写在实体类中

2.只要实例化一个对象 以后，就会先执行构造代码块，然后再执行构造方法

package com.qf.test;

class Dog {

	String name;
	int age;

	// 构造代码块
	{
		System.out.println("嘻嘻");
		this.name = "佩琪";
		this.age = 12;
	}

	// 无参构造方法
	public Dog() {
		this.name = "乔治";
		this.age = 10;
	}
	//有参的构造方法
	public Dog (String name, int age) {
		this.name = name;
		this.age = age;
	}
	

}

public class Demo2 {
	public static void main(String[] args) {
		// 只要实例化一个对象 以后，就会先执行构造代码块，然后再执行构造方法
		Dog dog = new Dog();
		System.out.println(dog.name);
		System.out.println(dog.age);
		
		Dog dog1 = new Dog("老八", 28);
		System.out.println(dog1.name);
		System.out.println(dog1.age);
	}
}

5.成员变量和局部变量

局部变量

变量的作用域的问题， 方法a中一个变量，能不能再方法b中使用？ 不能

package com.qf.test;

public class Demo3 {
	public static void main(String[] args) {
		//int i = 20;
		for (int i = 0; i < args.length; i++) {//int i = 0;  局部变量
			System.out.println(i);
			for (int j = 0; j < args.length; j++) {//{}是作用域
				
			}
			for (int j = 0; j < args.length; j++) {
				
			}
		}
		//System.out.println(i);
	}
	
	public  static void test () {//
		int i = 10;
		int a;//先声明变量 没有赋值的
		System.out.println(i);
		//System.out.println(a);//局部变量在使用的时候要赋值的
	}
	public  static void test1 () {
		int i = 10;
		System.out.println(i);
	}
	
}

成员变量

定义在实体类中的大括号的里面，也叫属性

package com.qf.test;

class Person1 {
	
	//属性====》 成员变量  作用域是 整个类都可以使用的
	String name;
	int age;
	public Person1() {
		System.out.println(name);//null   成员变量可以先不赋值，提供一个默认值
	}
	
	public void test () {
		System.out.println(age);//0
	}
	
	
}
public class Demo4 {
	public static void main(String[] args) {
		Person1 person1 = new Person1();
		person1.test();
		
	}
}

成员变量和局部变量区别

区别	成员变量	局部变量
定位位置	类的大括号的后面 也叫属性	定义在方法体中
作用	描述一个类的属性或者特征的	在方法体中保存变量的值的
初始化的值	有默认的初始值String=>null int ==>0	没有默认的值使用的时候一定要赋值
作用域	作用整个类	只能在当前方法中使用

6.封装【重点】

Java是面向对象的三大特征 ，就是把对象的属性和操作（服务） 结合起来变成一个整体，并尽可能的去隐藏内部的信息

Java封装 对属性的封装， 对方法的封装 ， 对类的封装

今天主要讲属性的封装：

之前写的属性 String name; int age;。只需要通过对象.name 赋值和取值即可，这样的话存在一定隐患的。

现在咱们对属性进行封装:

1.为每个属性加上一个修饰符 private (私有的)

2.在实体类中，书写相对应的set方法和get方法 进行操作

package com.qf.test;


class People {
	//对象属性进行封装  加private关键字
	private String name;
	private int age;
	
	//借助于set（设置）方法对属性进行赋值
	//有一定规则的：  set方法 （设置值的时候） 没有返回值的  void
	//setName  为啥叫？setName    set+ 变量的名字 作为咱们方法的名字 采用小驼峰的命名规则
	public void  setName (String name) {//此时 name = "黑蛋儿"
		this.name = name;// this.name = "黑蛋儿";
	}
	//借助于get（得到）方法对属性进行取值  得有返回值的
	public String getName () {
		return this.name;
	}
	
	public void setAge (int age) {
		this.age = age;
	}
	
	public int getAge () {
		return age;
	}
	
	
	
	
}
public class Demo5 {
	public static void main(String[] args) {
		People people = new People();
		//结果发现报错了   私有的变量只能在本类中使用，出了这个类无法使用  咋办？
	
		people.setName("黑蛋儿");//会赋值给 第12行的方法的形参name
		//以上代码已经将"黑蛋儿"  赋值给对象的name
		people.setAge(18);
		//取值
		System.out.println("people的名字为:"+people.getName());
		System.out.println("people的年龄为:"+people.getAge());
	}
}

set方法和get方法可以使用快捷键

package com.qf.test;


class Teacher {
	private String name;//名字
	private int age;//年龄
	private char sex;//性别
	private double salary;//月薪
	private double height;//身高
	private double weight;//体重
	
	
	 //快捷键  右键-》source->Generate Getters and Setters...
	
	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 char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	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;
	}
	
	
}
public class Demo7 {
	public static void main(String[] args) {
		Teacher teacher = new Teacher();
		teacher.setName("骚磊");
		System.out.println(teacher.getName());
	}
}