本篇文章是根据视频学的，来源如下所示：

教程来源：	java基础到高级_零基础自学Java–尚硅谷–宋红康
教程视频地址：	java基础到高级_零基础自学Java--尚硅谷--宋红康_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1ny4y1Y7CW

1.面向对象编程学习的主线

2.理解面向过程与面向对象

3.两个要素:类和对象

4.类的结构:属性和方法

5.类和对象的创建

6.类和对象的创建

7.对类和对象创建的再理解

8.体会类的多个对象的关系

9.对象的内存解析

10.属性与局部变量的对比1

11.属性与局部变量的对比2

12.方法举例与声明的格式

13.方法的声明1

14.方法声明的说明2

15.return关键字的使用

16.方法使用的注意点

17.课后练习1:类的使用

18.课后练习2

19.课后练习3

20.课后练习4

21.每日一考1

22.每日一考2

23.理解"万事万物皆是对象"

24.对象数组的内存解析

25.匿名对象的使用

26.自定义数组的工具类

27.理解方法的重载

28.方法重载的细节说明

29.重载的举例与判断练习

30.重载的练习：编码实践

31.新特性：可变个数形参的方法

32.理解变量的赋值

33.值传递机制：针对基本数据类型

34.值传递机制：针对引用数据类型

35.值传递机制的练习（本节视频建议看两遍）

36.探讨几道网红题

37.参数传递的编码练习

38.递归方法的使用

39.递归方法的举例

40.每日一考

41.封装性的引入

42.封装性的体现

43.四种权限修饰的理解

44.四种权限修饰的测试

45.封装性的练习：基本使用

46.构造器的基本理解

47.构造器使用的细节说明

48.构造器练习：基本使用

49.构造器练习：三角形

50.总结赋值的过程

51.JavaBean的使用

52.介绍UML类图

53.this调用属性和方法

54.this调用构造器

55.this练习：boy和girl

56.综合练习1：Account和Customer

57.综合联系2：对象数组

58.package关键字的使用

59.MVC设计模式的理解

60.import关键字的使用

61.每日一考

1.面向对象编程学习的主线

2.理解面向过程与面向对象

*2.面向对象:强调了具备功能的对象,以类/对象为最小的单位,考虑谁来做.(面向对象比面向过程更加高一些)
 *人
 *{
 *		打开(冰箱)
 *			{
 *				冰箱.开开();
 *				}
 *		抬起(大象)
 *			{
 *				大象.进入(冰箱)
 *				}
 *		关闭(冰箱)
 *			{				
 *				冰箱.关关（）；
 *				}
 *}
 *冰箱
 *{
 *		开开(){}；
 *		关关(){}；
 *}
 *大象
 *{
 *		进入(冰箱)
 *			{}；
 *		}
 *

3.两个要素:类和对象

*三.面向对象的两个要素:
 *类:对一类事物的描述,是抽象的 概念上的定义
 *对象:是实际存在的事物的个体,是实例化的过程
 *>面向对象程序设计的重点是类的设计
 *>设计类就是设计类的成员的过程
 */

4.类的结构:属性和方法

5.类和对象的创建

6.类和对象的创建

package com.atguigu.java;


public class PersonTest {
public static void main(String[] args) {
	//实例化对象
	Person p1 = new Person() ;
	//调用相应的属性与方法
	//调用属性:相应的格式是 对象.属性
	p1.name = "Yang";
	p1.age = 23;
	p1.ismale = true;
	System.out.println(p1.name);
	//调用方法:相应的格式是 对象.方法
	p1.eat();
	p1.sleep();
	p1.talk("Chinese");
}
}
class Person
{
	//属性
	String name;
	int age;
	boolean ismale;
	
	//方法
	public void eat()
	{
		System.out.println("人可以吃饭!");
	}
	public void sleep()
	{
		System.out.println("人可以睡觉呀");
	}
	public void talk(String language)
	{
		System.out.println("说的语言是" + language);
	}
}

7.对类和对象创建的再理解
白马非马问题-------课上引出
本节课只是对类和对象在思想层面上用语言进一步讲解

8.体会类的多个对象的关系

package com.atguigu.java;


public class PersonTest {
public static void main(String[] args) {
	//实例化对象
	Person p1 = new Person() ;
	//调用相应的属性与方法
	//调用属性:相应的格式是 对象.属性
	p1.name = "Yang";
	p1.age = 23;
	p1.ismale = true;
	System.out.println(p1.name);
	//调用方法:相应的格式是 对象.方法
	p1.eat();
	p1.sleep();
	p1.talk("Chinese");
	
	/
public class UserTest {

}
class User
{
	//属性(或成员变量)
	private String name;
	public int age;
	boolean isMale;
	
	public void talk(String language)//language:形参,也是局部变量
	{
		System.out.println("我们使用" + language + "进行交流");
	}
	public void eat()
	{   String food = "马铃薯";
		System.out.println("北方人喜欢吃" + food);
	}

	
}

11.属性与局部变量的对比2

package com.atguigu.java;

public class UserTest {
public static void main(String[] args) {
	User u1 = new User();
	System.out.println(u1.name);
	System.out.println(u1.age);
	System.out.println(u1.isMale);
	u1.talk("日语");
	u1.eat();
}
}
class User
{
	//属性(或成员变量)
	String name;
	public int age;
	boolean isMale;
	
	public void talk(String language)//language:形参,也是局部变量
	{
		System.out.println("我们使用" + language + "进行交流");
	}
	public void eat()
	{   String food = "马铃薯";
		System.out.println("北方人喜欢吃" + food);
	}
	
}

12.方法举例与声明的格式

package com.atguigu.java;

public class CustomerTest {

}
class Customer
{
	//属性:
	String name;
	int age;
	boolean isMale;
	
	//方法:
	public void eat()
	{
		System.out.println("和客户吃饭");
	}
	public void sleep(int hour)
	{
		System.out.println("休息了" + hour + "个小时");
	}
	public String getName()
	{
		return name;
	}
	public String getNation(String nation)
	{
		String info = "我的国籍是" + nation;
		return info;
		
	}
}

13.方法的声明1

package com.atguigu.java;

public class CustomerTest {
public static void main(String[] args) {
	Customer c1 = new Customer();
	c1.eat();
	c1.getName();
}
}
class Customer
{
	//属性:
	String name;
	int age;
	boolean isMale;
	
	//方法:
	public void eat()
	{
		System.out.println("和客户吃饭");
	}
	public void sleep(int hour)
	{
		System.out.println("休息了" + hour + "个小时");
	}
	public String getName()//一定要返回,否则报错
	{
		if(age > 13)
		{
		return name;
		}
		else{
		return "Tom";
		}
	}
	public String getNation(String nation)
	{
		String info = "我的国籍是" + nation;
		return info;
		
	}
}

14.方法声明的说明2

package com.atguigu.java;

public class CustomerTest {
public static void main(String[] args) {
	Customer c1 = new Customer();
	c1.eat();
	c1.getName();;
	int[] arr = new int[]{1,2,3,3,3,4,5,6,3,3,4};
	//c1.sort(arr);测试形参是否需要
}
}
class Customer
{
	//属性:
	String name;
	int age;
	boolean isMale;
	
	//方法:
	public void eat()
	{
		System.out.println("和客户吃饭");
	}
	public void sleep(int hour)
	{
		System.out.println("休息了" + hour + "个小时");
	}
	public String getName()//一定要返回,否则报错
	{
		if(age > 13)
		{
		return name;
		}
		else{
		return "Tom";
		}
	}
	
	
}

15.return关键字的使用

 *  return关键字的使用:
 *  	1.适用范围:使用在方法体之中
 *  	2.作用:(1)结束方法
 *  		   (2)针对有返回值的类型的方法,使用"return 数据"的方式
 *      3.注意点:return后面不可以声明执行语句.

16.方法使用的注意点

 *  5.方法的使用注意:可以调用当前类的属性或方法
 *  		特殊:方法A之中又调用了A--递归
 *  		方法之中不可以定义方法.(错误)

17.课后练习1:类的使用

题目

Person4.java

package com.atshangguigu.exer;

public class Person4 {
	String name;
	int age;
	
	int sex;
	
	public void study()//说明书里面的+是代表着public
	{
		System.out.println("studying");
	}
	public void showAge()
	{
		System.out.println("age" + "=" + age );
	}
	public int addAge(int i)
	{
		age += i;
		return age;
	}
}

PersonTest.java

package com.atshangguigu.exer;

public class PersonTest {
public static void main(String[] args) {
	Person4 p1 = new Person4();
	p1.name = "Yang";
	p1.age = 23;//没有女朋友
	p1.sex = 1;
	p1.study();
	p1.showAge();
	int newAge = p1.addAge(2);//这个2在栈里面
	System.out.println(p1.name + "的新年龄是:" + newAge);//25
	System.out.println(p1.age);//25 这里需要注意
	
	
	Person4 p2 = new Person4();
	p2.showAge();//0
	p2.addAge(10);
	p2.showAge();
}
}

18.课后练习2

package com.atshangguigu.exer;

//测试类
public class CirCleTest {
public static void main(String[] args) {
	Circle c1 = new Circle();
	c1.radius = 12.5;
	
	//double c2 = c1.findArea();
	//System.out.println(c2);
	c1.findArea();
}
}

//圆
class Circle
{
	//属性
	double radius;
	
	//方法
	//方式一:
	//public double findArea()
	//{
	//	return (Math.PI * radius * radius);//Math.PI
	//}
	//方式二:
	public void  findArea()
	{
		double area = Math.PI * radius * radius;
		System.out.println("面积为:" + area);
	}
	
	
}

19.课后练习3

package com.atshangguigu.exer;


public class Exer3Test {
public static void main(String[] args) {
	Exer3Test test = new Exer3Test();
	//test.method();//3.1
	
	//方式二
	//System.out.println(test.method1());
	//3.3
	System.out.println(test.method2(3,8));
	
}


public int method2(int m,int n)
{
	for(int i = 0;i < m;i++)
	{
		for(int j = 0;j < n;j++ )
		{
			System.out.print("*");
		}
			System.out.println();
			
	}
	return m * n;
			 
}
}

20.课后练习4

21.每日一考1

22.每日一考2

23.理解"万事万物皆是对象"

 * 一.理解"万事万物皆是对象"这句话(面试的时候可以提一下)
 * 1.在java语言的范畴之中,我们将功能结构等封装到类之中,通过类的实例化,来调用具体的功能结构.
 *   Scanner,string
 *   文件:file
 *   网络资源:URL
 * 2.语言的交互:前端之中STM32骨架(一个硬件或者接口)-----java之中的对象.属性(一个类)----数据库对象(表之中的一条条数据)
 * 		java语言与前段Html 后端的数据库交互时,前后端的结构在java层面的交互都提现为类 对象.
 *

24.对象数组的内存解析
将栈空间之中的stus:0x7788,指着堆空间之中的数组,且第一个元素指向相应的地址.

25.匿名对象的使用

package com.atshangguigu.java;

public class InstanceTest {
public static void main(String[] args) {
	Phone p = new Phone();//com.atshangguigu.java.phone@15db9742
	//p = null;
	System.out.println(p);
	
	p.sendMail();
	p.playGame();
	
	//匿名
	new Phone().price = 1999;
    new Phone().showPrice();//0.0
    
    
    PhoneMall mall = new PhoneMall();
    //mall.show(p);
    //匿名对象的使用
    mall.show(new Phone());//相当于是Phone phone = new Phone();我的理解是
    
}
}
class PhoneMall
{
	public void show(Phone phone)
	{
		phone.sendMail();
		phone.playGame();
	}
}
class Phone
{
	double price;
	
	public void sendMail()
	{
		System.out.println("发送邮件");
	}
	
	public void playGame()
	{
		System.out.println("打游戏");
	}
	
	public void showPrice()
	{
		System.out.println("手机的价格是" + price);
	}

}

26.自定义数组的工具类

改名refactory - rename:对类进行改名

package com.atshangguigu.java;

public class ArrayUtil {

	//求最大值
	public int getMax(int[] arr)
	{
		int max = arr[0];//最大值
		for(int i = 0;i < arr.length;i++)
		{
			if(max < arr[i])
			{
				max = arr[i];
			}

		}

		return max;
		
	}
	//求最小值
	public int getMin(int[] arr)
	{

		int min = arr[0];//最小值
	
		for(int i = 0;i < arr.length;i++)
		{
		
			if(min > arr[i])
			{
				min = arr[i];
			}
			
		}
	
		return min;
	}
	//求总和
	public int getSum(int[] arr)
	{

		int add = 0;
	
		for(int i = 0;i < arr.length;i++)
		{
		
			add += arr[i];
			
		}

		return add;
		
	}
	//求平均值
	public double getAvg(int[] arr)
	{
	
		int add = 0;
		double ava;
		for(int i = 0;i < arr.length;i++)
		{
			
			add += arr[i];
			
		}
		ava = add/(arr.length);
		return ava;
		
	}
	//反转
	public void reverse(int[] arr)
	{
		for(int i = 0,j = arr.length-1;i < j;i++,j--)  
		{
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		
	}
	//复制
	public int[] copy(int[] arr)
	{
		int[] arr1 = new int[arr.length];
		for(int i = 0;i < arr.length;i++)
		{
			arr1[i] = arr[i];
		}
		return arr1;
		
	}
	//排序
	public void sort(int[] arr)
	{
		for(int i = 0;i < arr.length-1;i++)
		{
			for(int j = 0;j

package com.atshangguigu.java;

public class ArrayUtilTest {
public static void main(String[] args) {
	
	ArrayUtil util = new ArrayUtil();
	int[] arr = new int[]{32,3,1,64,56,5,6,99,56,102,95,88,213,1,23,465,114,954};
	int max = util.getMax(arr);
	System.out.println("最大值为" + max);
	System.out.print("排序前:");
	util.print(arr);
	System.out.println();
	System.out.print("排序后:");
	util.sort(arr);
	util.print(arr);

	System.out.println("查找");
	int index = util.getIndex(arr, 5);
	if(index != 0)
	{System.out.println("找到了,索引地址为:" + index);
	}
	else
	{System.out.println("没有找到");
	}
	
	
}
}

27.理解方法的重载
重载的概念在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

28.方法重载的细节说明

package com.atshangguigu.java;

public class OverLoadTest {
	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		test.getSum(1,8);//如果注释掉第一个重载,那么自动调用其他的,自动类型提升
	}
	
	
	//如下四个方法构成了重载
	public void getSum(int i,int j)
	{
		System.out.println("1");
	}
	public void getSum(double d1,double d2)
	{
		System.out.println("2");
	}
	public void getSum(int d1,double d2)
	{
		System.out.println("3");
	}
	public void getSum(double d1,String d2)
	{
		System.out.println("4");
	}
	
	//下面这这个与第一个矛盾,不是一个重载的情况
	
}

29.重载的举例与判断练习
如下所示：是print类型的一个重载的过程。

30.重载的练习：编码实践

duplicate 的含义是重复。老外文化 Yes Yes Yes，因为听不懂，就是这样重复。

package com.atshangguigu.Exer;

public class OverLoadExer {
	//1.如下三种方法构成了重载
		public void mOL(int i)
		{
			System.out.println(i * i);
		}
		public void mOL(int i,int j)
		{
			System.out.println(i * i);
		}
		public void mOL(String s)
		{
			System.out.println(s);
		}
	//2.如下的三种方法也构成了重载
		public int max(int i,int j)
		{
			return (i > j)? i : j;		
		}
		public double max(double i,double j)
		{
			return (i > j)? i : j;	
		}
		public double max(double i,double j,double k)
		{
			double max = (i > j)? i : j;
			return(max > k)? max : k; 
		}
}

31.新特性：可变个数形参的方法

package com.atshangguigu.java1;

public class MethodArgsTest {
public static void main(String[] args) {
	MethodArgsTest test = new MethodArgsTest();
	test.show(12);
	test.show("hello!");
	test.show("hello!","world","没有对象!","学习吧");
	//test.show(new String[]{"AA","BB","CC"});
}
	public void show(int i)
	{
		
	}
	public void show(String s)
	{
		System.out.println("show(String!)");
	}
	public void show(String ...strs)
	{
		System.out.println("show(多个String!)");
		for(int i = 0;i < strs.length;i++)
		{
			System.out.println(strs[i]);
		}
	}
	
	
	public void show(int i,String ...strs)//必须声明在末尾
	{
	}
	
}

32.理解变量的赋值

package com.atshangguigu.java1;

public class ValueTransferTest {
public static void main(String[] args) {
	System.out.println("*************基本数据类型***********");
	int m = 10;
	int n = m;
	System.out.println("m=" + m + ",n=" + n);
	n = 20;
	System.out.println("m=" + m + ",n=" + n);
	System.out.println("*************引用数据类型***********");
	//引用数据类型的数据类型要么是null要么是地址值
	Order o1 = new Order();
	o1.OrderId = 1000;
	Order o2 = o1;//赋值以后,o1和o2的地址相同,指向也是相同的.
	System.out.println("o1 = " + o1.OrderId + ",o2 = " + o2.OrderId);
	o2.OrderId = 2000;
	System.out.println("o1 = " + o1.OrderId + ",o2 = " + o2.OrderId);
}
}
class Order
{
	int OrderId;
	
	}

33.值传递机制：针对基本数据类型

package com.atshangguigu.java1;

public class ValueTransferTest1 {
public static void main(String[] args) {
	int m = 10;
	int n = 20;
	System.out.println("m = " + m + ", n =" + n );
	ValueTransferTest1 test = new ValueTransferTest1();
	test.swap(m,n);
	System.out.println("m = " + m + ", n =" + n );
}
	public void swap(int m,int n)
	{
		int temp;
		temp = n;
		n = m;
		m = temp;
	}
}

上述代码的过程如下所示

34.值传递机制：针对引用数据类型

package com.atshangguigu.java1;

public class ValueTransferTest2 {
public static void main(String[] args) {
	two test = new two();
	test.m = 50;
	test.n = 80; 
	ValueTransferTest2 test2 = new ValueTransferTest2();
	System.out.println("m = " + test.m + ".n = " + test.n);
	test2.swap(test);
	System.out.println("m = " + test.m + ".n = " + test.n);
	
}
public void swap(two two)
{
	int temp;
	temp = two.m;
	two.m = two.n;
	two.n = temp;			
}
}
class two
{
   int m;
   int n;
}

35.值传递机制的练习（本节视频建议看两遍）
public class TransferTest3 { public static void main(String args []) { TransferTest3 test = new TransferTest3(); test .first(); } public void first() { int i = 5; Value v = new Value(); v . i = 25; second( v , i ); System. out .println( v . i ); } public void second(Value v , int i ) { i = 0; v . i = 20; Value val = new Value(); v = val ; System. out .println( v . i + " " + i ); } } class Value { int i = 15; }

36.探讨几道网红题

题目一

public static void method(int a,int b)
{//在不改变题目的基础上
	a = a * 10;
	b = b * 20;
	System.out.println(a);
	System.out.println(b);
	System.exit(0);
}

题目二

题目三

package com.atshangguigu.java1;

public class ArrayPrintTest {
public static void main(String[] args) {
	int[] arr = new int[]{1,2,3,4};
	System.out.println(arr);//地址值?
	char[] arr1 = new char[]{'1','2','3','4'};
	System.out.println(arr1); //地址值?
}
}

结果是：
[I@15db9742
1234

原因如左图（西北工业大学的学生进行面试的题目）

37.参数传递的编码练习

Circle.java

package com.atshangguigu.Exer1;

public class Circle {
	double radius;//半径
	public double findArea()
	{
		return radius * radius * Math.PI;
	}
}

PassObject.java

package com.atshangguigu.Exer1;

public class PassObject {
public static void main(String[] args) {
	PassObject test = new PassObject();
	Circle c = new Circle();
	test.printAreas(c, 5);
	System.out.println("now the radius is " + c.radius);
}
public void printAreas(Circle c, int times)
{ 
	System.out.println("RadiusttArea");
	for(int i = 0;i < times;i++)
	{
		c.radius = i;
		System.out.println(c.radius + "tt" +  c.findArea());
	}
	c.radius = c.radius + 2;
	}
}

38.递归方法的使用

这个阶段是了解即可

package com.atshangguigu.java2;

public class Recursiontest {
public static void main(String[] args) {
	Recursiontest test = new Recursiontest();
	
	System.out.println(test.getSum(100));
}
	//例1:计算1-n之间所有自然数的和
	//方式一：
	
	//方式二:
public int getSum(int n)
{
   if(n == 1 )
   {
	   return 1;
   }
   else 
   {
	   return n + getSum(n-1);
   }
}		
}

39.递归方法的举例
斐波那契数列
汉诺塔
快排

40.每日一考

41.封装性的引入

新浪网的员工加班,错过了77万的年终奖
封装性的定义:高内聚,低耦合

高内聚：类的内部数据操作细节自己完成，不允许外部干涉; 低耦合：仅对外暴露少量的方法用于使用。

思想:隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
注意下面的代码之中的legs的存在,这里有一个private

CSDN首页

消息

发文助手


发文助手会对标题提出优化建议，避免出现不恰当文字从而影响文章推荐。【标题规范】

六.面向对象编程(上)
11 / 100

展示封面：
*

优质的封面有利于推荐，格式支持JPEG、PNG
文章标签：
*
分类专栏：
新建分类专栏
最多选择3个分类专栏#为二级分类
文章类型：
申请原创将启用 Creative Commons 版权模板，如果不是原创文章，请选择转载或翻译。 原创文章默认开启打赏， 打赏管理
发布形式：
收益中心 
草稿已保存 21:33:46 共 23519 字
发布文章





package com.atshangguigu.java;

public class AnminalTest {
public static void main(String[] args) {
	Anminal a = new Anminal();
	a.name  = "花花变大黄";
	a.age = 1;
	//a.legs = 4;//报错:The field Anminal.legs is not visible
	a.show();
	a.setLegs(8);//告诉用户这种方式是正确的
	a.show();
}
}
class Anminal
{
	String name;
	int age;
	private int legs;//private的使用
	public void setLegs(int l)
	{
		if(l >= 0 && l%2 == 0)
		{
			legs = l;
		}
		else
		{
			legs = 0;
		}
	}
	public void eat()
	{
		System.out.println("看,那里有一堆粮");	
	}
	public void show()
	{
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
	
}

42.封装性的体现

package com.atshangguigu.java;

public class AnminalTest {
public static void main(String[] args) {
	Anminal a = new Anminal();
	a.name  = "花花变大黄";
	a.age = 1;
	//a.legs = 4;//报错:The field Anminal.legs is not visible
	a.show();
	a.setLegs(8);//告诉用户这种方式是正确的
	a.show();
	
}
}
class Anminal
{
	String name;
	int age;
	private int legs;//private的使用
	//对于属性的一个设置
	public void setLegs(int l)//腿的个数
	{
		if(l >= 0 && l%2 == 0)
		{
			legs = l;
		}
		else
		{
			legs = 0;
		}
	}
	//对于属性的一个获取
	public int getLegs()
	{
		return legs;
	}
	public void eat()
	{
		System.out.println("看,那里有一堆粮");	
	}
	public void show()
	{
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
	
	//提供age的get与set的方式
	public int getAge()
	{
		return age;
	}
	public void setAge(int age)
	{
		//限制条件
	}
}

43.四种权限修饰的理解
* 三.权限修饰符------封装性的提现需要权限修饰符的配合
* 1.java规定的四种权限:private 缺省 protected public
* 2.四种权限可以修饰什么:修饰类以及内部结构属性方法构造器内部类
* 3.具体的,四种权限都是可以修饰类的内部结构:属性方法构造器内部类
* 修饰类的话 :只能使用缺省 public

44.四种权限修饰的测试

代码一

package com.atshangguigu.java;

public class Order {
	private int orderPrivate;
	int orderDefault;
	public int orderPublic;
	
	private void methodPrivate()
	{
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	void methodDefault()
	{
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	public void methodPublic()
	{
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	
}

代码二

package com.atshangguigu.java;

public class Ordertest {
public static void main(String[] args) {
	Order test = new Order();
	//出了Order之后这里的私有结构是不可以被调用的
	//test.orderPrivate = 1;
	test.orderDefault = 2;
	test.orderPublic = 3;
	
	//同理:方法也是,private类型的是不可被调用的
}
}

代码三

package com.atshangguigu.java1;

import com.atshangguigu.java.Order;
//引用如果要是缺省类型的出了包以后也是不可以使用的.
public class OrderTest {
	public static void main(String[] args) {
		Order test = new Order();
		//出了Order之后这里的私有结构是不可以被调用的
		//test.orderPrivate = 1;
		//出了Order类所属的包以后,私有和缺省都是不可以被调用
		//test.orderDefault = 2;
		test.orderPublic = 3;
		
		//同理:方法也是
	}
	
}

总结:Java提供了四种权限修饰符来修饰类以及类的内部结构,提现类及类的内部结构在被调用的时候的可见性的大小.

45.封装性的练习：基本使用

Person.java

package com.atshangguigu.Exer;

public class Person {
	private int age;
	
	public void getAge(int ag)
	{
		if(ag < 0||ag > 130)
		{
			throw new RuntimeException("传入非法数据!");
			
		}
		else{
		age = ag;
		}
	}
	public int setAge()
	{
		return age;
	}
	
}

PersonTest.java

package com.atshangguigu.Exer;

public class PersonTest {
public static void main(String[] args) {
	Person test = new Person();
	test.getAge(23);
	System.out.println(test.setAge());
}
}

46.构造器的基本理解

field属性 constructor构造器 method方法

package com.atshangguigu.java1;

public class PersonTest {
public static void main(String[] args) {
	//过程2:创建对象:new + 构造器
	Person test = new Person();
	test.eat();
}
}

// 过程1:创建类
class Person {
	//属性
	int age;
	String name;
	
	//构造器
	public Person()
	{
		System.out.println("构造器");
	}
	
	//方法
	public void eat() {
		System.out.println("我一顿吃两份饭!");
	}

	public void sleep() {
		System.out.println("我可以连着睡12个小时");
	}

}

47.构造器使用的细节说明

package com.atshangguigu.java1;

public class PersonTest {
public static void main(String[] args) {
	//过程2:创建对象:new + 构造器
	Person test = new Person();
	test.eat();
	
	Person p1 = new Person("Tom");
	System.out.println(p1.name);
}
}

// 过程1:创建类
class Person {
	//属性
	int age;
	String name;
	
	//构造器
	public Person()
	{
		System.out.println("构造器");
	}
	public Person(String n)//这里的作用是初始化一个属性的过程
	{
		name = n;
	}
	public Person(String n,int a)
	{
		name = n;
		age = a;
	}
	
	//方法
	public void eat() {
		System.out.println("我一顿吃两份饭!");
	}

	public void sleep() {
		System.out.println("我可以连着睡12个小时");
	}

}

48.构造器练习：基本使用

package com.atshangguigu.java1;

public class ConstructorTsest {
public static void main(String[] args) {
	Person1 p = new Person1();
	System.out.println("年龄是" + p.setAge());
	
	Person1 p2 = new Person1("Yang",23);
	System.out.println("姓名是" + p2.setName());
}
}
 class Person1
{
	//属性 
	private int age;
	private String name;
	
	//构造器
	public Person1()
	{
		age = 18;
	}
	public Person1(String n,int a)
	{
		name = n;
		age = a;
	}
	
	//方法
	public void getAge(int ag)
	{
		age = ag;
	}
	public int setAge()
	{
		return age;
	}
	public void getName(String na )
	{
		name = na;
	}
	public String setName()
	{
		return name;
	}	
}

49.构造器练习：三角形

TriAngle.java

package com.atshangguigu.Exer1;

public class TriAngle {
	//属性
	private double base;//底边长
	private double height;//高
	
	//构造器
	public TriAngle()
	{
		
	}
	public TriAngle(double b,double c)
	{
		base = b;
		height = c;
	}
	
	//方法
	public void setbase(double b)
	{
		base = b;
	}
	public double getbase()
	{
		return base;
	}
	public void setHeight(double b)
	{
		height = b;
	}
	public double getHeight()
	{
		return height;
	}
}

TriAngleTest.java

package com.atshangguigu.Exer1;

public class TriAngleTest {
public static void main(String[] args) {
	//调用空参的构造器
	TriAngle t1 = new TriAngle();
	t1.setbase(45.3);
	t1.setHeight(175.0);
	System.out.println("base:" + t1.getbase() + ",height:" + t1.getHeight());
	
	//调用含有参数的构造器
	TriAngle t2 = new TriAngle(18,16);
	System.out.println("base:" + t2.getbase() + ",height:" + t2.getHeight());
}
}

50.总结赋值的过程

package com.atshangguigu.java1;

public class UserTest {
public static void main(String[] args) {
	User u = new User();
	System.out.println(u.age);
	
	User u1 = new User(2);
	u1.setAge(3);
	System.out.println(u1.age);
	
}
}
class User
{
	String name;
	int age = 1;
	
	public User()
	{}
	public User(int a)
	{
		age = a;
	}
	public void setAge(int a)
	{
		age = a;
	}
	public int getAge()
	{
		return age;
	}
}

51.JavaBean的使用

这节课听不明白,什么MyS什么什么哪个东西还没学(后面学)

package com.atshangguigu.java1;

public class Customer {
	
	private String name;
	private int id;
	
	//构造器
	public Customer()
	{}
	
	//方法
	public void getName(String na)
	{
		name = na;
	}
	public String setName()
	{
		return name;
	}
	public void getId(int i)
	{
		id = i;
	}
	public int setId()
	{
		return id;
	}
}

52.介绍UML类图

这里的banking代表着包名

53.this调用属性和方法

任何一个知识点:what why how

package com.atshangguigu.java2;

public class PersonTest {
public static void main(String[] args) {
	Person p1 = new Person();
	p1.setAge(1);
	System.out.println(p1.getAge());
}
}
class Person
{	//属性
	private String name;
	private int age;
	
	//构造器
	public Person()
	{}
	public Person(int age)
	{
		this.age = age;
	}
	public Person(int age,String name)
	{
		this.name = name;
		this.age = age;
	}
	
	//方法:形参的意义在于给上面进行赋值,并且需要"见名知意"
	public void setName(String name)
	{
		this.name = name;//防止属性与上面的形参重名的情况,注意this的使用
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age = age;//这里的this是相当于p1的,是先有类的,在写相应的代码
	}
	public int getAge()
	{
		return age;
	}
	
	public void eat()
	{
		System.out.println("中午了,看完这两节课,我想要去吃饭啦!");
		//data();//方法里面可以调用方法
		//上面的代码相当于下面
		this.data();//this相当于省略了
	}
	public void data()
	{
		System.out.println("今天是2021年10月18日,空气良好!");
	}
	
}

54.this调用构造器

this();//注意括号里面是否进行参数的填写

//构造器
	public Person()
	{
		this.eat();
		//Person初始化的时候需要注意以下代码(共40行代码)
	}
	public Person(int age)
	{
		this();//直接调用上面的空参构造器
		this.age = age;
		//Person初始化的时候需要注意以下代码(共40行代码)
		//上面的代码不用写了,直接调用上面的构造器
		
	}
	public Person(int age,String name)
	{
		this(age);//调用上面的构造器
		this.name = name;
		this.age = age;
	}

ctrl + shift + t 进行查找HashMap-------降低代码的冗余

本节完整代码如下所示:

package com.atshangguigu.java2;

public class PersonTest {
public static void main(String[] args) {
	
	Person p2 = new Person(20,"Jerry");
	System.out.println(p2.getAge());
}
}
class Person
{	//属性
	private String name;
	private int age;
	
	//构造器
	public Person()
	{
		this.eat();
		//Person初始化的时候需要注意以下代码(共40行代码)
		System.out.println(age);
	}
	public Person(int age)
	{
		this();//直接调用上面的空参构造器
		this.age = age;
		//Person初始化的时候需要注意以下代码(共40行代码)
		//上面的代码不用写了,直接调用上面的构造器
		
	}
	public Person(int age,String name)
	{
		this(age);//调用上面的构造器
		this.name = name;
		this.age = age;
	}
	
	//方法:形参的意义在于给上面进行赋值,并且需要"见名知意"
	public void setName(String name)
	{
		this.name = name;//防止属性与上面的形参重名的情况,注意this的使用
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age = age;//这里的this是相当于p1的,是先有类的,在写相应的代码
	}
	public int getAge()
	{
		return age;
	}
	
	public void eat()
	{
		System.out.println("中午了,看完这两节课,我想要去吃饭啦!");
		//data();//方法里面可以调用方法
		//上面的代码相当于下面
		this.data();//this相当于省略了
	}
	public void data()
	{
		System.out.println("今天是2021年10月18日,空气良好!");
	}
	
}

55.this练习：boy和girl

注意:软件上面的按钮:source - Generate Getters and Setters[直接加上get 与 set相应的内容]
注意:产生一个的构造器,这里的构造器是自动添加的方式:source - Generate Constructor using Fields
快捷键:Alt + shift + s
public int compare(Girl girl) { //简化版 return this.age - girl.age;//this表示的是当前吊用的对象 } }
- BoyAndGirlTest.java
```
package com.atshangguigu.Exer3;

public class BoyAndGirlTest {
public static void main(String[] args) {
	Boy boy = new Boy("罗密欧",22);
	boy.shout();
	
	Girl girl = new Girl("朱丽叶",18);
	girl.marry(boy);
	
	Girl girl1 = new Girl("魔法小樱",16);
	System.out.println(girl1.compare(girl));
	if(girl1.compare(girl) > 0)
	{
		System.out.println(girl1.getName() + "年龄大");
	}
	else if(girl1.compare(girl) < 0)
	{
		System.out.println(girl.getName() + "年龄大");
	}
	else 
	{
		System.out.println("二者的年龄一样大");
	}
}
}
```
56.综合练习1：Account和Customer

57.综合联系2：对象数组
58.package关键字的使用
- * 一.package关键字的使用
  * 1.为了更好的管理实现项目之中类的管理,提供包的概念
  * 2.使用package声明类或者接口所属的包,声明在源文件的首行(后面会学到xml,现在还不知道是什么)
  * 3.包是属于标识符,遵循标识符的命名规则与规范以及见名知意.
  * 4.每"."一次就代表一层目录-------这个是需要下Navigator之中进行查看.
  * 补充:同一个包之下不可命名同一个接口或者同一个类.
  * 不同的包之下可以命名同名的接口以及同名的类.
  */
59.MVC设计模式的理解
60.import关键字的使用
- 如果在源文件之中使用了不同包下的同名的类,则至少有一个类需要以全类名的方式进行显示.如下面所示:
```
package com.atshangguigu.Test;
import java.util.*;
import java.util.Arrays;
import java.util.HashMap;
import com.atshangguigu.Test.java3.Dog;

import static java.lang.System.*;
import static java.lang.Math.*;


public class PackageimportTest {
public static void main(String[] args) {
	String info = Arrays.toString(new int[]{1,2,3});
	
	ArrayList list = new Arraylist();
	HashMap map = new HashMap();
	com.atshangguigu.java1.PersonTest test = new com.atshangguigu.java1.PersonTest();
	com.atshangguigu.java2.PersonTest test1 = new com.atshangguigu.java2.PersonTest();
	
	Date date = new Date();
	java.sql.Date data1 = new java.sql.Date(1234567890);
	
	Dog dog = new Dog();
	
	out.println("一会儿得去上英语课,演讲PPT");//import static java.lang.System.*;
	long num = round(123.456);//import static java.lang.Math.*;
}
}
```
61.每日一考
- 1.构造器的作用是什么?使用的过程中需要注意哪些点?
答:创建对象,初始化对象结构;构造器没有返回值,一个类之中一定会有构造器的
- 2.关于类的属性的赋值,有几种赋值方式.谈一谈赋值的先后顺序
答:默认初始化,构造器之中初始化,对象.属性(对象.方法),给属性赋值
- 3.this关键字可以调用哪些结构?
答:this可以调用属性方法构造器,理解为当前对象或者当前正在创建的对象.涉及到形参问题,不可以省略this.
- 4.java之中涉及到了四种权限修饰符,分别是什么?
答:private int age;

private void eat(){};
- 5.创建Circle类,提供私有的radius属性,提供相应的get和set方法,并且求出相应的圆的面积
答:private double radius;

public void setRadius(double radius )

{

this.radius = radius;

}

public double getRadius()

{

return radius;

}

public double findArea()

{

return 3.14*getRadius*getRadius;

}

六.面向对象编程(上)

1.面向对象编程学习的主线

3.两个要素:类和对象
三.面向对象的两个要素: 类:对一类事物的描述,是抽象的概念上的定义对象:是实际存在的事物的个体,是实例化的过程 >面向对象程序设计的重点是类的设计 >设计类就是设计类的成员的过程 /

4.类的结构:属性和方法

5.类和对象的创建

7.对类和对象创建的再理解
白马非马问题-------课上引出
本节课只是对类和对象在思想层面上用语言进一步讲解

15.return关键字的使用
* return关键字的使用: * 1.适用范围:使用在方法体之中 * 2.作用:(1)结束方法 * (2)针对有返回值的类型的方法,使用"return 数据"的方式 * 3.注意点:return后面不可以声明执行语句.

16.方法使用的注意点
* 5.方法的使用注意:可以调用当前类的属性或方法 * 特殊:方法A之中又调用了A--递归 * 方法之中不可以定义方法.(错误)

20.课后练习4

21.每日一考1

22.每日一考2

24.对象数组的内存解析
将栈空间之中的stus:0x7788,指着堆空间之中的数组,且第一个元素指向相应的地址.

29.重载的举例与判断练习
如下所示：是print类型的一个重载的过程。

39.递归方法的举例
斐波那契数列
汉诺塔
快排

40.每日一考

52.介绍UML类图

这里的banking代表着包名

56.综合练习1：Account和Customer

57.综合联系2：对象数组

59.MVC设计模式的理解

Java相关栏目本月热门文章

六.面向对象编程(上)

1.面向对象编程学习的主线

3.两个要素:类和对象 *三.面向对象的两个要素: *类:对一类事物的描述,是抽象的 概念上的定义 *对象:是实际存在的事物的个体,是实例化的过程 *>面向对象程序设计的重点是类的设计 *>设计类就是设计类的成员的过程 */

4.类的结构:属性和方法

5.类和对象的创建

7.对类和对象创建的再理解 白马非马问题-------课上引出本节课只是对类和对象在思想层面上用语言进一步讲解

15.return关键字的使用 * return关键字的使用: * 1.适用范围:使用在方法体之中 * 2.作用:(1)结束方法 * (2)针对有返回值的类型的方法,使用"return 数据"的方式 * 3.注意点:return后面不可以声明执行语句.

16.方法使用的注意点 * 5.方法的使用注意:可以调用当前类的属性或方法 * 特殊:方法A之中又调用了A--递归 * 方法之中不可以定义方法.(错误)

20.课后练习4

21.每日一考1

22.每日一考2

24.对象数组的内存解析 将栈空间之中的stus:0x7788,指着堆空间之中的数组,且第一个元素指向相应的地址.

29.重载的举例与判断练习 如下所示：是print类型的一个重载的过程。

39.递归方法的举例 斐波那契数列汉诺塔快排

40.每日一考

52.介绍UML类图 这里的banking代表着包名

56.综合练习1：Account和Customer

57.综合联系2：对象数组

59.MVC设计模式的理解

Java相关栏目本月热门文章

3.两个要素:类和对象
三.面向对象的两个要素: 类:对一类事物的描述,是抽象的概念上的定义对象:是实际存在的事物的个体,是实例化的过程 >面向对象程序设计的重点是类的设计 >设计类就是设计类的成员的过程 /

7.对类和对象创建的再理解
白马非马问题-------课上引出
本节课只是对类和对象在思想层面上用语言进一步讲解

15.return关键字的使用
* return关键字的使用: * 1.适用范围:使用在方法体之中 * 2.作用:(1)结束方法 * (2)针对有返回值的类型的方法,使用"return 数据"的方式 * 3.注意点:return后面不可以声明执行语句.

16.方法使用的注意点
* 5.方法的使用注意:可以调用当前类的属性或方法 * 特殊:方法A之中又调用了A--递归 * 方法之中不可以定义方法.(错误)

24.对象数组的内存解析
将栈空间之中的stus:0x7788,指着堆空间之中的数组,且第一个元素指向相应的地址.

29.重载的举例与判断练习
如下所示：是print类型的一个重载的过程。

39.递归方法的举例
斐波那契数列
汉诺塔
快排

52.介绍UML类图

这里的banking代表着包名