数组
* 数组:可以存储多个元素并且多个元素是 同一种类型的容器
*
* 数组的 定义:
* 数据类型[] 数组名;
* 数据类型 数组名[];
*
* 举例:
* int[] a; 定义了一个int类型的数组变量a
* int a[] ; 定义了一个int类型 变量a数组
*
* 这两种方式的定义:虽然写法不一样,并且读法不一样,但是表达的效果一样,都是在定义一个数组,推荐使用第一种方式;
*
*
* 数组的初始化:
* 1)动态初始化: 给数组指定长度,数组中的元素值由系统默认给定
* 2)静态初始化: 给定数组中元素的值,数组的长度由系统给定;
*
*
* 动态初始化:
* 数据类型[] 数组名 = new 数据类型[数组长度] ;
*
* 举例:
* int[] arr = new int[3] ;
* 数组的静态初始化:
* 指定数组的元素,长度由系统给定
*
* 定义个数:
* 原始格式:
* 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
* 简写方式:
* 数据类型[] 数组名称= {元素1,元素2,元素3..} ;
*
* 数组中经常会出现的异常:
*
* ArrayIndexOutOfBoundsException:数组角标越界异常
* 出现的原因:访问了数组中不存在的索引值;
* 解决方案:观察数组中到底有索引值到多少; 数组长度-1
* NullPointerException:空指针异常 (在实际开发中该异常是最多的)
* 出现的原因:对象为null,而开发者还要去使用对象,就会出现问题
* 解决方案:给某个对象进行非空判断,防止程序程序空指针异常
*
* 对于异常:
* 把从头到尾,将遇见到的异常建立文档,
* 出现该异常的原因
* 如何解决异常
*
*
* OOM异常:OutOfMemory:内存溢出 Android 解决加载大量图片的问题:图片加载器:ImageLoader等等
* 举例:
* int[] arr = new int[]{1,2,3} ;
* int[] arr = {1,2,3} ;
*
* 这种方式错误:动静结合 定义数组要么动态初始化,指定长度,要么静态初始化指定数组元素!
* int[] arr2 = new int[3]{1,2,3} ;
面向对象
面向过程:
假设有一个需求:求数组中的最大值;
定义一个数组,静态初始化---->定义一个参照物---->遍历....
给一个需求,对需求分析,然后一步一步进行操作,最终得到某一个结果,整个过程都是自己在完成....
面向对象的思想概述:
思想的特征:
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 = 27 ;
s.gender = "女" ;
s.Id = 007 ;
System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);
//调用Student类中的成员方法
//对象名.成员方法名() ;
s.study();
}
}
匿名对象
* 匿名对象:
* 就是创建对象的时候,没有名字的对象
class Student{
String name ;
int age ;
public void show() {
System.out.println(name+"---"+age);
}
}
//学生类的测试类
public class StudentDemo {
public static void main(String[] args) {
//创建一个学生类对象
Student s = new Student() ;//该对象名s
s.name = "高圆圆" ;
s.age = 28 ;
s.show();
System.out.println("------------------");
//匿名对象(开发中经常使用),没有名字的对象
System.out.println(new Student());//org.westos.noname.Student@70dea4e
new Student().name = "赵又廷" ;
/**
* 匿名对象在实际开发中,只用使用一次,不要使用多次 (可能会造成一个内存溢出的现象);
*/
new Student() ; //一直给堆内存开辟空间
new Student () ;
}
}
形式参数
* 形式参数的问题:
* 如果是基本数据类型,形式参的改变对实际参数没有影响
* 研究引用类型:形式参数的改变会直接影响实际参数
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);
}
}
private关键字
* private的用法:
* 1)被private修饰的只能在本类访问
* 2)可以通过公共的访问public 去间接访问
*
*
*
* 当前成员变量和局部变量名称一致的情况,遵循就近原则
class Demo{
private int num = 100 ;
//成员方法 :公共访问方法
public void method() {
int num = 200 ; //局部变量
System.err.println(num);
}
}
//测试类
public class PrivateDemo {
public static void main(String[] args) {
//创建一个Demo类的对象
Demo d = new Demo() ;
// System.out.println(d.num);//外界不能访问
d.method();
}
}
* 创建一个学生类,
* 成员变量:姓名和年龄
* 测试这个学生类
*
* 分析:
* 刚才通过下面代码给学生的年龄赋值了一个不合理的数据,而这种不合理的数据依然可以被输出出来,有问题!
* 解决方案?
* 在Student类中提供一个针对年龄的判断的一个方法
*
* 虽然提供了这一个方法,但是成员变量在测试类中永远被访问到,针对这种情况:Java提供了关键字:private:私有的
*
* private:体现的也是一种封装思想
* 封装:
* 标准类的写法,将成员变量全部私有化,被private修饰的成员变量只能在本类中访问,可以通过公共的访问方法去访问成员变量
//学生类 class Student{ //实体类 String name ; // int age ; //用private 修饰成员变量 private int age ; public void show() { System.out.println(name+"---,"+age); } //针对年龄进行一个判断 public void ageTest(int age) { if(age <0 || age >120) { System.out.println("该年龄是一个不合理数据...."); } } }
//测试类 public class StudentDemo {
public static void main(String[] args) { //创建一个学生类对象 Student s = new Student() ; s.name = "高圆圆" ; s.age = 27 ;
s.show(); System.out.println("---------------"); s.name = "赵又廷" ; s.age = -30 ; s.show(); s.ageTest(s.age); s.show(); } }
* 写一个手机类
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.setBrand("小米");
p.setPrice(1699);
p.setColor("黑色");
System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
}
}
static关键字
* 定义一个人类
* 成员变量:姓名 年龄 国籍
* 创建了三个Person对象,每一个对象的国籍都是中国,值是重复的,这样的话在堆内存中比较浪费内存空间,不好
*
* 针对这种情况,多个对象对同一个变量进行共享,这个时候Java提供了一个关键字---static: 静态的(共享的)
* 在方法区中:开辟一个静态区域: 都是静态标记
//定义一个人类
class Person{
String name ; //姓名
int age ; //年龄
// String country ; //国籍
//改进:
static String country ;
public Person() {}
//三个参数的构造方法
public Person(String name,int age,String country) {
this.name = name ;
this.age = age ;
this.country = country ;
}
//提供两个参数的构造方法
public Person(String name,int age) {
this.name = name ;
this.age = age ;
}
//show方法的作用:来输出成员变量的值
public void show() {
System.out.println("姓名是"+name+",年龄是:"+age+",国籍是:"+country);
}
}
//测试类
public class StaticDemo {
public static void main(String[] args) {
//创建人类的对象
Person p1 = new Person("西施", 27, "中国") ;
p1.show();
// Person p2 = new Person("杨贵妃",28,"中国") ;
Person p2 = new Person("杨贵妃", 28) ;
p2.show();
// Person p3 = new Person("高圆圆", 27, "中国") ;
Person p3 = new Person("高圆圆", 27) ;
p3.show();
p3.country = "美国" ;
p3.show();
p1.show();
p2.show();
}
}
* 关于static关键字:
* 1)静态随着类的加载而加载
* 2)static优先于对象存在
* 回想:main public static void main(..){...}
*
* 3)static共享数据,可以被多个对象进行共享
* 举例: 饮水机(staticd的:共享的)
* 水杯(不能共享的...)
* 4)如果数据被静态修饰的,它可以被类名直接调用
* 被静态修饰的方法: 类名.方法名()
* 被静态修饰的变量: 类名.变量名;
* static用法:
*
* 一个类中可有静态变量,也可以有非静态
* 可以有静态成员方法,也可以非静态的成员方法
* 静态的方法只能访问静态变量,或者是静态的方法
* 非静态的方法,既可以访问静态变量也可以非静态的变量...
*
* 简单记:静态只能访问静态
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());
}
}
成员方法
* 类的组成中有一个成员:成员方法
* 成员方法的分类:
* 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);
}
}
构造方法
* 构造方法作用:
* 就是给对象进行进行初始化
*
* 构造方法也属于一类的组成:
* 成员变量
* 构造方法
* 成员方法
*
* 构造方法:
* 1)方法名和类名相同
* 2)构造方法,连void都没有
* 构造方法的注意事项:
* 1)之前没有写无参构造,系统会默认提供无参构造
* 2)如果我们无参构造或者有参构造,系统不会在提供无参构造;定义一个类的时候,永远给出无参构造;
*
*
* 构造方法是可以重载的:
//创建一个老师类
class Teacher{
private String name ;
private int age ;
//SetXXX()/GetXXX()方法:公共访问方法
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 Teacher() {
System.out.println("老师类的无参构造..");
}
//有参构造
public Teacher(String name) {
this.name = name;
System.out.println("带一个String类型参数的有参构造");
}
public Teacher(int age) {
this.age =age ;
System.out.println("带一个int类型参数的有参构造");
}
//带两个参数
public Teacher(String name,int age) {
this.name =name ;
this.age = age ;
System.out.println("带两个参数的有参构造...");
}
}
//测试类
public class ConstructorDemo2 {
public static void main(String[] args) {
//创建一个老师类对象
Teacher t = new Teacher() ;
t.setName("张三");
t.setAge(27);
System.out.println(t.getName()+"----"+t.getAge());
System.out.println("----------");
/**
* 给成员变量有两种方式:
* 1)setXXX()公共的访问方法
* 2)可以通过有参构造进行赋值
*/
t = new Teacher("高圆圆") ;
t.setAge(28);
System.out.println(t.getName()+"----"+t.getAge());
System.out.println("----------------");
t= new Teacher(27) ;
t.setName("赵又廷");
System.out.println(t.getName()+"----"+t.getAge());
System.out.println("----------------");
Teacher t2 = new Teacher("高圆圆", 27) ;
System.out.println(t2.getName()+"----"+t2.getAge());
}
}