java初识面向对象

面向对象

第一次听到这个词 字面意思就是 面对面的对象吗 在深一点就是 从这面指向另一面嘛

举个例子 

你想吃饭了  你要自己买菜 买油，买锅 自己做

 开个饭店 顾个厨师 说我饿了 让厨师去做饭

第一种是面向过程 一步一步来 第二种就叫面向对象 ，今天吃两个菜 名吃一个菜  可以后天吃三个  面向过程就只能做完这个菜以后才能做第二个  面向对象可以直接或间接性做三个菜或者更多，让我们进入代码中来了解真正的面向对象吧

那在java里什么是面向对象呢？

      从我们开始学Java后，接触最多的就是面向对象的语言。万物皆对象嘛，如果面试的时候问你啥叫oop  一脸懵 啥叫oop啊  面向对象就叫oop呗

Oop 全称Object Oriented Programming

面向对象的设计思想

  面向对象的基本思想是，从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类的自然思维方式。

面向对象更加强调运用人类在日常生活的逻辑思维中经常采用的思想方法与原则，如抽象、分类，继承、聚合、多态等。人在思考的时候，首先眼睛里看到的是一个一个的对象。

面向对象的特征

继承：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展，通过继承创建的新类称为“子类”或“派生类”

封装：也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作。

多态：允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

可以用表来说明：

 

每天早上8.20-8.30早读 把这件事告诉 学号 姓名 性别 年级 年龄

在java编程里就是给他定义一个方法  把 早读这个事件 定义起来 这个方法就算是完成了

初步总结

      面向过程就是 事情一部一部来就像做饭一样 什么事都要自己来 是执行者

      面向对象是 把事情分配下去 好多人一起完成 是一种领导者

—————————————————

类和对象的概念

类：class    对象Object,instance：就叫他实例吧  谁谁的对象就等于说谁谁的实例

类：相当于买衣服 我先不在乎买什么颜色样式的衣服

对象：我要买什么样的品牌，颜色等等

物事（买衣服）	类
属性（什么颜色款式）	成员变量
行为  （买去呗）	成员方法

 

方法的定义

[修饰符]  方法返回值类型  方法名(形参列表) {

   // n条语句

}

↓↓↓↓↓↓↓↓↓↓↓↓这是一个买衣服的方法↓↓↓↓↓↓↓↓↓↓↓↓

↑这一个简单的方法代码 方便理解（一会画图）下边就说到构造方法了

public class yifu {    public static void main(String[] args) {       //定义以下衣服的动作       clothes sc=new clothes("蓝色","海澜之家");       sc.buyclothes();// 输出买衣服的方法    } } //要去买衣服了 class clothes{    String color;//颜色    String make;//品牌    public clothes(String color,String make)    {//定义一个构造器（接下来我们会讲到）       this.color=color;       this.make=make;    }    public void buyclothes()//买衣服    {       System.out.println("我要买"+color+"的"+make+"品牌的衣服");    }  }

构造方法(构造器 constructor)

构造方法

      构造方法负责对象的初始化工作，为实例变量赋予合适的初始值。必须满足以下的语法规则

方法名与类名相同； 不要返回类型（例如return、void等）； 不能被static、final、native、abstract和synchronized修饰，不能被子类继承

1.构造方法的基本用法

构造器也叫构造方法(constructor)，用于对象的初始化构造器是一个创建对象是被自动调用的特殊方法，目前是对象的初始化。构造器的名称应与类名相同。Java通过new关键字来调用构造器，从而返回该类的实例，是一种特殊的方法。

 

构造器4个要点：

①构造器通过new关键字调用！！

②构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。

③如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加！

④构造器的方法名必须和类名一致！

 

int x;   public void 类名 ()//空构造器   {//一般系统会自动添加 但我们还是要写上尾号        }   public void 类名(int x)//带参数的   {      this.x=x;   }

 

2.构造方法的重载

构造方法也是方法，只不过有特殊的作用而已。与普通方法一样，构造方法也可以重载。 通过new创建对象后，在不同的条件下，对象可能会有不同的初始化行为，可以通过重载构造方法来表达对象的初始化行为。具体参考this关键字用法

 

 

继承

      动物分 海洋生物和陆地生物 和陆地海洋两栖动物

海洋又分淡水河还说之分  陆地又分猫科动物和哺乳动物之分

淡水鱼                                 猫咪狗                 人猩猩

 

继承 ： extends （子类可以继承父类的属性和方法，但构造方法不能继承）
public class Student extends Person{}
9.super关键字 用来解决父类提供了带参构造方法，子类报错的问题

public class Student extends Person{
public Student(String name){
super(name);
}

car继承父类Animal

public class car extends Animal {

 

