1.面向对象思想
*· 物以类聚,分类的思想模式,思考问题首先会解决问题需要哪些分类,然后对这些分类
进行单独思考.最后.才对某个分类下的细节进行面向过程的思索
*·面向对象适合处理复杂的问题,适合处理需要多人协作的问题
对于描述复杂的事物,为了从宏观上把握,从整体合理分析,我们需要使用面向对象的思路来分析整个系统.但是具体到微观操作,仍然需要面向过程的思路去处理
面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据.
抽象
*封装
*继承
*多态
从代码运行角度考虑是先有类后有对象. 类是对象的模板.
package 面向对象;
//oop 类
public class oop1 {
public static void main(String[] args) {
int max=max(10,20);
System.out.println(max);
}
/*
* 修饰符 返回值 方法名(...){
* 方法体
* return 返回值;
* }
*/
public String Hello(){
return "Hello";
}
public static int max (int a , int b ) {
if (a>b){
return a;
} else return b;
}
} // void 返回值为空
1.调用
静态方法可以直接调用 类名. 方法名
1.非静态
如果他俩同为 static可以调用
如果一个是static 一个 不是static 则不可以调用
static是和类一起加载的 B 是实例化之后才存在的
2.形参和实参
package 面向对象;
public class oop3 {
public static void main(String[] args) {
int sum= (int) sum(20,30);
//实际参与的数字就是实参
System.out.println(sum);
}
public static double sum (int C , int D) {
//形式设计的 数值就是形式参数
return C+D;
}
}
3.值传递
package 面向对象;
//值传递
public class oop4 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
oop4.change(a);
System.out.println(a);
}
public static void change(int a) {
a =10;
}
}
4.引用传递**
package 面向对象;
//引用传递:对象 ,本质还是直传递
public class oop5 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
oop5.change(person);
System.out.println(person.name);//小学生
}
public static void change(Person person) {
person.name ="小学生";
}
}
//定义一个person类, 有一个属性:name
class Person{
String name;
}
2.类和对象的关系
1.类是一种抽象的数据类型,它是对某一类事物整体的描述/定义,但是并不能代表某一具体的事物
2.对象是抽象概念的具体实例
能够体现出特点,展现出功能的是具体的实列,而不是一个抽象的概念
1.创建与初始化对象
1.使用 new 关键字创建对象
2.使用new关键字创建是时候,除了分配内存空间之外,还会给创建好的对象 进行默认的初始化 以及对类中构造器的调用
3.类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的.并且构造器有以下两个特点.
1.必须和类的名字相同
2.必须没有返回类型, 也不能写void
package 面向对象;
//一个项目只能处在一个mian方法
public class Application {
public static void main(String[] args) {
// 类:抽象的 ,实例化
// 类实列化后会返回一个自己的对象!
//student对象就是一个Student类的具体实列
Student xiaohong = new Student();
Student xiaoming = new Student();
//student 他是一个类 不是具体的一个值
xiaoming.name="小明";
xiaoming.age=10;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
package 面向对象;
//学生类
public class Student {
//属性 :字段
String name;//默认值 null //是一个抽象的概念一个模板
int age; //默认值 为0 //是一个抽象的概念一个模板
//方法
public void student(){
System.out.println(this.name + "学生说话了");
?
}
}
2.构造器
无参构造
先走new persion 在走public persion ---- this name ----在返回 给name
有参构造
new persion 定义了一个name 就走有参构造
Alt+ insert 生成构造器
构造器 :
1.和类名相同
2.没有返回值
作用 :
1.new 本质在调用构造器
2.初始化对象的值
注意点
1.定义有参构造器之后,如果想使用无参构造,显示的定义一个无参的构造
this. 标识这个类
后面this.= 什么 表示传进来的
3.创建对象内存分析
4.封装
高内聚 低耦合
高内聚:就是类的内部数据作细节自己完成,不允许外部干涉
低耦合:仅暴露少量的方式给外部使用
封装
通常,应禁止直接访问一个对象中数据的实际表示 ,而应通过操作访问,这称为信息隐藏
属性私有
get / set
get
set
ALT + insert 只动生成get set 方法
封装的意义
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.增加了系统可维护
package 面向对象;
public class Application {
public static void main(String[] args){
Student student = new Student();
student.getName();
student.setName("小学生");
System.out.println(student.getName());
student.getAge();
student.setAge(70);
System.out.println(student.getAge());
}
}
package 面向对象;
//学生类
public class Student {
//private 属性私有
private String name;
private int age;
private int ID;
//提供一些 可以操作这个属性的方法
//提供一些 public 的get . set 方法
// get 获得这个数据
public String getName() { //获取值不能用void
return this.name;
}
// set 给这个数据设置值
public void setName(String name){
//括号里要有调用的形势参数
this.name=name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120 || age<0){
System.out.println("年龄不合法");
}else
this.age = age;
}
}