(一)数组
-
数组:可以存储多个元素并且多个元素是 同一种类型的容器
数组的 定义: 数据类型[] 数组名; 数据类型 数组名[];
举例: int[] a; 定义了一个int类型的数组变量a int a[] ; 定义了一个int类型 变量a数组
这两种方式的定义:虽然写法不一样,并且读法不一样,但是表达的效果一样,都是在定义一个数组,推荐使用第一种方式;
数组的初始化: 1)动态初始化: 给数组指定长度,数组中的元素值由系统默认给定 2)静态初始化: 给定数组中元素的值,数组的长度由系统给定;
动态初始化: 数据类型[] 数组名 = new 数据类型[数组长度] ;
静态初始化: 指定数组的元素,长度由系统给定 定义个数: 原始格式: 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ; 简写方式: 数据类型[] 数组名称= {元素1,元素2,元素3..} ;
注意：数组中经常会出现的异常:
ArrayIndexOutOfBoundsException:数组角标越界异常
出现的原因:访问了数组中不存在的索引值;
解决方案:观察数组中到底有索引值到多少; 数组长度-1
NullPointerException:空指针异常 (在实际开发中该异常是最多的)
出现的原因:对象为null,而开发者还要去使用对象,就会出现问题
解决方案:给某个对象进行非空判断,防止程序程序空指针异常
(二)面向对象
1、讲面向对象之前: 面向过程: 假设有一个需求:求数组中的最大值; 定义一个数组,静态初始化---->定义一个参照物---->遍历.... 给一个需求,对需求分析,然后一步一步进行操作,最终得到某一个结果,整个过程都是自己在完成....
面向对象的思想概述: 思想的特征: 1)面向对象更符合我们的生活中的行为思想习惯 2)面向对象将我们从执行者变成了指挥者,指挥对象做事情 3)面向对象简单性体现在这里:让我们事情从复杂性--->简单化
举例:
洗衣服:
面向过程:脱下脏衣服--->放到一个盆里面--->加水,洗衣液---->泡一泡--->搓一搓---->拧一拧----->
晾一晾
面向对象:脱下脏衣服--->放到一个全自动洗衣机中--->一键---->晾一晾
炒菜:
面向过程:买菜--->摘菜--->洗菜--->切菜--->炒菜--->出锅
面向对象:找一个对象..--->出锅...
举例: 把大象装进冰箱
1)装大象的方法in()
2)开冰箱门:open()
3)关闭冰箱门:close()
面向过程:
class Test{
main(..){
//分别调用三个方法
open();
in();
close();
}
//开冰箱门
public static void open(){
System.out.println("开冰箱门...") ;
}
//装大象
public static void in(){
System.out.println("把大象塞进冰箱") ;
}
//关闭冰箱门
public static void close(){
System.out.println("开冰箱门...") ;
}
}
面向对象:
把大象装进冰箱 : 名词提取法: 大象类,冰箱类,测试类
class 大象类{
public static void in(){
System.out.println("把大象塞进冰箱") ;
}
}
class 冰箱类{
public static void open(){
System.out.println("开冰箱门...") ;
}
public static void close(){
System.out.println("开冰箱门...") ;
}
}
class Test{
main(){
类名.方法名() ;
大象类.in() ;
冰箱类.open();
并迅雷.close() ;
}
}
面向对象的三大特征: 封装 继承 多态 向对象语言中现实世界的事物在代码中如何体现的{
学生
属性:姓名 年龄 性别 ...学号
行为:学习,打游戏....
学生现实世界的事物------>代码 学生类:Student 属性:属性:姓名 年龄 性别 ...学号 成员变量:name,age,sex... 行为:学习,打游戏.... 成员方法:study(),playGame();
总结:
面向对象
:将事物看成XX类,将事物对应的属性--->看成这个类的成员变量
将事物对应的行为----->看成这个类的成员方法
描述一个学生事物, 属性:姓名,年龄,性别,学号 行为:学习
在Java中,创建对象:new对象 **类名 对象名 = new 类名() ; ** public class Student {
//成员变量
String name ;
int age ;
String gender ;
int Id ;
//成员方法:学习的方法
//先去掉static
public void study() {
System.out.println("学生在学习Java.....") ;
}
} }
public class StudentTest {
public static void main(String[] args) {
//创建一个学生对象
// 格式: 类名 对象名 = new 类名() ; Student s = new Student() ; //System.out.println(s);//org.westos.oop.Student@70dea4e 包名.类名@(地址值标记)16进制数据 System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);
//给学生对象进行赋值
s.name = "张三" ;
s.age = 21 ;
s.gender = "男" ;
s.Id = 007 ;
System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);
//调用Student类中的成员方法
//对象名.成员方法名() ;
s.study();
}
} 2、匿名对象 就是创建对象的时候,没有名字的对象 例如： 创建一个有名字的学生类对象 Student s = new Student() ;//该对象名s 匿名对象(开发中经常使用),没有名字的对象 new Student().name = "赵又廷" ; 匿名对象在实际开发中,只用使用一次,不要使用多次 (可能会造成一个内存溢出的现象); new Student() ; //一直给堆内存开辟空间 3、形式参数 形式参数的问题: 如果是基本数据类型,形式参的改变对实际参数没有影响 研究引用类型:形式参数的改变会直接影响实际参数 例如： class Demo{
//求和的成员方法
public int sum(int a,int b) { //形式参数是基本类型 :
return a+b ;
}
}
//一个学生类 class Student{ public void show() { System.out.println("好好学习,天天向上...."); } }
class StudentDemo{
//method方法中形式参数是一个引用类型:需要的是学生类对象 Student s = new Student () ;
public void method(Student s) {//形式参数现在引用类型
s.show();
}
}
//测试类 public class ArgsTest {
public static void main(String[] args) {
//创建Demo类对象
Demo d = new Demo() ;
System.out.println(d.sum(10, 20)) ;
System.out.println("-------------------------");
//需求:调用StudentDemo中的method方法:如何调用
//1)创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
//2)形式参数是Student类型,所以创建Student类的对象
Student s = new Student() ;
sd.method(s);
}
} 4、private关键字 private的用法： 1）被private修饰的只能在本类中访问 2）可以通过公共的访问public 去间接访问
当成员变量和局部变量一致时，遵循就近原则。
列如：
class Phone{
//私有修饰
private String brand ;
private int price ;
private String color ;
//成员方法
//提供公共的访问方法
public void setBrand(String brand) {
brand = brand ;
}
//获取手机品牌
public String getBrand() {
return brand ;
}
public void setPrice(int p) {
price = p ;
}
public int getPrice() {
return price ;
}
public void setColor(String c) {
color = c ;
}
public String getColor() {
return color ;
}
}
//测试类 public class PhoneDemo {
public static void main(String[] args) {
//创建手机类对象
Phone p = new Phone() ;
// p.brand = "" ; 已经被私有化了 // System.out.println(p.brand+"----"+p.price+"---"+p.color); p.setBrand("小米"); p.setPrice(1699); p.setColor("黑色"); System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
}
} 成员变量:姓名和年龄 测试这个学生类
分析: 刚才通过下面代码给学生的年龄赋值了一个不合理的数据,而这种不合理的数据依然可以被输出出来,有问题! 解决方案? 在Student类中提供一个针对年龄的判断的一个方法
虽然提供了这一个方法,但是成员变量在测试类中永远被访问到,针对这种情况:Java提供了关键字:private:私有的
private:体现的也是一种封装思想 封装: 标准类的写法,将成员变量全部私有化,被private修饰的成员变量只能在本类中访问,可以通过公共的访问方法去访问成员变量 5、构造方法以及创建对象的过程 一个标准类的写法: 学生类 成员变量:姓名,年龄,性别 成员方法:set/getXXX() 学习,睡觉...
构造方法:
无参构造:
有参构造
一个标准手机类的写法: class Student{ //成员变量 private String name ; private int age ; private char gender ;
//无参构造方法
public Student() {}
//有参构造
public Student(String name,int age,char gender) {
this.name = name ;
this.age = age ;
this.gender = gender ;
}
//setXXX/getXXX()方法
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 void setGender(char gender) {
this.gender= gender ;
}
public char getGender() {
return gender ;
}
//学习
public void study() {
System.out.println("学生在学习...");
}
public void sleep() {
System.out.println("学生困了,就需要睡觉...");
}
}
//测试类 public class StudentDemo { public static void main(String[] args) {
//方式1:创建学生类对象
//无参构造+set/getXXX()相结合的方式
Student s = new Student() ;
s.setName("高圆圆");
s.setAge(28);
s.setGender('女');
System.out.println(s.getName()+"----"+s.getAge()+"---"+s.getGender());
System.out.println("----------------------------");
//方式2:直接通过有参构造形式
Student s2 = new Student("高圆圆", 27, '女') ;
System.out.println(s2.getName()+"----"+s2.getAge()+"---"+s2.getGender());
}
} 6、static关键字 （1） 定义一个人类 成员变量:姓名 年龄 国籍 创建了三个Person对象,每一个对象的国籍都是中国,值是重复的,这样的话在堆内存中比较浪费内存空间,不好 针对这种情况,多个对象对同一个变量进行共享,这个时候Java提供了一个关键字---static: 静态的(共享的) 在方法区中:开辟一个静态区域: 都是静态标记 （2） 关于static关键字:
1)静态随着类的加载而加载
2)static优先于对象存在
回想:main public static void main(..){...}
3)static共享数据,可以被多个对象进行共享
举例: 饮水机(staticd的:共享的)
水杯(不能共享的...)
4)如果数据被静态修饰的,它可以被类名直接调用
被静态修饰的方法: 类名.方法名()
被静态修饰的变量: 类名.变量名;
（3）static用法: 一个类中可有静态变量,也可以有非静态 可以有静态成员方法,也可以非静态的成员方法 静态的方法只能访问静态变量,或者是静态的方法 非静态的方法,既可以访问静态变量也可以非静态的变量...
简单记:静态只能访问静态
7、this关键字 定义变量,方法,类,接口,做到见名知意 在手机类中的公共的访问方法中,对应局部变量名称应该做到见名知意 虽然做到见名知意了,但是局部变量将成员变量可以隐藏掉,Java提供一个关键字:this this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量 例如： class Phone{
//私有修饰
private String brand ;
private int price ;
private String color ;
//成员方法
//提供公共的访问方法
public void setBrand(String brand) {
// brand = brand ; this.brand = brand; }
//获取手机品牌
public String getBrand() {
return brand ;
}
public void setPrice(int price) {
// price = price ; this.price = price ; } public int getPrice() { return price ; }
public void setColor(String color) {
//color = color ;
this.color = color ;
}
public String getColor() {
return color ;
}
}
//测试类 public class Test {
public static void main(String[] args) {
//创建手机类对象
Phone p = new Phone() ;
p.setBrand("华为");
p.setPrice(1999);
p.setColor("黑白");
System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
System.out.println("-----------------------");
Student s = new Student() ;
s.setName("高圆圆");
s.setAge(28);
s.setsId("xx002");
s.setGender('女');
s.setTitle("学习委员");
System.out.println(s.getName() + "----" + s.getAge() + "----" + s.getsId() + "----" + s.getGender() + "----"
+ s.getTitle());
}
} 8、类的组成中有一个成员：成员方法 成员方法的分类: 1)按照返回值划分 void的形式:没有具体的返回值 非void形式:有具体返回值 2)按照参数进行划分 空参 有参 //创建一个学生类 class Student {
private String name ;
private String age ;
public Student() { //alt+shift+s+c
}
//成员方法
public String show() { //有返回值没有参数的
return "helloworld" ;
}
//没有返回值,有参数的情况
public void method(String s) {
System.out.println(s);
}
//没有返回值,没有参数的情况
public void function() {
System.out.println("function student...");
}
//有返回值,有参数的情况
public String function2(String s1,String s2) {
return s1+ s2;
}
}
//测试类 public class Test {
public static void main(String[] args) {
//创建学生类对象
Student s = new Student() ;
String str = s.show() ;
System.out.println(str);
s.method("Java");
s.function();
String str2 = s.function2("hello", "world") ;
System.out.println(str2);
}
} 9、构造方法 构造方法作用: 就是给对象进行进行初始化 构造方法也属于一类的组成: 成员变量 构造方法 成员方法 构造方法: 1)方法名和类名相同 2)构造方法,连void都没有 构造方法的注意事项: 1)之前没有写无参构造,系统会默认提供无参构造 2)如果我们无参构造或者有参构造,系统不会在提供无参构造;定义一个类的时候,永远给出无参构造; 构造方法是可以重载的:
