day7 java基础（面向对象）

---------------------------------------------知识点1-----------------------------------------------------
/*
形式参数的问题：
基本类型：形式参数的改变不影响实际参数 int float String boolean byte 等
引用类型：形式参数的改变直接影响实际参数 数组 接口 类
*/
// 形式参数是基本类型
class Demo{
public int sum(int a ,int b){
return a+b;
}

}
// 形式参数是引用类型
class Student{
public void show(){
System.out.println(“我爱学习”);
}

}

class StudentDemo{
// 如果方法的形式参数是类类型（引用类型），这里需要的是该类的一个对象
public void method(Student s){
s.show();
}

}

class ArgsTest{
public static void main(String [] args){
// 创建对象
Demo a = new Demo();
System.out.println(a.sum(10,20));
System.out.println("---------------");
// 需求是调动StudentDemo中的method方法
StudentDemo b = new StudentDemo();
// 类参数对象创建
Student c = new Student();
b.method©; // 相当于把c的地址给到了这里
}

}
---------------------------------------------知识点2-----------------------------------------------------
/*
成员变量和局部变量的区别：
1.在类中的位置不同
成员变量：在类中方法外
局部变量： 在方法中或者在方法声明上
2.在内存中的位置不同
成员变量：在堆内存
局部变量：栈内存
3.生命周期不同
成员变量：随着对象的创建而存在，随对象消失而消亡
局部变量：随着方法调用而存在，方法调用结束而消亡
4.初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义初始化才能使用

	注意事项：
	    局部变量的名称可以和成员变量一样，在方法使用时，采用就近原则

*/
class Variable{
//成员变量
int num ; // 0

public void show (){
	int num2=10 ;  // 局部变量
	System.out.println(num2);
}

}

class VariableDemo{
public static void main(String [] args){
Variable v = new Variable();
System.out.println(v.num);
v.show();
}

}
---------------------------------------------知识点3-----------------------------------------------------
/*
形式参数的问题：
基本类型：形式参数的改变不影响实际参数 int float String boolean byte 等
引用类型：形式参数的改变直接影响实际参数 数组 接口 类
*/
// 形式参数是基本类型
class Demo{
public int sum(int a ,int b){
return a+b;
}

}
// 形式参数是引用类型
class Student{
public void show(){
System.out.println(“我爱学习”);
}

}

class StudentDemo{
// 如果方法的形式参数是类类型（引用类型），这里需要的是该类的一个对象
public void method(Student s){
s.show();
}

}

class ArgsTest{
public static void main(String [] args){
// 创建对象
Demo a = new Demo();
System.out.println(a.sum(10,20));
System.out.println("---------------");
// 需求是调动StudentDemo中的method方法
StudentDemo b = new StudentDemo();
// 类参数对象创建
Student c = new Student();
b.method©; // 相当于把c的地址给到了这里
}

}
---------------------------------------------知识点4-----------------------------------------------------
/*
匿名对象：就是没有名字的对象

1.调用方法，仅调用一次的时候。
	注意：调用多次的时候，不合适
	优势：匿名对象调用完就是垃圾，可以被垃圾回收器回收
2.匿名对象可以作为实际参数传递

*/
class Student{
public void show(){
System.out.println(“我爱学习”);
}

}
class StudentDemo{
public void method(Student s){
s.show();
}
}

class NoNameDemo{
public static void main(String []args){
// 带名字的调用
Student s = new Student();
s.show();
s.show();
System.out.println("-------");

// 匿名对象
new Student().show();
new Student().show();
System.out.println("-------");

// 匿名对象作为实际参数使用
StudentDemo a = new  StudentDemo();
a.method(new Student());
System.out.println("-------");

// 改进
new StudentDemo().method(new Student());

}

}
---------------------------------------------知识点5-----------------------------------------------------
/*
private :
是一个权限修饰符
可以修饰成员变量和成员方法
其被修饰的成员只能在本类中使用
*/
class Demo{
// int num =10;
// 用private修饰
private int num =10;
public void show(){
System.out.println(num);
}

private void method(){
	System.out.println("method");
}

public void function(){
	method();
}

}

