1.面向对象的进阶
1.1成员变量和局部变量的区别
//成员变量和局部变量的区别
//1.在类中的位置不同
// 成员变量:类中方法外
// 局部变量:在方法中定义的变量(方法里面,方法声明中)
//2.作用的范围不同
// 成员变量:类中可以使用(成员方法)
// 局部变量:只有在定义该变量的方法中使用
//3.在内存中的位置不同
// 成员变量:在堆内存
// 局部变量:在栈内存
//4.初始化值不同
// 成员变量:有默认的初始化
// 局部变量:没有默认的初始值,必须定义后赋值再使用
//5.生命周期不同
// 成员变量:随着对象的创建而存在,随着对象的销毁而销毁
// 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
//注意事项:局部变量的名称可以和成员变量的名称一样 就近原则(先找方法中是否存在局部变量然后再找成员变量)
class Variable{
//成员变量
int num;//0
int num2=99;
//成员方法
public void show(){
//局部变量
int num2=20;
System.out.println(num);
//就近原则(先找方法中是否存在局部变量然后再找成员变量)
System.out.println(num2);
}
public void show2(int num3){
System.out.println(num);
//System.out.println(num2);报错的 num2只能在show方法使用
}
}
public class VariableDemo{
public static void main(String[] args){
Variable variable=new Variable();
System.out.println(variable.num);//0
variable.show();
}
}
1.2对象的垃圾回收
2.方法
2.1为什么需要方法
public class MethodDemo01{
public static void main(String[] args){
int x=10;
int y=20;
//相加
int c=x+y;
//输出结果
System.out.print(c);
//60+80
int x2=60;
int y2=90;
int c2=x2+y2;
System.out.println(c2);
//重复编写代码!!!
//把这些重复的代码放到一地方,只需要写一次代码,方法
}
}
2.2方法的定义格式
方法:完成特定功能的代码块
方法的定义格式:
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2){
//代码
return返回值;
}
返回值类型:就是功能结果的数据类型
参数:形成参数 就是定义在方法声明中,用于接受实际参数
实际参数:就是实际参与运算的值
return:结束方法的
返回值:就是功能的运算的结果,用return带给调用者
2.3有参数,没有返回值
class Number{
//需求:我给你两个数 两个整数相加,打印出来
//定义一个方法的时候:两个明确
//A:返回值类型 结果的数据类型
//B:参数列表 你要传递几个参数,以及每个参数的类型
//成员方法
public void sum(int a,int b){
int c=a+b;
System.out.println(c);
//return;
//结束方法的 如果一个方法返回值类型为void,return可以不写
}
}
public class NumberDemo{
public static void mian(String[] args){
Number number=new Number();
number.sum(1,2);
number.sum(1,5);
number.sum(1,8);
}
}
2.4有参数,有返回值
需求:两个整数相加,你把结果给我
class Number{
//需求:我给你两个数 两个整数相加,打印出来
//定义一个方法的时候:两个明确
//A:返回值类型 结果的数据类型
//B:参数列表 你要传递几个参数,以及每个参数的类型
//成员方法
public void sum(int a,int b){
int c=a+b;
System.out.println(c);
//return;
//结束方法的 如果一个方法返回值类型为void,return可以不写
}
//需求:两个整数相加,你把结果给我
//返回值类型 int
//参数列表 两个int类型的参数
public int sum2(int a,int b){//int a=1;int b=2
int c=a+b;//3
return c;//3
}
}
public class NumberDemo{
public static void main(String[] args){
Number number=new Number();
//方式1:单独调用
number.sum2(1,2);
//方式2:赋值调用
//int result=3;
int result=number.sum2(1,2);
System.out.println(result);
//方式3:输出调用
System.out.println(number.sum2(1,2));
}
}
2.5没有参数,有返回值
//没有参数,有返回值
public int sum3(){
return 100;
}
2.6没有参数,有返回值
public void hello(){
System.out.println("hello world!");
}
main
Number number=new Number();
//如果一个方法没有返回值,智能进行单独调用
number.hello();
2.7获取两个数的最大值
class Number{
//获取两个整数的最大值
//两个明确
//返回值类型 int类型
//参数列表 两个参数
public int getMax(int a,int b){
//int a=1 int b=2
if(a>b){
return a;
}else{
return b;
}
}
}
public class NumberDemo{
public static void main(String[] args){
Number number=new Number();
System.out.println(number.getMax(1,2));
}
}
优化
public int getMax(int a,int b){
int c=(a>b)?a:b;
return c;
}
再次优化
public int getMax(int a,int b){
return (a>b)?a:b;
}
2.8判断两个整数是否相等
/*
判断两个整数是否相等
两个明确
返回值类型 boolean
参数列表 两个int类型
*/
public boolean compare(int a,int b){
if(a==b){
return true;
}else{
return false;
}
}
优化
public boolean compare(int a,int b){
return a==b?true:false;
}
再优化
public boolean compare(int a,int b){
return a==b;
}
2.9方法的注意事项
- 方法不调用不执行
- 方法和方法是平级关系,不能嵌套定义
- 方法定义的时候参数用,隔开
- 方法调用的时候不需要在传递数据类型
- 如果方法有明确的的返回值类型,一定要有return带回一个值
- 当方法的返回值类型是void,只能单独调用
3.方法的高级应用
3.1方法的参数维数组
需求:传递一个int类型数组,获取数组的最大值
两个明确;
返回值类型int
参数列表:int[] arr
class Number{
/**
* 获取数组的最大值
* @param arr 传递一个数组 * @return 返回数组的最大值
*/
public int getArrayMax(int[] arr) {
int max=arr[0];
for(int i=1;i<arr.length;i++) {
if(arr[i]>max) {
max=arr[i];
}
}
return max;
}
}
public class NumberDemo {
public static void main(String[] args) {
Number number=new Number();
System.out.println(number.getMax(1, 2));
System.out.println(number.compare(3, 3));
int[] arr= {1,2,3,4,5,6,7,8,9};
int max=number.getArrayMax(arr);
System.out.println(max);
}
}
3.2方法的调用栈
class Stack{
public void hello(){
System.out.println("hello方法的开始");
aa(100);
System.out.println("hello方法的结束");
ee();
}
public int aa(int a){
System.out.println("aa开始");
bb();
System.out.println("aa结束");
dd();
return 100;
}
public void bb(){
System.out.println("bb开始");
}
//hello方法的开始 aa开始 "bb开始 aa结束 dd开始 hello方法的结束 ee开始
public void dd(){
System.out.println("dd开始");
}
public void ee() {
System.out.println("ee开始");
}
}
public class StackDemo {
public static void main(String[] args) {
Stack stack=new Stack();
stack.hello();
}
}
3.3方法的重载
class Number2{
//我们在实现各种组合的相加,方法的名字不一样 //我们要求见名知意
//怎么办呢?
//针对这种情况,方法的功能相同,参数列表不同,为了见名知意
//Java允许他们的名字一样 专业名词:方法的重载
//在一个类中,方法名相同,参数列表不同(参数的类型和个数)。与返回值没有关系
//两个整数相加
public int add(int a,int b) {
return a+b;
}
//两个整数相加
public int add(int a,long b) {
return 3;
}
//三个整数相加
public int add(int a,int b,int c) {
return a+b+c;
}
}
public class NumberDemo02 {
public static void main(String[] args) {
Number2 number=new Number2();
System.out.println(number.add(1, 2));//3
System.out.println(number.add(1, 2L));
System.out.println(number.add(1,2,3));
//什么叫做方法的重载?
//在一个类中
//方法的名字相同,参数列表不同(参数的类型和个数),与返回值类型无关
}
}
4.封装
面向对象的三大特性:封装 继承 多态
封装:指隐藏对象的属性和实现细节,仅对外提供公共的访问方式
4.1封装的概念
class Student2{
String name;
//成员变量可以直接进行赋值,可以进行一些非法操作
//在赋值之前,可以先判断一下,在哪里判断?
//逻辑代码必须放在方法中
//我们就在Student2写一个方法给age赋值
//age属性不能直接赋值
//java提供一个关键字 private(私有的)
private int age;
//private 私有的,可以修饰成员变量和成员方法
//被private修饰的成员只能在本类中访问
//封装:指隐藏对象的属性和实现细节,仅对外提供公共的访问
//我们就在Student2写一个方法给age赋值
public void setAge(int a) {
if(a<0||a>120) {
System.out.println("你的年龄有问题!");
}else{
//局部变量的值赋值给成员变量
age=a;
}
}
public void show() {
System.out.println("名字:"+name);
System.out.println("年龄:"+age);
}
private void sleep() {
System.out.println("睡觉");
}
}
public class StudentDemo02 {
public static void main(String[] args) {
Student2 student2=new Student2();
student2.name="班长";
student2.setAge(99);
student2.show();
}
}
4.2private 特点
//private 权限修饰符 可以修饰成员变量和成员方法
//被它修饰的成员只能在本类中访问
class PrivateDemo{
private int num=10;
public void show() {
//本类中的方法可以访问私有属性的
System.out.println(num);
}
private void method() {
System.out.println("method");
}
public void function() {
//本类中的方法可以访问私有的方法
method();
}
}
public class PrivateDemoTest {
public static void main(String[] args) {
PrivateDemo privateDemo=new PrivateDemo();
privateDemo.show();
privateDemo.function();
}
}
4.3private的标准案例
class Person{
//姓名
private String name;
//年龄
private int age;
//地址
private String address;
//设置值是设置名字
public void setName(String n) {
//不写判断 引出封装的概念 以后判断有其它的方式
name=n;
}
//获取名字
public String getName() {
return name;
}
//设置年龄
public void setAge(int a) {
age=a;
}
//获取年龄
public int getAge() {
return age;
}
//设置地址
public void setAddress(String a) {
address=a;
}
//获取值
public String getAddress() {
return address;
}
}
public class PersonDemo {
public static void main(String[] args) {
Person person=new Person();
System.out.println("name:"+person.getName()+"age:"+person.getAge()+"address"+person.getAddr
ess());
//赋值 person.setName("副班长");
person.setAge(18); person.setAddress("地球");
System.out.println("name:"+person.getName()+"age:"+person.getAge()+"address"+person.getAddr
ess());
}
}