  //显示构造器

  public car(String name,int age)

  {

     super(name,age);

  }

  //重写父类的say方法

  public void say()

  {

     System.out.println(name+"的"+age+"叫");

  }

 

}

• ·

自己理解的继承是子类可以用父类的静态方法 索然都可以继承但不是所有的方法都是可以用的

重点

父类也称作超类、基类。子类：派生类等。

Java中只有单继承，没有像C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。

Java中类没有多继承，接口有多继承。

子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。

如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object

 

重写override

在继承关系中，子类重写父类方法，方法名，参数列表，返回值都要一致

子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件

“= =”： 方法名、形参列表相同。

“≤”：返回值类型和声明异常类型，子类小于等于父类。

“≥”：    访问权限，子类大于等于父类。

public class Student extends Person{
private int score;
public int getScore(){
return score;
}
public void setScore(int score){
this.score = score;
}
public void info(){
System.out.println("我叫"+name+",成绩是"+score);
}

}

——————

  public class a {

• ·          public static void main(String[] args) {
•                

          name("李卫东");

•         age(18);
•         adress("啊啊啊啊啊啊啊啊啊啊啊啊 啊啊啊 啊啊啊 啊啊啊啊啊啊啊");
•         ah("玩游戏");
•         }
•         //兴趣爱好
•         //姓名年龄 家庭地址
•         public static void name(String name) //姓名
•         {
•                 System.out.println("我叫"+name);
•         }
•         public static void age(int age)//年龄
•         {
•                 System.out.println("我今年"+age);
•         }
•         public static void adress(String adress)//地址
•         {
•                 System.out.println("我家住"+adress);
•         }
•         public static void ah(String ah)//爱好
•         {
•                 System.out.println(ah);
•         }
• ·  }

 

Final 固定的 这个定义变量

final关键字 （不变） 
final修饰的变量叫常量，不可改变
final修饰的方法不可被重写
final修饰的类不能被继承

final  int   aaa= 120;

 

在程序里边 final 是不可改变的 常量是不可变得

继承和组合这块不太理解 下去学习学习在写

封装(encapsulation)

把东西的内部包装起来  支给别人怎么用看不到内部结构。就像汽车一样会开就行 他的制造过程就可以理解为封装

提高代码的安全性。

提高代码的复用性。

“高内聚”：封装细节，便于修改内部代码，提高可维护性。

“低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

class Person {

         String name;

         int age;

         @Override

         public String toString() {

                   return "Person [name=" + name + ", age=" + age + "]";

         }

}

public class Test {

         public static void main(String[ ] args) {

                   Person p = new Person();

                   p.name = “李卫东”;

                   p.age = -1;//封装这个年龄只能是整数而且不能太大

if(age<=0)

{

System.out.println(“请输入正确的年龄”);

}

                   System.out.println(p);

         }

}

多态polymorphism

public class Animal {

//成员属性

  public String name;

  public int age;

  //现实构造器

  public  Animal(String name,int age)

  {

     this.name=name;

     this.age=age;

  }

  //成员方法

  public void say()

  {

     System.out.println(age+"岁的"+name+"叫");

  }

}

 

 

public class car extends Animal {

  //显示构造器

  public car(String name,int age)

  {

     super(name,age);

  }

  //重写父类的say方法

  public void say()

  {

     System.out.println(name+"的"+age+"叫");

  }

 

}

public class Demo01 {

  public static void main(String[] args) {

     //实例化Animal对象

  /* Animal sc= new Animal("孙王",20);

 

     sc.say();

     car sc2=new car("sad",54);

     sc2.say();

     dog sc3=new dog("sad ",88);

     sc3.say();*/

     Animal sc= new dog("a ",48);

     sc.say();

     Animal sc1=new car("b",18);

     sc1.say();

    

  }

}

抽象类和接口

抽象类是什么？

当需要定义子类的具体行为，又要为子类提供共性功能时；所定义的抽象类。

 

抽象类的特点，好处？

A、只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。

B、之所以要继承自抽象类，面对一些共性的操作会更简单，实现具体功能就可以了；所以抽象类一定是个父类。

C、抽象类中是可以不定义抽象方法的，目的是不让该类去创建对象，抽象类中的方法可以通过被继承然后子类去使用。

D、abstract和private是不能同时用于一个类中的。

E、抽象类中不一定有抽象方法；如果一个类中有至少一个抽象方法，那么这个类一定是抽象类。

F、抽象类是一种特殊的普通类。

//抽象类

abstract class Animal {

       abstract public void shout();  //抽象方法

}

class Dog extends Animal {      

       //子类必须实现父类的抽象方法，否则编译错误

       public void shout() {

              System.out.println("狗叫！");

       }

