面向对象
1.类
1.1声明一个类的语法格式
public class 类 {
特征(Java中的变量)
行为(java 中暂时不带static的方法)
}
//举个例子
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创建对象
通过类创建对象。官方术语: 实例化对象
对象存在的目的: 对属性进行赋值,对方法调用
1.先有类才能有对象
2.对象的创建必须在main主函数中
对象创建的语法格式:
类 对象的名字= new 类();
//举个例子 //测试类 带有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(); //通过类去创建一个对象,然后对对象的属性进行赋值,对对象的方法进行调用 } }
1.3实体类和测试类(main主函数)可以写在一个文件中
当一个文件中有两个类的时候 ,只能有一个public 来修饰类
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();
}
}
2.构造方法
1.构造方法是用来初始化对象的(和创建对象有关的!!!)
2.构造方法必须写在实体类中 不是带有main主函数的类中
2.1无参构造方法
语法格式:
public 类名 () {
语句体
}
只要创建了对象,就会调用无参构造方法
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();
}
}
2.2有参构造方法
语法格式:
public 类名 (参数) {
}
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);//
}
}
3.对象的内存分析
Jvm内存分配,以后还会再讲
区域的名字 | 作用 |
---|---|
寄存器 | 给CPU使用的,和开发没有关系 |
本地方法栈 | JVM在执行操作系统的时候会使用,和咱们没有关系 |
方法区 | 存储的是字节码文件 class文件 |
堆区域 | 存储对象或者数组的数据,凡是 new的东西和堆有关 |
栈区 | 存储的是八大基本数据类型的数据和对象的引用(内存地址) |
栈:存储的是八大基本数据类型的数据和对象的引用(内存地址)
int a = 20; a 20 都存在栈区了
Peson person = new Person(); 栈 存的是dog的内存地址
堆:
对象的真实的数据 二哈 12
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KrsJHQM4-1681549149821)(D:/千峰教育软件/学习笔记视频代码/codeday09/1.png)]
4.构造代码块【开发不用】
现在开发不用了,以后会讲一个叫静态代码块的
构造代码块的目的:也是可以对对象的属性进行赋值。功能是和构造方法是一样的
语法格式:
{
语句体
}
1.写在实体类中
2.只要实例化一个对象以后,就会先执行构造代码块,然后再执行构造方法
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.成员变量和局部变量
5.1局部变量
变量的作用域的问题, 方法a中一个变量,能不能再方法b中使用? 不能
局部变量在使用的时候要赋值的
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);
}
}
5.2成员变量
定义在实体类中的大括号的里面,也叫属性
成员变量可以先不赋值,提供一个默认值
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();
}
}
5.3成员变量和局部变量的区别
区别 | 成员变量 | 局部变量 |
---|---|---|
定位位置 | 类的大括号的后面 也叫属性 | 定义在方法体中 |
作用 | 描述一个类的属性或者特征的 | 在方法体中保存变量的值的 |
初始化的值 | 有默认的初始值String=>null int ==>0 | 没有默认的值使用的时候一定要赋值 |
作用域 | 作用整个类 | 只能在当前方法中使用 |
6.封装【重点】
Java是面向对象的三大特征 ,就是把对象的属性和操作(服务) 结合起来变成一个整体,并尽可能的去隐藏内部的信息
Java封装 对属性的封装, 对方法的封装 , 对类的封装
今天主要讲属性的封装:
之前写的属性 String name; int age;。只需要通过对象.name 赋值和取值即可,这样的话存在一定隐患的。
现在咱们对属性进行封装:
1.为每个属性加上一个修饰符 private (私有的)
2.在实体类中,书写相对应的set方法和get方法 进行操作
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());
}
}
7.this关键字
1.一般写在 实体类中。表示的是当前的对象
可以使用 this调用 属性和方法
2.this关键字可以调用构造方法(很少用)
注意事项:
1.一定是在构造方法调用另外一个构造方法
2.在构造方法中调用其他的构造方法的时候,构造调用时候一定写在首行
package com.qf.test;
class Person {
String name;
int age;
public Person () {
System.out.println("Line 9: "+ this);//代表是当前的对象
this.name = "狗蛋";//this可以调用属性
}
public void eat () {
//this可以调用方法
this.test();
}
public void test () {
System.out.println("嘻嘻");
}
}
public class Demo1 {
public static void main(String[] args) {
Person person1 = new Person();
System.out.println(person1);//对象的内存地址 15db9742
System.out.println(person1.name);
person1.eat();
Person person2 = new Person();
System.out.println(person2);//对象的内存地址6d06d69c
System.out.println(person2.name);
}
}
8.方法的参数是一个类对象
方法的参数可以是八大基本数据类型 , String , 数组
类对象也是作为方法的参数
package com.qf.test;
class People {
//一个类对象可以作为一个方法的参数
public void feed (Dog1 dog1) {//这个是喂的方法
dog1.eat();
}
}
class Dog1 {
public void eat () {
System.out.println("狗去啃大骨头");
}
}
public class Demo4 {
public static void main(String[] args) {
People people = new People();
Dog1 dog1 = new Dog1();
people.feed(dog1);
}
}
9.多类合作
一个类对象可以作为另外一个类的属性
package com.qf.test;
class RenLei {//人类
String name;
int age;
BigDog bigDog;//bigDog这个对象带了三个数据 牛彩云 3 黑色
}
class BigDog {
String name;
int age;
String color;
}
public class Demo8 {
public static void main(String[] args) {
BigDog bd = new BigDog();
bd.name = "牛彩云";
bd.age = 3;
bd.color = "黑色";
RenLei renLei = new RenLei();
renLei.name = "二贝";
renLei.age = 38;
renLei.bigDog = bd;
System.out.println(renLei.name);
System.out.println(renLei.age);
//人的狗 狗的名字
System.out.println(renLei.bigDog);//内存地址
System.out.println(renLei.bigDog.name);// 牛彩云
System.out.println(renLei.bigDog.age);//3
System.out.println(renLei.bigDog.color);//黑色
}
}
age;
String color;
}
public class Demo8 {
public static void main(String[] args) {
BigDog bd = new BigDog();
bd.name = "牛彩云";
bd.age = 3;
bd.color = "黑色";
RenLei renLei = new RenLei();
renLei.name = "二贝";
renLei.age = 38;
renLei.bigDog = bd;
System.out.println(renLei.name);
System.out.println(renLei.age);
//人的狗 狗的名字
System.out.println(renLei.bigDog);//内存地址
System.out.println(renLei.bigDog.name);// 牛彩云
System.out.println(renLei.bigDog.age);//3
System.out.println(renLei.bigDog.color);//黑色
}
}
##