class PrivateDemo{
public static void main(String [] args){
Demo d = new Demo();
//System.out.println(d.num);
d.show();
d.function();
}

}
---------------------------------------------知识点6-----------------------------------------------------
/*
封装和private的应用
1.把成员变量用private修饰
2.提高对应的getXxx()和setXxx()方法
*/
class Student{
// 定义姓名成员变量
String name;
// 定义年龄
int age;

// 姓名设置值
public void setName(String n){
	name = n;
}
// 姓名的获取
public String getName(){
	return name;
}

// 年龄设置值
public void setAge(int a ){
	age = a;
}
//年龄的获取
public int getAge(){
	return age;
}

}

// 测试类
class privateStudent{
public static void main(String [] args){
// 创建对象
Student s = new Student();
s.setName(“刘亦菲”);
System.out.println(“姓名：”+s.getName()); // 调用的方法s. getName是错误的，少了括号（），犯错多次
s.setAge(20);
System.out.println(“年龄：”+s.getAge());
}

}
---------------------------------------------知识点7-----------------------------------------------------
/*
定义一个学生类：
成员变量： name ，age
成员方法： show() 方法
我们在使用这个案例的过程中，通过对象给成员变量赋值，可以赋值一些非法的数据
这个是不合理的。
在赋值之前，先判断数据的合法性。
StudenDemo类是一个测试类，测试类一般只创建对象，调用和方法
故在Student中，定义一个方法对数据进行校验

private :私有的，可以修饰成员变量和成员方法安
	注意：被private修饰的成员，只能在本类中访问

封装思想。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

*/

class Student{
// 姓名
String name;
// 年龄
private int age;

// 写一个方法对数据进行校验
/*
	返回类型:void
	参数列表：int a
*/
public void setAge(int a ){
	if(a<0|a>120){
		System.out.println("你输入的数据有错误！");
	}
}


//show()方法，显示所有成员变量值
public void show(){
	System.out.println("姓名:"+name);
	System.out.println("年龄:"+age);
}

}
// 测试类
class StudentDemo{
public static void main(String [] agrs){
// 创建对象
Student a = new Student();
a.show();
// 给成员变量赋值
a.name=“刘亦菲”;
a.age=20;
a.show();
// 给age赋值
s.age = -27;
a.show();
}

}
---------------------------------------------知识点8-----------------------------------------------------
/*
作业：请把手机类写成一个标准类，然后创建对象测试功能

手机类：
	成员变量：
		品牌：String brand;
		价格：int price;
		颜色：String color;
	成员方法：
		针对每一个成员变量给出对应的getXxx()和setXxx()方法。
	最后通过定义测试：
		创建一个对象，先通过getXxx()方法输出变量的值。这次的结果是null--0--null
		然后通过setXxx()方法对变量进行赋值，这次的结果是：三星--3699--土豪金

*/

class Phone{
// 定义品牌
private String brand;
//定义价格
private int price;
//定义颜色
private String color;

// 定义成员方法
public void setBrand(String brand){
	this.brand = brand;
}

public void setPrice(int price){
	this.price = price;
}

public void setColor(String color){
	this.color = color;
}

public String getBrand(){
	return brand;
}

public int getPrice(){
	return price;
}

public String getColor(){
	return color;
}

}

