java 学习：
面向对象：
- 面向对象的基本概念：
- java是面向对象的程序语言，c是面向过程的程序语言，各有特长。
- 面向对象的三个主要特征：
- 封装性：
对外部不可见，可以保护程序中的某些内容。 - 继承性：扩展功能。
- 多态：方法的重载，对象的多态性。
- 类与对象的关系：
- 面向对象的核心组成部分，就是类与对象。
- 类是对某一事物的描述，是抽象的，概念上的定义；
对象是实际存在的该类事物的每个个体，因而也称为实例（instance）。
- -
- 类的定义：
class定义一个类，
class类名称{
数据类型 属性；
............
public 返回的数据类型 方法名称（参数1，参数2......）{
程序语句；
return 表达式；
}
}
类的名称首字母必须大写！
class Person{
//人中有姓名和年龄两个属性
Srting name; //姓名
int age; //年龄
public void tell(){
System.out.pringln("姓名："+name+"年龄："+age);
}
}
person类图：
第一层表示类的名称，类的名称与之前一样要求开头首字母大写；
第二层表示属性的定义，按照“访问权限 属性名称：属性类型”的格式定义；
第三层表示类中方法的定义，按照“访问权限 方法名称（）：方法返回值”的格式定义
- 对象的声明及使用：
- Person per = new Person();
- 声明对象：Person per,栈内存中声明的，与数组一样，数组名称就保存在栈内存之中， 只开辟了栈内存的对象是无法使用的，必须有其堆内存的引用才可以使用。
实例化对象：
new Person(),在堆中开辟空间，所有的内容都是默认值。类属于引用数据类型，从数组中可以知道，引用数据类型必然存在栈内存-堆内存的引用关系，实际上，在类与对象的使用关系上必然存在这种关系。
使用格式：
调用属性：对象.属性 调用方法：对象.方法()有两种写法：
Person per = new Person（）； per.name = "小明";或
Person per = null; per = new Person(); per.name = "小明"；
注意：
对象是保存在栈内存之中，属性是保存在堆内存之中；
在程序中所有的方法是保存在全局代码区之中的，此区中的内容是所有对象共享的；
在使用对象的时候，对象必须被实例化之后才可以使用；
实例化对象并不止指的是直接通过new关键字实现的，只要其有堆内存的空间指向，则就表示实例化成功。
如果不实例化—则会出现空指向异常，在引用操作中，如果一个对象没有堆内存的引用，而是调用了类中的属性或方法，就会出现此问题；
所谓的引用数据类型，实际上传递的是堆内存的使用权，可以同时为一个堆内存空间定义多个栈内存的引用操作。
总结
- 掌握栈与堆内存的关系；
- 对象保存在栈内存之中，而具体的内容保存在堆内存之中
- 对象间的引用传递，实际上传递的就是堆内存空间的使用权
- 垃圾的产生；
- 面向对象的封装性
封装就是保护内容：保证某些属性或方法不被外部看见。
- 封装的实现：
- 为属性封装：private 属性类型 属性名称
- 为方法封装：private 方法返回值 方法名称（参数列表）{}
- 访问封装的内容：
被封装的属性如果需要被访问，则需要编写setter和getter方法完成；
eg:
private String name;
public void SetterName(String n){ //设置姓名
name = "skye"
}
public void GetterName(){
return name;
}注意：
- 如果年龄设置有问题，则不应该为属性赋值；
- 应在setter方法中加入检验；在getter方法中只是把内容简单的取回；
- 封装性在java中有很多种形式，private只是最基本的一种形式，也是一种比较常见的形式；
- 类中的每一个属性都必须封装；
- 构造方法与匿名对象
- 构造方法的概念及调用时机
什么是构造方法？
只要一有对象产生实例化，就会调用构造方法。
构造方法的定义格式：
class 类名称{
访问权限 类名称（类型1 参数1，类型2 参数2，......）{
程序语句；
....//构造方法没有返回值
}
}
构造方法的申明：
- 构造方法的名称必须与类名称一致；
- 构造方法的申明处不能有任何返回值类型的申明；
- 不能在构造方法中使用return返回一个值；
申明对象时，并不去调用构造方法；
每个类中都会有一个构造方法；
java的操作机制中，如果一个类没有明确的声明一个构造方法，则会自动生成一个无参的什么都不做的构造方法，供用户使用。
构造方法的主要目的是为类中的属性进行初始化。
- 构造方法的重载
- 构造方法与普通方法一样，都是支持重载操作的，只要参数的类型或个数不同，则就可以完成重载操作。
匿名对象的使用
- 匿名：没有名字，在java中如果一个对象只使用一次，则称为匿名对象；
- 所谓的匿名对象就是比之前的对象少了一个栈内存的引用关系。
- 匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。
总结：
- 构造方法的定义及使用原则：
- 对象实例化时必须调用构造方法
- 每个类中都至少有一个构造方法
- 匿名对象：只开辟了堆内存的实例对象
- 类设计分析：
- 根据需求写出类所包含的属性；
- 所有的属性都必须进行封装（private）；
- 封装之后的属性都必须通过setter和getter设置和取得；
- 如果需要可以加入若干构造方法；
- 再根据其他要求添加相应的方法；
- 类中所有的方法都不会直接输出，而是交给北调用处输出。
- String 类：（比较重要）
string有两种比较方式：
- ==用来判断地址空间是否相等，判断的是地址值，比较的地址值；
- 如果判断内容相等与否，则就使用equals（）方法来比较；
- String类的两种实例化方式
在String 中可以直接赋值和new 调用构造方法的方式完成，
String name = “skye”;
表示将一个堆内存空间的指向给了栈内存空间；
- String类的两种比较操作
- 使用直接赋值的方式，只需要一个实例化对象即可，可以有效的节省内存空间，
使用new String（）的方式，开辟了两个内存对象，开发中最好使用直接赋值的方式完成。
String的特点：- 字符串的内容不可改变；改变的是堆内存地址的指向（内存地址的引用关系）；
- StringBuffer()；
- -
- String 的常用方法：
语言的使用文档，，为用户列出了全部的类以及相关的操作及使用方法；
- 字符串与字符数组
一个字符串可以变为一个字符数组，同样，也可以把一个字符数组变为一个字符串。
在String类中提供了以下方法：
1. 将字符串变为字符数组：public char[] toCharArray()
2. 字符数组变为字符串：public String(char[] value) 和
3. public String(char[] value,int offset,int count)
- 从字符串取出指定位置的字符
此方法的返回值一定是一个char类型，public char charAt(int index)
public class StringAPIDemo{
public ststic void main(String args[]){
String str1 = "hello";
System.out.pringln(str1.charAt(3));
}
}
- 字符串与byte数组的转换：
byte数组（字节数组），一般在IO操作中会经常使用到。
字符串变为字节数组：public byte[] getBytes(）
将一个字节数组变为字符串：
将全部字节数组变为String：public String(byte[] bytes)
将部分字节数组变为String：public String(byte[] bytes,int offset,int length)
- 取得一个字符串的长度：public int length()
public class StringAPIDemo{
public ststic void main(String args[]){
String str1 = "hello skye";
System.out.pringln("\""+str1+"\"的长度为：”str1.length());
}
}
注意：
- 在数组中可以使用数组名称.length，而在字符串的操作中一定要记得用（）：字符串.length（）；
- 查找指定的字符串是否存在：
- 从头开始查找：public int indexOf(String str)
从指定位置开始查找：public int indexOf(int ch,int fromIndex)
- 查找的时候方法的返回值是一个字符串的位置，如果查到的话返回字符串的位置，如果没有查到的话，他将返回-1；
- 去掉空格：
- 如果信息由用户输入，可能有空格，需要去掉左右两边的空格，但是在字符串之间的空格是不能去掉的
- 字符截取：
从一个指定的字符串中取出里面的部分内容，
使用方法：
从指定位置开始一直截取到结束位置：public String substring(int beginIndex)
截取指定范围的字符串：public String substring(int beginIndex, int endIndex)
- 拆分字符串：
需要按照指定的字符串去拆分一个字符串：public String[] split(String regex)
- 大小写转换：
转化为大写：public String toUpperCase()
转化为小写：public String toLowerCase()
- 判断是否以指定的字符串开头或结尾：
public boolean startsWith(String prefix)测试此字符串是否以指定的后缀开始。
public boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束。
- 不区分大小写的比较：
equals只能对大小写一致的字符串进行比较，
public boolean equalsIgnoreCase(String anotherString)将此 String 与另一个 String 比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），则认为这两个字符串是相等。的。
- 引用传递
- this 关键字
- 表示类中的属性：
- 使用this调用构造方法：
使用this表示当前对象：
当前对象：当前正在调用方法的对象。
- java集合
作用：存放对象，有时候是容器。
- 数组：缺陷—类型单一，固定长度，无法更改不能知道数组中对象的真实数量。
集合：可变容量的数组，java.util.collection –接口,表示集合
list 接口 有顺序，可以重复
set 接口 没有顺序，不可重复
map 接口 不是collection的子接口，名值对，一次保存2个对象，前面的对象是KEY，后面的对象为value，根据key来获取value。key 不可重复，value可以重复。
类的关系图：
1.向集合中添加对象
collection c1 = new ArryList();
//
- boolean add(E e)–向列表的尾部添加指定的元素（可选操作）。
- boolean 表示是否成功加入。
c1.add(“hello”);
c1.add(new Integer(1));
2.将一个集合中所有的对象加入到另一个集合
collection c2 = new ArryList();
3.清除集合中所有的对象
void clear()
4.比较集合中是否包含指定的对象
boolean contains(Object o)
5.比较集合中是否包含另一个集合的所有内容
boolean containsAll(Collection
package com.skye;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 用一个集合保存十份学生成绩，输出其中不及格的成绩。*/
public class StudentScore {
public static void main(String[] args) {
Collection score = new ArrayList();
score.add(11);
score.add(79);
score.add(80);
score.add(92);
score.add(87);
score.add(79);
score.add(90);
score.add(59);
score.add(60);
score.add(77);
//迭代器来遍历集合
Iterator it = score.iterator();
while(it.hasNext()){
Integer i = (Integer)it.next();
if(i<60){
System.out.println(i+"");
}
}
}
}- List
ArryList –使用数组来实现，
特点：
- 访问元素 快速，改变集合效率低（增加，删除，插入较多）
- 按照序列进行访问的操作多，改变集合内容的操作少的情况下，选择使用该类
- 最常使用LIst集合
- LinkedList
特点：
- 修改集合内容效率高，（增加，删除，插入），资源利用率高
- 根据序列访问效率比较低；
- 修改操作频繁，根据序列查询操作少，选择使用该类
- Vector
古老的list，线程安全，效率低，速度慢
public class CollectionDemo{
public ststic void main(String args[]){
//List 集合 （有序可重复）
List list = new LinkedList();//向List 集合中添加对象，对象的顺序按照添加的顺序 //序列从0开始 list.add("hello"); list.add("world"); list.add("hello"); //2.可以为新添加的对象指定添加的位置 list.add(1,"hehe"); //3.根据对象的序列获取对象 System.out.println(list.get(1)); //4.返回此列表中第一次出现的指定元素的索引 System.out.println(list.IndexOf("hello")); //5.替换list集合的对象 list.set()1,"haha"; System.out.println(list.get(1)); System.out.println(list.get(2)); //6.返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图 List newList = list.subList(0,3); System.out.println(newList.size()); Iterator it = list.iterator(); while(it.hasNext()){ Systom.out.println(it.next()); } } }
collections类–一个工具类
集合的工具类—工具类：其中的方法都是static静态的方法
使用：
reverse(List list)：反转 List 中元素的顺序
sort(List list)：根据元素的自然顺序对指定 List 集合元素按升序排序
//按照对象的自然顺序来排列，（也可以自定义顺序）
Collections.sort(list);
it.list.iterator();
while(it)Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
void copy(List dest,List src)：将src中的内容复制到dest中
练习：
package com.skye1;
/*
* 1.一个饲养员给动物喂食物的例子体现JAVA中的面向对象思想,接口（抽象类）的用处
*/
//1.动物接口 -- interface
interface Animal{
public void eat(Food food);
}
// 第一种动物 -- 狗
class Dog implements Animal{
@Override
public void eat(Food food) {
System.out.println("狗啃"+food.getName());
}
}
// 第二种动物 -- 猫
class Cat implements Animal{
@Override
public void eat(Food food) {
System.out.println("猫吃"+food.getName());
}
}
//2. 食物抽象类 -- abstract
abstract class Food {
protected String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//第一种食物 -- 鱼
class Fish extends Food{
public Fish(String name) {
super();
this.name = name;
}
}
// 第二种食物 -- 骨头
class Bone extends Food{
public Bone(String name) {
super();
this.name = name;
}
}
//4. 饲养员类 --
class Feeder{
//有一个喂养的方法
public static void feed(Animal animal,Food food){
animal.eat(food);
}
}
//5. 测试类 -- 饲养员给动物喂食物
public class TestFeeder {
public static void main(String[] args) {
Feeder feeder = new Feeder();
Animal animal = new Dog();
Food food = new Bone("骨头"); //给狗喂肉骨头
Feeder.feed(animal,food);
animal = new Cat();
food = new Fish("鱼");
Feeder.feed(animal, food); //给猫喂鱼
}
}
扫一扫
1701
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