       public void Door(){

              System.out.println("看门呢");

       }

}

//测试抽象类

public class TestAbstractClass {

       public static void main(String[ ] args) {

              Dog a = new Dog();

              a.shout();

              a.Door();

       }

}

抽象类的使用要点:

1. 有抽象方法的类只能定义成抽象类
2. 抽象类不能实例化，即不能用new来实例化抽象类。
3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
4. 抽象类只能用来被继承。
5. 抽象方法必须被子类实现。

接口

接口的特点

• A、接口中定义的方法必须用public abstract来修饰；且接口不可以创建对象
• B、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

接口有啥用（接口解决什么问题？）

A、最重要的用途：解决多继承的弊端；一个类可以实现接口A和接口B，假如A和B中有同一个抽象方法，由子类C去实现方法体，只实现一个，这样就不会出现二义性了。接口的出现避免了单继承的局限性。

B、解释一下Java为什么不支持多继承：假如子类同时继承自父类A和父类B，二者拥有一个相同的方法，此时在调用时无法确定调用哪一个，会出现二义性。

C、当一个类继承自某个类，但是它的功能还不完善，这时就要实现一个（或者多个）接口来拓展额外功能。（拓展功能！）

D、接口的出现降低了耦合性，即设备与设备之间实现了解耦。

优先用接口少用抽象类

字符串String

字符串没啥好说的会用就行

字符串是一个很特殊的数据类型

String类又称作不可变字符序列。

String位于java.lang包中，Java程序默认导入java.lang包下的所有类。

Java字符串就是Unicode字符序列，例如字符串“Java”就是4个Unicode字符’J’、’a’、’v’、’a’组成的。

Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。

String a = ""   空字符串;

String greeting = " Hello World ";

String s1 = "Hello";

String s2 = "World! ";

String s = s1 + s2; //HelloWorld!

下载API

int indexOf(String str)	返回从头开始查找第一个子字符串str在字符串中的索引位置。如果未找到子字符串str，则返回-1。
lastIndexOf()	返回从末尾开始查找第一个子字符串str在字符串中的索引位置。如果未找到子字符串str，则返回-1。
int length()	返回字符串的长度。
String replace(char oldChar,char newChar)	返回一个新串，它是通过用 newChar 替换此字符串中出现的所有oldChar而生成的。
boolean startsWith(String prefix)	如果字符串以prefix开始，则返回true。
boolean endsWith(String prefix)	如果字符串以prefix结尾，则返回true。
String substring(int beginIndex)	返回一个新字符串，该串包含从原始字符串beginIndex到串尾。
String substring(int beginIndex,int endIndex)	返回一个新字符串，该串包含从原始字符串beginIndex到串尾或endIndex-1的所有字符。
String toLowerCase()	返回一个新字符串，该串将原始字符串中的所有大写字母改成小写字母。
String toUpperCase()	返回一个新字符串，该串将原始字符串中的所有小写字母改成大写字母。
String trim()	返回一个新字符串，该串删除了原始字符串头部和尾部的空格。

public class StringTest1 {        public static void main(String[ ] args) {               String s1 = "core Java";               String s2 = "Core Java";               System.out.println(s1.charAt(3));//提取下标为3的字符               System.out.println(s2.length());//字符串的长度               System.out.println(s1.equals(s2));//比较两个字符串是否相等               System.out.println(s1.equalsIgnoreCase(s2));//比较两个字符串（忽略大小写）               System.out.println(s1.indexOf("Java"));//字符串s1中是否包含Java               System.out.println(s1.indexOf("apple"));//字符串s1中是否包含apple               String s = s1.replace(' ', '&');//将s1中的空格替换成&               System.out.println("result is :" + s);        } }

public class StringTest2 {        public static void main(String[ ] args) {               String s = "";               String s1 = "How are you?";               System.out.println(s1.startsWith("How"));//是否以How开头               System.out.println(s1.endsWith("you"));//是否以you结尾               s = s1.substring(4);//提取子字符串：从下标为4的开始到字符串结尾为止               System.out.println(s);               s = s1.substring(4, 7);//提取子字符串：下标[4, 7) 不包括7               System.out.println(s);               s = s1.toLowerCase();//转小写               System.out.println(s);               s = s1.toUpperCase();//转大写               System.out.println(s);               String s2 = "  How old are you!! ";               s = s2.trim();//去除字符串首尾的空格。注意：中间的空格不能去除               System.out.println(s);               System.out.println(s2);//因为String是不可变字符串，所以s2不变        } }

 

 

一个字符串练习的链接

https://www.cnblogs.com/xyg-zyx/p/9824442.html

                                                   结

 

转载于:https://www.cnblogs.com/lwd521/p/11445653.html