// 测试类
class PhoneTest{
public static void main(String [] args){
// 创建对象
Phone s = new Phone();
System.out.println(s.getBrand()+"–"+s.getPrice()+"–"+s.getColor());
// 对成员变量赋值
s.setBrand(“三星”);
s.setPrice(3699);
s.setColor(“土豪金”);
System.out.println(s.getBrand()+"–"+s.getPrice()+"–"+s.getColor());
}

}
---------------------------------------------知识点9-----------------------------------------------------
/*
this关键字：是当前类的对象引用，简单的概述，他就是代表当前类的对象
注意:方法被那个对象调用，就是代表那个对象
this的场景：
解决局部变量隐藏成员变量
*/
class Student{
// 定义姓名成员变量
String name;
// 定义年龄
int age;

// 姓名设置值
public void setName(String name){  
	//name = name;  // 变量就近原则，自己赋值给自己
	//这里只能通过对象调用成员变量
	// java提供了一个关键字this
	this.name = name;
}
// 姓名的获取
public String getName(){
	return name;
}

// 年龄设置值
public void setAge(int age ){
	this.age = age;
}
//年龄的获取
public int getAge(){
	return age;
}

}

// 测试类
class StudentTest{
public static void main(String [] args){
// 创建对象
Student s = new Student();
s.setName(“刘亦菲”);
System.out.println(“姓名：”+s.getName()); // 调用的方法s. getName是错误的，少了括号（），犯错多次
s.setAge(20);
System.out.println(“年龄：”+s.getAge());
}

}
---------------------------------------------知识点10-----------------------------------------------------
/*
标准的代码改进版
*/
class Student{
private String name;
private int age;

public void setName(String name){
	this.name = name;
}
public void setAge(int age){
	this.age  = age;
}
public String getName(){
	return name;
}
public int getAge(){
	return age;
}

}
// 测试类

class StudentTest2{
public static void main(String [] args){
// 创建对象
Student s = new Student();
s.setName(“刘亦菲”);
s.setAge(20);
System.out.println(s.getName()+"————"+s.getAge());
// 创建对象2
Student s1 = new Student();
s1.setName(“林青霞”);
s1.setAge(22);
System.out.println(s1.getName()+"————"+s1.getAge());
}

}
---------------------------------------------知识点11-----------------------------------------------------
/*
构造方法：

*/

class Student{

}

class ConstructDemo{
public static void main(String [] args){
// 创建对象
Student s = new Student();
System.out.println(s);

}

}
---------------------------------------------知识点12-----------------------------------------------------
/*
我们一直在使用构造方法，但是我们没有定义构造方法，用的哪里来的呢？

构造方法的注意事项：
	1.如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
	2.如果我们给出了构造方法，系统将不再提供
注意：我们给出构造函数时，系统将不再给出构造函数，不管我们给出的构造函数是有参还是无参，建议是永远自己给出构造函数。

给成员变量赋值：
	1.setXxx();
	2.构造函数；

*/
class Student{
private String name;
private int age;
public Student(){
System.out.println(“这个是无参构造方法”);
}
// 方法的重载
public Student(String name){
System.out.println(“这个是String参数构造方法”);
this.name = name;
}

public Student(int age){
	System.out.println("这个是int参数造方法");
	this.age = age;
}

public Student(String name,int age){
	System.out.println("这个是String,int参数造方法");
	this.name = name;
	this.age = age;
}

// 定义获取方法
public String getName(){
	return name;
}

public int getAge(){
	return age;
}

}

class ConstructDemo2{
public static void main(String [] args){
// 创建对象
Student s = new Student();
System.out.println(s.getName()+"—"+s.getAge());

// 创建对象2
Student s2 = new Student("李青霞");
System.out.println(s2.getName()+"---"+s2.getAge());

// 创建对象3
Student s3 = new Student(20);
System.out.println(s3.getName()+"---"+s3.getAge());

//创建对象4
Student s4 = new Student("林青霞",20);
System.out.println(s4.getName()+"---"+s4.getAge());
}

}
---------------------------------------------知识点13-----------------------------------------------------
/*
标准的手机类练习

手机类：
	成员变量：brand，price，color
	构造方法：无参构造
	成员方法：getXxx()/setXxx()

*/

class Phone{
// 品牌
private String brand;
//价格
private int price;
// 颜色
private String color;

//无参构造
public Phone(){}

// 成员方法
public void setBrand(String brand){
	this.brand = brand;
}

public String getBrand(){
	return brand;
}

public void setPrice(int price){
	this.price = price;
}

public int getPrice(){
	return price;
}

public void setColor(String color){
	this.color = color;
}

public String getColor(){
	return color;
}

}

