java第八天学习笔记
回顾
public static void main(String[] args) {
//传参
//我们在调用方法时，有些方法需要传入参数。
//基本类型作为参数传递：属于值传递 形参的改变不影响实参
//引用类型作为参数传递：属于引用传递，传的是地址值 形参的改变是影响实参的
//二维数组：是元素为一维数组的数组。
int[][] ints = new int[3][]; // null null null
int[][] ints2= new int[3][2]; // 0x001 0x002 0x003
//递归：在方法中调用方法本身的现象 递归要有出口 递归次数不宜过多。
//面向对象：一种思想，基于面向过程。 万物皆对象。
//面向对象的三大特征：封装 继承 多态
//封装：类 体现的是封装的思想。 封装了 成员变量 成员功能。 类 是Java中最小的单位。
//定义一个类 class
// 怎么使用类？创建该类对象 使用对象调用类中的属性和功能
}
一、面向对象(成员变量和局部变量的区别)(掌握)
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上(形参)
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：: 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
public static void main(String[] args) {
int num = 10; //局部变量
//System.out.println(num);
/* //成员变量和局部变量的区别
* //局部变量：定义在方法中的变量或者方法声明上的变量（形参）
* //成员变量：定义在类中方法外的变量
* 1.局部变量属于方法，局部变量随着方法的调用而产生，随着方法的调用完毕而消失。
* 2.成员变量属于对象。随着对象创建的创建而产生，随着对象的消失而消失。
* 3.局部变量没有初始化值，必须赋值才能使用。成员变量有默认值。
* 4.局部变量存在栈内存，成员变量存在堆内存。
* */
Student student = new Student();
student.show(20, 30);
}
//成员变量
int num=200;
int c;
public void show(int a,int b){
//变量访问的规则：当成员变量和局部变量同名后，在访问变量时，按照就近原则
//就近原则：先在局部范围找，如果找到这个变量，就使用；如果在局部范围 没找到，去成员范围找，如果找到就使用。
System.out.println(a); //20
//System.out.println(b); //30
int c=300;
System.out.println(c); //
}
面向对象(方法的形式参数是类名的时候如何调用)(掌握)
A:Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
B:方法的参数是类名
如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
=======================================================================================
public class MyTest2 {
public static void main(String[] args) { }
}
//我们可以在一个Java文件中，并列定义多个类。要求是 只能这个有主方法的类前面加上public,要么全部都不加public
//但是我们建议 一个类就是一个Java文件
class Teacher{ }
class Dog{ }
class Cat{ }
public class MyTest {
public static void main(String[] args) {
//如果你以后看到一个方法的形参要一个 类 类型，你就传递一个该类的对象。
Teacher teacher = new Teacher();
System.out.println("传递的"+teacher);
show(teacher,20);
System.out.println("========================");
Teacher teacher2 = new Teacher();
show(teacher2,250);
System.out.println(teacher2.num);//250
System.out.println("===========================");
//匿名对象作为参数传递
show(new Teacher(),6333);
show(new Teacher(), 6333); }
public static void show(Teacher teacher,int a){
System.out.println("传递到方法里面的"+ teacher);
teacher.num=a;
System.out.println(teacher.num);}
}
class Teacher{
int num=100;}
面向对象(匿名对象的概述和应用)(理解)
A:什么是匿名对象
就是没有名字的对象
B:匿名对象应用场景
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递
C:案例演示
匿名对象应用场景
public static void main(String[] args) {
Student student=new Student();
student.show();
//没有名字的对象，我们叫做匿名对象。
new Student();
//使用匿名对象来调用方法
new Student().show();
//如果说我们这个方法，只想要调用一次的是，我们直接使用匿名对象调用就很方便
new Student().show();
//如果我想要使用同一个对象，把方法调用多次的时候，就不能使用匿名对象。
Student s1 = new Student();
s1.show();
s1.show();
s1.show();
System.out.println("============================");
//匿名对象可以作为参数传递
//如果你以后看到一个方法的形参，要一个类 类型。你就传递一个该类的对象
test(s1,20); }
public static void test(Student student,int a){
System.out.println(student.num); //
}
}
class Student{
int num=200;
public void show(){
System.out.println("呵呵");
}
面向对象(封装的概述)(掌握)
A:封装的引入
通过学生案例，给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
B:封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
C:封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
D:封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
面向对象(private关键字的概述和特点)(掌握)
A:private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问，外界无法直接访问
B:案例演示
private关键字特点
public class MyTest {
public static void main(String[] args) {
//private 是一个权限 修饰符，可以修饰成员变量，和成员方法，被修饰的成员，只能在本类中访问，外界无法直接访问。
//权限修饰符 范围 public>protected>确省的>private
Student student = new Student();
int age = student.age;
int num = student.num;
int a = student.a;
student.show();
//类中私有的成员外界无法访问
//student.show2(); } }
class Student{
private String name;
public int age;
protected int num;
int a;
public void show(){
System.out.println("abc");
System.out.println(age);
show2(); }
private void show2() {
System.out.println("abc");
}
}
public class Student {
String name;
//private 私有的 是一个权限修饰符，可以修饰 成员变量，成员方法，修饰之后，该成员只能在本类中访问，外界无法直接访问
private int age;
public void show(){
System.out.println(age);
}
//我们为了让用户能够在外界给我们的成员变量设置值，我们可以让他调用方法来给成员变量设置
//我们提供给成员变量设置值的公共的方法，让他把数据通过调用方法，传过来 来设置
public void setAge(int nianling){
if(nianling>=0&&nianling<=100){
age = nianling;
}
}
//我们还得提供获取成员变量值的方法
public int getAge() {
return age;
}
}
public static void main(String[] args) {
Student student = new Student();
//给成员变量设置值
student.name="张三";
// student.age=23;
String name = student.name;
//int age = student.age;
System.out.println(name);
// System.out.println(age);
System.out.println("=========================");
Student student2 = new Student();
//给成员变量设置值
student2.name = "李四";
//设置年龄的时候，这个240 我认为是不合理的数据，但是这个数据给设置上去了，我觉得不好。
//我要避免这种情况，当我给一个成员变量设置值时，我得要对这个数据进行校验，看合不合理，如果数据不合理，就不要设置。
//以我们目前的这个语法 对象名.成员变量名=值 就给设置上去了。
//那么 我们 可以屏蔽掉这种语法 不要 以 对象名.成员变量名=值 这种方式来设置。
//我们使用关键字private 就可以屏蔽掉 对象名.成员变量名=值 这种方式
//student2.age = 240;
String name2 = student2.name;
//int age2 = student2.age;
student2.setAge(50);
System.out.println(name2);
//System.out.println(age2);
int age = student2.getAge();
System.out.println(age);
}
面向对象(private应用的标准案例)(掌握)
A:private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法
B:案例演示
演示使用封装来完善我们的学生类
public class Teacher {
//定义成员变量，把成员变量私有掉
private String name;
private int age;
//提供公共的 设置值 和 获取 成员变量值的方法
public void setName(String mingzi){name=mingzi;}
public void setAge(int nianling){age=nianling;}
public String getName(){return name;}
public int getAge(){return age;}
}
面向对象(this关键字的概述和应用)(掌握)
A:为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
B:this关键字特点
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
C:this的应用场景
解决局部变量隐藏成员变量
D:案例演示
this的应用场景
class Student{
private String name;
private int age;
//提供公共的方法 设置 获取
public void setName(Student student,String name) {
System.out.println("方法中的this 代表"+this);
//当成员变量和局部变量重名了，我们怎么区分
//我们可以使用this关键字来取分
//this 他代表本类的一个引用，你可以认为是本类的一个对象，那么哪个对象调用这个方法，这个方法中的this就代表这个对象。
this.name = name;
// student.name = name;
System.out.println("传过来的student"+student);
System.out.println(this == student); }
public void setAge(Student student,int age) {
System.out.println("方法中的this 代表" + this);
this.age = age;
//student.age = age;
System.out.println("传过来的student" + student);
System.out.println(this==student); }
public String getName() {
return name; }
public int getAge() {
return age; }
}
面向对象(标准的学生类代码及其测试)(掌握)
A:案例演示: 把手机类的成员用private修饰,给出getXxx()/setXxx()方法
public class Student {
private String name;
private int age;
public String getName() {
return name; }
//使用IDEA快速生成 get set 方法 alt+insert 弹出一个框 选 getterAndseter选项 选择
public void setName(String name) {
this.name = name; }
public int getAge() {
return age; }
public void setAge(int age) {
this.age = age; }
}
二、构造方法
面向对象(构造方法概述和格式)(掌握)
A:构造方法概述和作用
创建对象,给对象中的成员进行初始化
B:构造方法格式特点
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
public class MyTest {
public static void main(String[] args) {
//创建对象时使用关键字 new
//我们在创建对象时，除了要使用 关键字new 之外，我们还必须借助构造方法，来完成对类的实例化
//我们这里使用的是空参构造来创建对象。
Student student = new Student();
System.out.println(student);
//student.show();
System.out.println("=================================");
//我们借助有参构造来创建对象
Student student1 = new Student("aaa");
System.out.println(student1);
System.out.println("===============================");
Student student2 = new Student("张三", 23);
System.out.println("===============================");
Student student3 = new Student();
student3.setName("赵六");
student3.setAge(26);
System.out.println(student3.getName());
System.out.println(student3.getAge());
System.out.println("===========================");
//借助有参构造给成员变量赋值
Student student4 = new Student("田七", 27);
System.out.println(student4.getName());
System.out.println(student4.getAge()); }
}
class Student{
//我们在自定义一个类的时候，这个类默认就存在一个空参的构造方法
//构造方法：就是方法名和类名相同，并且构造方法，没有返回值类型，连void没有
private String name;
private int age;
public Student(){
System.out.println("空参的构造方法调用了"); }
public Student(String name) {
System.out.println("一个参数的构造方法调用了"+name); }
public Student(String name,int age) {
System.out.println("两个参数的构造方法调用了"+name+"==="+age);
this.name=name;
this.age=age; }
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 void show(){
System.out.println("show"); }
public void show(int a) {
System.out.println("show"); }
}
面向对象(构造方法的重载及注意事项)(掌握)
A:案例演示
构造方法的重载
B:构造方法注意事项
a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
b:如果我们给出了有参数构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
C:给成员变量赋值的两种方式
a:setXxx()方法
b:构造方法
面向对象(一个标准学生类的代码及测试)(掌握)
A:案例演示
完善一下我们的学生的类
B:给成员变量赋值：
a:setXxx()方法
b:构造方法
C:输出成员变量值的方式：
a:通过getXxx()分别获取然后拼接
b:通过调用show()方法搞定
public static void main(String[] args) {
Teacher teacher = new Teacher();
teacher.setName("沈员外");
teacher.setAge(20);
System.out.println(teacher.getName());
System.out.println(teacher.getAge());
System.out.println("============================");
Teacher teacher1 = new Teacher("沈公子", 30);
System.out.println(teacher1.getName());
System.out.println(teacher1.getAge());
}
public class Teacher {
private String name;
private int age;
//自己定义的类中，默认就存在空参构造
//当我们手动写出了有参构造，默认无参构造就没有了，如果你还想使用无参构造创建对象。建议你手动把无参构造写出来
public Teacher(){
System.out.println("空参构造调用了"); }
public Teacher(String name,int age){
this.name=name;
this.age=age; }
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; }
}
面向对象(一个标准手机类的代码及测试)(掌握)
A:案例演示: 模仿学生类，完成手机类代码
private String name;
private double price;
public Phone(){}
public Phone(String name,double price){
this.name=name;
this.price=price; }
public String getName() {
return name; }
public void setName(String name) {
this.name = name; }
public double getPrice() {
return price; }
public void setPrice(double price) {
this.price = price; }
public void call(){
System.out.println("打电话"); }
public void sendMsg(){
System.out.println("发短信"); }
public class Phone {
private String name;
private double price;
//快速生成构造方法 alt+insert 选constructor
public Phone() { }
public Phone(String name, double price) {
this.name = name;
this.price = price; }
public String getName() {
return name; }
public void setName(String name) {
this.name = name; }
public double getPrice() {
return price; }
public void setPrice(double price) {
this.price = price; }
public void call(){
System.out.println("打电话"); }
}
public static void main(String[] args) {
//一个类的构成：构造方法 成员变量 成员方法
Phone phone = new Phone();
phone.setName("小米");
phone.setPrice(800);
System.out.println(phone.getName());
System.out.println(phone.getPrice());
phone.call();
phone.sendMsg();
System.out.println("==============================");
Phone phone1 = new Phone("魅族", 900);
System.out.println(phone1.getName());
System.out.println(phone1.getPrice());
phone1.call();
phone1.sendMsg();
}
面向对象(创建一个对象的步骤)(掌握)
A:画图演示
画图说明一个对象的创建过程做了哪些事情?
Student s = new Student();
步骤:
(1):加载Student.class文件进内存
(2):在栈内存为s开辟空间
(3):在堆内存为学生对象开辟空间
(4):对学生对象的成员变量进行默认初始化
(5):对学生对象的成员变量进行显示初始化
(6):通过构造方法对学生对象的成员变量赋值
(7):学生对象初始化完毕，把对象地址赋值给s变量
Price());
phone.call();
phone.sendMsg();
System.out.println("==============================");
Phone phone1 = new Phone(“魅族”, 900);
System.out.println(phone1.getName());
System.out.println(phone1.getPrice());
phone1.call();
phone1.sendMsg();
}
### 面向对象(创建一个对象的步骤)(掌握)
A:画图演示
画图说明一个对象的创建过程做了哪些事情?
Student s = new Student();
步骤:
(1):加载Student.class文件进内存
(2):在栈内存为s开辟空间
(3):在堆内存为学生对象开辟空间
(4):对学生对象的成员变量进行默认初始化
(5):对学生对象的成员变量进行显示初始化
(6):通过构造方法对学生对象的成员变量赋值
(7):学生对象初始化完毕，把对象地址赋值给s变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LYgEAwDP-1586793764442)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1586793634954.png)]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
