面向对象概述：
面向过程：当需要一个功能的时候，每一个具体步骤亲力亲为，详细处理每一个细节
面向对象：当需要一个功能的时候，不关心具体的步骤，而是找一个具有该功能的人，来帮我做事。
面向对象特征：封装、继承、多态
public class Demo{
public static void main(String[] args){
int[] array={
10,20,30,40}
//要求打印 [10,20,30,40]
//面向过程是亲力亲为
System.out.print("[");
for(int i=0;i<array.length;i++)
{
if(i==array.length)
System.out.print(array[i]+"]");
else
System.out.print(array[i]+",");
}
System.out.println("================");
//使用面向对象
//找一个JDK给我们提供的Arrays类
//其中有一个toString方法，直接就能把数组变成想要的字符串
System.out.println(Arrays.toString(array));
}
类和对象
类：是一组相关属性和行为的集合。一类事物的模板。使用事物的属性和特征来描述该类实物
现实中：
属性：状态信息（名字 体重 年纪）
行为：能做什么（走 跑 叫）
对象：一类事物的具体表现，对象是类的实例
现实中：一类事物的实例：一只小猫；
类是一类事物的描述。抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体。
类的定义
定义一个类，用来模拟学生事务，两个组成部分
属性（是什么）
姓名
年龄
行为（能做什么）
吃饭饭
睡觉觉
学习习
对应到java中
成员变量（属性）
String name;//姓名
int age;//年龄
成员方法（行为）
public void eat(){}//吃饭饭
public void sleep(){}//睡觉觉
public void study(){}//学习习
******定义一个学生类 叫Student;
public class Student{
//成员变量 （直接写在了类里（成员变量），没有建在方法里（局部变量））
String name;//姓名
int age;//年龄
//成员方法
public void eat(){
System.out.println("吃饭饭");
}
public void sleep(){
System.out.println("睡觉觉");
}
public void study(){
System.out.println("学习习");
}
1.成员变量是直接定义再类当中的，再方法外面；
2.成员方法不要写static关键字；（普通方法写）
---------------------------------------------
通常情况下，一个类并不能直接使用，需要根据一个类创建一个对象，才能使用。
1.导包：指出需要的类在什么位置。
import 包名称.类名称;
import cn.itcast.day.Student;
和当前类属于同一个包的情况，可以省略不写
2.创建：
类名称 对象名 = new 类名称（）；
Student stu = new Student();
3.使用：分两种情况
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
Public class Dem{
public static void main(String[] args){
//导包。
//需要使用Student类。和我Dem位于同一个包下，不用导包
//2.创建：
//类名称 对象名 =new 类名称（）；
//根据Student类，创建一个stu对象
Student stu = new Student();
//3.使用其中成员变量
//对象名.成员变量名
System.out.println(stu.name);//类中没有赋值,会默认值null
System.out.println(stu.age);0
//可以赋值
stu.name="赵丽颖";
stu.age=18;
stu.eat();
stu.sleep();
stu.study();
public class Phone {
String yanse;
int change;
public void tonghua(String who){
//带参数的
System.out.println("给"+who+"打电话");
}
public void liaotian(){
//不带参数的
System.out.println("吃饭了没！！！");
}
}
public class pho {
public static void main(String[] args){
//导包
//import
//创建
Phone one = new Phone();
//使用
System.out.println(one.yanse);
System.out.println(one.change);
one.yanse="黄色";
one.change=5999;
System.out.println(one.yanse);
System.out.println(one.change);
one.liaotian();
one.tonghua("乔布斯");
}
}
——-----------------------------------------------------------
两个对象内存图
public class Phone {
String yanse;
int change;
public void tonghua(String who){
//带参数的
System.out.println("给"+who+"打电话");
}
public void liaotian(){
//不带参数的
System.out.println("吃饭了没！！！");
}
}
public class pho {
public static void main(String[] args){
Phone one = new Phone();
System.out.println(one.yanse);
System.out.println(one.change);
one.yanse="黄色";
one.change=5999;
System.out.println(one.yanse);
System.out.println(one.change);
one.liaotian();
one.tonghua("乔布斯");
Phone two = new Phone();
System.out.println(two.yanse);
System.out.println(two.change);
two.yanse="黄色";
two.change=5999;
System.out.println(two.yanse);
System.out.println(two.change);
one.liaotian();
one.tonghua("欧巴");
}
}
两个引用指向同一对象
对象也可以作为方法的参数
public class Phone{
String yanse;
int change;
public void dianhua(String who){
System.out.println("给"+who+"打电话");
}
public void liaotian(){
System.out.println("hihihi");
}
}
public class Ph{
public static void main(String[] args){
Phone one = new Phone();
one.yanse="土豪金";
one.change=5999;
moth(one); //这里传的是one对象的地址；
}
public static void moth(Phone pm){
//参数是一个对象，Phone出来的pm；pm存储的是one对象的地址
Systrm.out.println(pm.yanse);
System.out.pirntln(pm.change);
}
}
对象作为返回值
当时用一个对象作为返回值的时候，返回值其实就是对象的地址值；
…
pbulic static void main(String[] args){
Phone two = getphone();
System.out.println(two.change);
System.out.println(two.yanse);
}
public static Phone getphone(){
Phone one = new Phone();
one.change=8999;
one.yanse="玫瑰金";
return one;
}
局部变量与成员变量
1.定义位置不一样
局部变量：方法内部
成员变量：方法外部，直接写到了类中；//new …
2.作用范围不一样
局部变量：只有在方法中才能使用，出了方法不能用
成员变量：整个类全部都能用；
3.默认值不一样
局部变量：没有默认值，如果想要使用，必须进行赋值
成员变量：如果没有赋值，有默认值
4.内存位置不一样
局部变量：栈内存中
成员变量：堆内存中
5.生命周期不一样
局部变量：随着进栈诞生，出栈消失
成员变量；随着对象创建而诞生，随着垃圾回收消失；
*方法参数是局部变量
面向对象三大特征：封装、继承、多态
封装性：1.方法就是一种封装
2.关键字privote也是一种封装
//封装就是将一些细节隐藏起来，对外界不可见
prinvate关键字使用
问题描述：定义persion的年龄时，无法阻止不合理的数据设置进来；
解决方案：用prinvate关键字将需要保护的成员变量进行修饰。
一旦修饰，本类当中任然可以直接访问。
但是超出本类就不能直接访问。
间接访问： 定义一对Getter/Setter方法
public class Persion{
String name;
private int age;
public void show(){
System.out.println("我叫" +name",年龄"+age);
}
public void setAge(int num){
if(age<0||age>130)
age=num;
else
System.out.println("输入年龄不合法");
}
public int getAge(){
return age;
}
}
public calss Dem{
public static void main(String[] args){
Person per = new Person();
person.name="赵丽颖";
person.setAge(20);
person.show();
}
}
private练习
public class Student(){
private String name;
private int age;
private boolean male;
public void setName(String nm){
name=nm;
}
public String getName(){
return name;
}
public void setAge(int ae){
age=ae;
}
public int getAge(){
return age;
}
public void setMale(boolean b){
male=b;
}
public boolean isMale(){
return male;
}
}
public calss Demo0{
public static void main(String[] args){
Student stu = new Student();
stu.setName("鹿晗");
stu.setAge(20);
stu.setMale(true);
System.out.println("姓名:"+stu.getName);
System.out.println("年龄:"+stu.getAge);
System.out.println("是不是爷们儿:"stu.isMale);
}
}
this指向
:解决重名问题
public class Person{
String name;//我自己的名字
public void sayHello(String who){
//参数也是name时
System.out.println(who+",你好","我是"+name); //王思聪，你好。我是王思聪
} // 把后面的name改为 this.name. 就行了。就指成员变量我的名字
}
public class Demo1{
public static void main(String[] args){
Person per=new Person();
person.name="王健林";
person.sayHello("王思聪"); //谁调用的方法，谁就是this person调用的方法，this.name就是person.name
}
}
-----------------------------------------------------------------------
构造方法
注意事项：
1.构造方法的名称和所在的类名称完全相同
2.构造方法不写返回类型。
3.构造方法不能return
4.没有编写构造方法时，编译器会送一个方法，什么都不做
5.一旦编写至少一个方法，编译器将不再赠送
public class person {
private String name;
private int age;
public person(){
//这里构造方法
System.out.println("无参构造执行啦");
}
public person(String name,int age){
//构造方法，有参数时可以直接赋值
this.name=name;
this.age=age;
System.out.println("有参构造执行啦");
}
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;
}
}
public class Demo1 {
public static void main(String[] args){
// person per =new person();
System.out.println("++++++++++++");
person per =new person("赵丽颖",20);
System.out.println("姓名："+per.getName()+",年龄"+per.getAge());
per.setAge(22);
System.out.println("姓名："+per.getName()+",年龄："+per.getAge());
}
}
一个标准的类
1.所有成员变量编写都使用private关键字
2.每一个成员变量都编写一个Getter/Setter方法
3.编写一个无参构造
4.编写一个有参构造
其中几个重要的对象在内存中的状态 在主页有专门的博客