class PhoneTest{
public static void main(String [] args){
// 创建对象
Phone p = new Phone();

	p.setBrand ("诺基亚");
	p.setPrice (3000);
	p.setColor ("土豪金");
	
	System.out.println(p.getBrand()+"--"+p.getPrice()+"--"+p.getColor());
	
}

}
---------------------------------------------知识点14-----------------------------------------------------
/*
类的组成：成员变量 成员方法
今天我们又加入了一个新的成员：构造方法
以后再提类的组成：
成员变量
构造方法
成员方法
根据返回值：
void 类型
非void类型
根据参数：
空参方法
非空参方法
*/
class Student{
// 空参方法 非void类型
public String getString(){
return “helloworld”;
}
// 有参方法 void类型
public void method(String name){
System.out.println(name);
}
}
class StudentDemo3{
public static void main(String [] args){
// 创建对象
Student s = new Student();

// 带参数的无返回值
s.method("林青霞");

// 无参数的有返回值
String result = s.getString();
System.out.println(result);


}

}
---------------------------------------------知识点15-----------------------------------------------------
/*
一个标准代码的最终版

学生类：
	成员变量：
		name ，age
	构造方法：
		无参，带两个参
	成员方法：
		getXxx()/setXxx()
		show(); // 输出该类的所有变量值
		
	给成员变量赋值：
		1.setXxx()方法
		2.构造方法
	
	输出成员变量的方式：
		1.通过getXxx()分别获取然后拼接
		2.通过调用show（）方法

*/
class Student{
// 姓名
private String name;
// 年龄
private int age;

// 构造方法
public Student(){

}

public Student(String name,int age){
	this.name = name;
	this.age = age;
}

public void setName(String name){
	this.name = name;
}

public String getName(){
	return name;
}

public void setAge(int age){
	this.age = age;
}

public int getAge(){
	return age;
}

// show方法
public void show(){
	System.out.println(name+"--"+age);
}

}
class StudentTest{
public static void main(String [] args){
// 创建对象1
Student s = new Student();
//System.out.println(s.getName+"—"+s.getAge);
s.show();
// 创建对象2
Student s1 = new Student(“林青霞”,20);
s1.show();
}
}
---------------------------------------------知识点16-----------------------------------------------------
/*
疑问：如果定义成员变量时进行赋值，采用无参构造方法初始化成员变量，是不是
会给出 null和0
*/

class Student{
// 定义成员变量
private String name = “林青霞”;
private int age = 20;

// 无参构造方法
public Student(){
	//name = "陈小康";
	//age = 25;
}

// 成员方法
public String getName(){
	return name;
}

public int getAge(){
	return age;
}

}

class TestDemo{
public static void main(String [] args){
// 创建对象
Student s = new Student();
System.out.println(s.getName()+"–"+s.getAge());
}
}
---------------------------------------------知识点17-----------------------------------------------------
/*
定义一个类Demo，其中定义一个求两个数据和的方法，
定义一个测试类Test,进行测试

变量什么时候定义为成员变量：
	如果这个变量是用来描述类的信息的，该变量就该被定义为成员变量

变量定义在什么范围比较好：
	变量的范围是越小越好，因为能够及时回收。

*/
//方式1
class Demo{

//定义成员方法
public int sum(int a , int b){
	return a+b;
}

}

//方式2
class Demo2{
int a;
int b;
public int sum(){
return a+b;
}

}

class Test{
public static void main(String [] args){
// 创建对象1
Demo s = new Demo();
s.sum(1,2);
System.out.println(s.sum(1,2));
// 创建对象2
Demo2 s2 = new Demo2();
s2.a = 10;
s2.b = 20;
System.out.println(s2.sum());
}
}
---------------------------------------------知识点18-----------------------------------------------------
/*
定义一个长方形的类，定义求周长和面积的方法
然后定义一个测试类Test2，进行测试

长方形的类：
	成员变量：
		长，宽
	成员方法：
		求周长：（长+宽）*2；
		求面积：长*宽
		
	长宽为成员变量，因为代表了长方形类的属性信息

*/
import java.util.Scanner;
class ChangFangXing{
// 定义长度
private int length;
// 定义宽度
private int width;

// 构造方法初始化成员变量
public ChangFangXing(){}

// 定义成员方法
public  void setLength(int length){
	this.length = length;
}

public void setWidth(int width){
	this.width = width;
}

//计算周长方法
public int ZhouChang(){
	return (length+width)*2;
}

// 计算面积方法
public int MianJi(){
	return length*width;
}

}

class Test2{
public static void main(String [] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//接收长方形长度
System.out.println(“请输入长方形的长度：”);
int length = sc.nextInt();
//接收长方形宽度
System.out.println(“请输入长方形的宽度：”);
int width = sc.nextInt();

	// 创建对象
	ChangFangXing c = new ChangFangXing();
	c.setLength(length);
	c.setWidth(width);
	System.out.println("周长："+c.ZhouChang());
	System.out.println("面积："+c.MianJi());
	// 
}

}
---------------------------------------------知识点19-----------------------------------------------------
/*
main方法的格式讲解：
public static void main(String [] args){}

	public :公共的，访问权限最大的。由于main方法是被jvm调用，所以权限要够大。
	static ：静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
	void：因为我们经常说，方法的返回值是返回给调用者，而main方法是jvm调用，你给jvm调用没有意义。
	main：常见的方法入口
	String[] args:这是一个字符串数组，值去哪里
		这个东西早期是用来接收键盘录入的数据
		在命令窗口输入：
			格式为：java MainDemo hello world java

*/

class MainDemo{
public static void main(String [] args){
//System.out.println(args.length); //0
//System.out.println(args);//[Ljava.lang.String;@15db9742 数组地址值
//System.out.println(args[0]);

	// 接收数据后
	System.out.println(args.length); 
	System.out.println(args);
	System.out.println(args[0]);
	
	//遍历数组
	for(int x = 0;x<args.length;x++){
		System.out.print(args[x]+" ");
	}
}

}
---------------------------------------------知识点20-----------------------------------------------------
/*
static 的特点：
1.随着类的加载而加载
2.优先于对象存在
3.被所有对象共享
举例：咱们班级共用一个班级号
如果某个成员变量是所有对象共享的，
那么它可以设置为静态变量
4.可以通过类调用
其实本身也可以通过对象调用
推荐使用类名调用

	静态修饰的内容一般我们称其为：与类相关的，类成员

*/
class Student{
// 非静态调用
int num =10;

//静态变量
static int num2 = 20;

}

class StudentDemo{
public static void main(String [] args){
Student s = new Student();
System.out.println(s.num);

	//通过类名调用
	//System.out.println(Student.num);// 错误: 无法从静态上下文中引用非静态 变量 num
	System.out.println(Student.num2);
	System.out.println(s.num2);
}

}
---------------------------------------------知识点21-----------------------------------------------------
/*
static 关键字的注意事项：
1.在静态方法中没有this关键字的
如何理解呢？
静态是随着类的加载而加载，this是随着对象的创建而存在
静态比对象先存在
2.静态访问只能访问静态变量和静态方法
静态方法：
成员变量:只能访问静态变量
成员方法：可以访问静态方法和静态变量

*/
class Teacher{
int num = 10;
static int num2 = 20;

public void show(){
	System.out.println(num);
	System.out.println(this.num);
}

public void function(){}

public  static void function2(){}

public static void method(){
	// System.out.println(num); // 错误: 无法从静态上下文中引用非静态 变量 num
	System.out.println(num2); 
	
	//function();//错误: 无法从静态上下文中引用非静态 方法 function()
	function2();
}

}

class TeacherDemo{
public static void main(String [] args){
// 创建对象
Teacher s = new Teacher();
s.show();
s.method();
}

}