1.Tcp协议发送数据

当使用tcp发送数据的时候必须的有服务器端,当第一次执行客户端代码会报如下错误

java.net.ConnectException: Connection refused: connect 连接被拒绝

代码实现

[1]客户端代码

public class Client {

public static void main(String[] args) throws Exception{

//1.创建socket的实例

Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);

String data = "tcp我来了";

//2.返回此套接字的输出流。通过输出流向服务器发送数据

socket.getOutputStream().write(data.getBytes());

//3.关闭socket

socket.close();

}

[2]服务器代码

public class ServerClient {

public static void main(String[] args) throws Exception{

//1.创建serversocket对象

ServerSocket ss = new ServerSocket(9999);

//2.侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。 这个对象其实就是发送端的socket对象

Socket socket = ss.accept();

//3.获取客户端发送的数据要使用输入流

InputStream is = socket.getInputStream();

//4.把数据读取出来

int len =0;

byte buf[] = new byte[1024];

while((len = is.read(buf))!=-1){

String str = new String(buf,0,len);

System.out.println("服务器:"+str);

}

ss.close();

}

2.客户端发送数据数据来自键盘录入

public class Client {

public static void main(String[] args) throws Exception{

//1.创建socket的实例

Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);

// String data = "tcp我来了";

Scanner scanner = new Scanner(System.in);

while(scanner.hasNext()){

String data = scanner.nextLine();

//1.1 当用户输入的是886 跳出while循环

if ("886".equals(data)) {

break;

}

//2.返回此套接字的输出流。通过输出流向服务器发送数据

socket.getOutputStream().write(data.getBytes());

}

scanner.close();

//3.关闭socket

socket.close();

}

3.文件上传核心逻辑

朋友圈,百度网盘 360云盘.邮箱-->上传附件

代码实现:

[1]客户端代码

public class Client {

public static void main(String[] args) throws Exception{

//1.创建socket的实例

Socket socket = new Socket(InetAddress.getByName("192.168.126.26"),9999);

//2.先读取abc.txt文件内容

FileInputStream fis = new FileInputStream("abc.txt");

int len=0;

byte buf[] = new byte[1024];

while((len=fis.read(buf))!=-1){

//2.返回此套接字的输出流。通过输出流向服务器发送数据

socket.getOutputStream().write(buf, 0, len);

}

fis.close();

//3.关闭socket

socket.close();

}

[2]服务器代码

public class ServerClient {

public static void main(String[] args) throws Exception{

//1.创建serversocket对象

ServerSocket ss = new ServerSocket(9999);

//2.侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。 这个对象其实就是发送端的socket对象

Socket socket = ss.accept();

//3.获取客户端发送的数据要使用输入流

InputStream is = socket.getInputStream();

FileOutputStream fos =new FileOutputStream("abcd.txt");

//4.把数据读取出来并写到指定文件中

int len =0;

byte buf[] = new byte[1024];

while((len = is.read(buf))!=-1){

fos.write(buf, 0, len);

}

fos.close();

ss.close();

}

总结 :客户端上传的是什么文件类型服务器接收的就应该是什么格式.

udp:datagramSocket DatagramPacket

tcp :socket serversockete

4.枚举(1.5)

枚举应用场景,比如我要定义一个星期(1-7)变量四季(春夏秋冬) 交通灯(红绿黄)

我使用一个普通类来模拟枚举的功能.

package com.itheima.enumtest;

//普通类来模拟枚举功能模拟星期

//枚举只能是固定的几个实例

public abstract class WeekDay {

//1.构造方法私有化

private WeekDay(){}

//2.自己创建几个实例 {}代表通过该类的子类完成实例化就是实现父类为实现的方法

public static WeekDay mon = new WeekDay(){

@Override

public WeekDay nextDay() {

return sun;

}

};

public static WeekDay sun = new WeekDay(){

@Override

public WeekDay nextDay() {

return mon;

}

};

//3.定义一个方法 nextDay //Perosn

/*public WeekDay nextDay(){

if (this == mon) {

return sun;

}else if (this == sun) {

return mon;

}else {

return null;

}

}*/

//4.为了简化if else 语句我这样定义

public abstract WeekDay nextDay();

//3.默认打印实例打印地址重写toString方法 alt + shift + s

@Override

public String toString() {

if (this == mon) {

return "mon";

}else if (this == sun) {

return "sun";

}else{

return "";

}

如何定义枚举. class interface enum 实现带抽象方法的枚举

public enum Weekday {

// 这个成员默认是静态:

SUN, MON(2), TUE, WED, THRI, FRI(50), SAT;

// 1.定义构造方法

private Weekday() {

System.out.println("1111");

}

//2.定义一个带参数的构造方法

private Weekday(int day) {

System.out.println("22222");

}

带抽象方法的枚举

public enum TrafficLamp {

RED{

@Override

public TrafficLamp nextLamp() {

return TrafficLamp.GREEN;

}

},GREEN{

@Override

public TrafficLamp nextLamp() {

return YELLOW;

}

},YELLOW{

@Override

public TrafficLamp nextLamp() {

return TrafficLamp.RED;

}

};

//定义下一个灯

public abstract TrafficLamp nextLamp();

}

5.单例设计模式

单例设计模式特点: 在内存中只有一个实例存在.

5.1饿汉式代码写法

//想保证student对象在内存中只有一个实例

//单例设计模式分类饿汉式懒汉式

public class Student {

//1.构造方法私有化

private Student(){}

//2.自己创建一个实例李四

private static Student s = new Student();

//3.对外提供一个获取实例的方法

public static Student getStudent(){

return s;

}

5.2 懒汉式代码写法

public class Teacher {

//1.构造方法私有化

private Teacher(){}

//2.自己先不创建先声明

private static Teacher t;

//3.提供一个方法获取teacher的实例 t1 t2 t3

public synchronized static Teacher getTeacher(){

if (t == null) {

t = new Teacher();

}

return t;

}

6.工厂设计模式

工厂设计模式可以负责对象的创建对实例创建进行封装.

代码实现过程

1.先定义一个猫和狗的实例

//定义一个猫类

public class Cat extends Anim{

//提供一个吃的方法

public void eat() {

System.out.println("鱼");

}

//定义一个狗类

public class Dog extends Anim{

//提供一个吃的方法

public void eat() {

System.out.println("肉");

}

2.由于猫和狗都是动物所以向上抽取了一个动物类

//抽象一个动物类提供一个吃的方法

public abstract class Anim {

public abstract void eat();

}

3.创建一个工厂这个工厂负责猫和狗对象的创建

//这个类就负责猫和狗的创建

public class AnimFactory {

//1.不需要提供new对象的方式获取工厂的实例所以构造方法私有化

private AnimFactory(){};

//2.对外提供一个创建猫和狗实例的方法参数代表获取动物的类型

public static Anim getAnim(String type) {

if ("dog".equals(type)) {

return new Dog();

}else if ("cat".equals(type)) {

return new Cat();

}else {

return null;

}

7.模板设计模式

代码实现过程

1.定义一个计算时间模板

public abstract class GetTime {

//获取一段逻辑执行需要的时间这个方法相当于是一个计算时间的模板

public long getCodeTime(){

//1.获取当前系统的时间

long startTime = System.currentTimeMillis();

code(); //具体要计算的业务逻辑让子类去实现

//2.在获取一下系统时间

long endTime = System.currentTimeMillis()-startTime;

return endTime;

}

public abstract void code();

}

2.定义for循环执行1000万次需要的时间

public class GetForTime extends GetTime {

@Override

public void code() {

//1.1 算出 for循环需要多长时间

for (int i = 0; i < 10000; i++) {

System.out.println(i);

}

3.定义拷贝视频的逻辑

public class GetCopyVideoTime extends GetTime {

@Override

public void code() {

//这里写拷贝视频的逻辑

//1.2 算出拷贝一段视频需要多长时间

try {

FileInputStream fis = new FileInputStream("test.avi");

FileOutputStream fos = new FileOutputStream("copy.avi");

//流对接操作

int len =0;

byte[] buf = new byte[1024];

while((len=fis.read(buf))!=-1){

fos.write(buf, 0, len);

}

fis.close();

fos.close();

} catch (Exception e) {

e.printStackTrace();

}

8.适配器设计模式

代码实现过程

1.定义一个接口接口里面有4个方法

public interface User {

public void add();

public void del();

public void update();

public void query();

}

2.定义一个适配器类 Adapter 默认实现这个接口

public class Adapter implements User {

@Override

public void add() {

}

@Override

public void del() {

}

@Override

public void update() {

}

@Override

public void query() {

}

3.定义一个具体的实现类来继承Adapter类用到哪个方法就重写哪个方法

public class UserImp2 extends Adapter {

@Override

public void add() {

super.add();

}

9. 装饰设计模式

去4s店买个车宝马x5 买房毛坯房手机(诺基亚) 打电话.

代码实现过程

1.定义一个接口接口里面有个一个打电话功能

public interface Phone {

public void call();

}

2.向上抽取了一个基本的装饰类基本的装饰类要保证有通话功能

public abstract class BaseDecorate implements Phone {

//子类在装饰的时候要保证有基本的通话功能

private Phone p;

public BaseDecorate(Phone p){

this.p = p;

}

@Override

public void call() {

this.p.call();

}

3.在定义具体的装饰类比如播放音乐加彩铃

public class MusicDecorate extends BaseDecorate {

public MusicDecorate(Phone p) {

super(p);

}

@Override

public void call() {

super.call();

System.out.println("手机可以听音乐了");

}

4.定义一个测试类就可以了

public class TestPhone {

public static void main(String[] args) {

//1.手机可以通话了

Iphone iphone = new Iphone();

iphone.call();

System.out.println("-------------");

//2.对手机进行装饰 加彩铃 播放音乐 播放视频 不管对手机怎么装饰 都要保证电话的基本功能

RingDecorate ringDecorate = new RingDecorate(iphone);

ringDecorate.call();

System.out.println("---------***----");

//3.对iphone继续装饰加音乐

MusicDecorate musicDecorate = new MusicDecorate(iphone);

musicDecorate.call();

}

总结设计模式:

1 单例(必须会)

2 工厂设计模式(必须会)

3 模板设计模式(了解)

4.适配器设计模式(必须会)

5.装饰设计模式(了解)

10.Class介绍

黑人白人黄人---->人宝马奥迪奔驰 QQ H6(油老虎)--->car String list Map .....>Class

一个Class里面应该有什么呢构造方法属性(成员) 方法

获取一个类的Class对象的三种方式:

public class TestClass {

public static void main(String[] args) throws Exception{

String str = "abc";

//1.获取str 对应的Class对象

Class class1 = str.getClass();//补充：需要写实例，麻烦

//2.类名.class 只要是在java中你能想到的任何类型都会有一份字节码对象

Class class2 = String.class;//还需要引个包

//3.Class.forName(); 获取Class对象

Class class3 = Class.forName("java.lang.String");//所以一般用这个

System.out.println(class1 == class2);

System.out.println(class2 == class3);

}

11.反射

反射概念:反射就是把java中相应的成分(构造方法成员方法)映射成相应的类.

11.1获取person类中构造方法

//获取带私有的构造方法

private static void method2() throws Exception{

//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

//2.获取person类中所有的构造方法

Constructor[] declaredConstructors = class1.getDeclaredConstructors();

//3.遍历

for (Constructor constructor : declaredConstructors) {

System.out.println(constructor);

}

//alt + shift + M 快速抽取一个方法获取person类中构造方法不包含私有的

private static void method1() throws ClassNotFoundException {

//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

//2.获取person类中所有的构造方法

Constructor[] constructors = class1.getConstructors(); //私有获取不到

//3.遍历数组

for (Constructor constructor : constructors) {

System.out.println(constructor);

}

11.2获取person类中单个空参构造方法并且实例化

//获取person类中 public Person(){};

private static void method3() throws Exception{

//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

//2.获取 public Person(){};构造方法参数:可变参数

Constructor constructor = class1.getConstructor(); //这个类的实例就代表构造方法

//3.通过构造方法获取person的实例

Object object = constructor.newInstance();

System.out.println(object);

}

11.3 获取person类中单个带参构造方法并且实例化

//获取person类中单个带参构造方法并且实例化

private static void method4() throws Exception{

//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

//2.获取 public Person(String name,int age,String address);

Constructor constructor = class1.getConstructor(String.class,int.class,String.class);

//3.通过构造方法获取person的实例

Object object = constructor.newInstance("zhaowei",20,"沙河");

System.out.println(object);

}

11.4获取person类中私有的构造方法

//获取person类中私有的构造方法

private static void method5() throws Exception{

//1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

//2.获取私有的构造方法 private Person(String name)

Constructor constructor = class1.getDeclaredConstructor(String.class);

//3.暴力反射 其实就是调用一个方法 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查

constructor.setAccessible(true);

//3.通过构造方法获取person的实例

Object object = constructor.newInstance("柳岩");

System.out.println(object);

}

11.5 获取person类中成员(属性并且使用)

// 获取所有的属性包括私有的

private static void method2() throws Exception{

// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

// 2.获取person类中所有的属性

Field[] declaredFields = class1.getDeclaredFields();

//3.遍历

for (Field field : declaredFields) {

System.out.println(field);

}

// 获取person类中所有的属性

private static void method1() throws Exception {

// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

// 2.获取person类中所有的属性 (不要考虑私有)

Field[] fields = class1.getFields();

// 3.遍历

for (Field field : fields) {

System.out.println(field);

}

11.6获取单个属性并且使用

//获取person类中address属性并且

private static void method3() throws Exception{

// 1.获取person类的字节码对象(Class) 参数1:要反射类的完整包名类名

Class class1 = Class.forName("com.itheima.classtest.Person");

//2.获取address属性并且使用参数:获取哪个属性

Field field = class1.getField("address");

//3.通过构造方法获取person的实例

Constructor constructor = class1.getConstructor();

Object obj = constructor.newInstance();

System.out.println("---"+obj);

//3.给address属性赋值参数1:代表person的实例

field.set(obj, "上海");

System.out.println(obj);

}

12.今天总结

1.tcp协议了解 ☆

2.枚举 ☆ ☆ ☆

3.单例 ☆ ☆ ☆

4.工厂 ☆ ☆ ☆

5.适配器 ☆ ☆ ☆

6.模板 ☆ ☆

7.装饰 ☆

8.Class类 ☆ ☆ ☆

9.反射 ☆ ☆ ☆

复习：

1.枚举：（具体见day2——4）

原理模拟：枚举就是一个把构造方法私有的抽象类。

私有构造方法是为了不让别人通过new随意建立对象，而只能通过类名调用在本身已经定义好的对象（所以在本类中新建对象时必须用static修饰）。

抽象是为了方法实现。

方法实现：先在本类中定义一个抽象方法，新建对象时通过加{匿名内部类类型的子类}实现抽象方法。

2.单例设计模式：（day2——5）

原理：

懒汉式：私有化构造，直接new对象，对外提供获取方法；

饿汉式：私有化构造，先定义对象，但是不初始化。在获取方法里面判断对象是否为空，为空再新建。

（饿汉式容易出现线程安全问题，获取方法上要加synchronize，一般不用饿汉式，两种方法的构造都要加static，因为要让外界直接调用）

3.工厂设计模式：（day2——6）

原理：抽取各个对象类的共性，建立一个抽象的父类，再用一个工厂对调用方法加工（工厂获取客户需求，内部调用对象并反馈）。

4.模板设计模式：

原理：做一个模板，用子类继承模板，并覆盖部分方法，以实现特殊功能。

5.适配器设计模式：

原理：先做一个接口，然后用一个适配器实现接口中所有的方法，但是方法的内容为空，当有需要用到这些方法的时候，再新建一个类继承适配器并覆盖

需要用到的方法

6.反射：

原理：反射就是把java中相应的成分(构造方法成员方法)映射成相应的类.

1. 构造方法反射成 constructor类

① 获取单个用 get Constructor ( 参数类型.参数名如：原构造是 String a 在这里变为---> String.class )方法，获取多个用 get Constructor

② 如果要获取私有的，用 getDeclared Constructors (),

getDeclared Constructor (参数类型.class,...）如：原构造是 String a 在这里变为---> String.calss

私有需要暴力反射： constructor.setAccessible(true);

例子：演示获取空参构造并实例。（里面是可以加参数的，下面的例子是空参的例子。）

Constructor constructor = class1 . getConstructor ();

Object obj = constructor . newInstance ();实例化

2. 成员反射成 field类

① 获取单个用getField(里面加需要获取的成员名，+加引号)方法，获取多个用getFields

② 如果要获取私有的，用 getDeclaredFields(), getDeclaredField("成员名")

获取单个并实例化，用

1. 获取空参构造实例。

Constructor constructor = class1 . getConstructor ();

Object obj = constructor . newInstance ();

2.通过set，给空参实例赋值成员属性。

field . set ( obj , "上海" );

System . out . println ( obj );

3. 方法反射成 method类

同上： getDeclaredMethod， getDeclaredMethods, getMethod， getMethods

12.今天总结

1.tcp协议了解 ☆

2.枚举 ☆☆☆

3.单例 ☆☆☆

4.工厂 ☆☆☆

5.适配器 ☆☆☆

6.模板 ☆☆

7.装饰 ☆

8.Class类 ☆☆☆

9.反射 ☆☆☆

day02_java基础加强(jdk新特性 javaa设计模式反射)相关推荐

Java笔记整理五（Iterator接口,泛型,常见数据结构（栈，队列，数组，链表，红黑树，集合），jdk新特性，异常，多线程,Lambda表达式）
Java笔记整理五 1.1Iterator接口 Collection接口与Map接口主要用于存储元素,而Iterator主要用于迭代访问(即遍历)Collection中的元素,因此Iterator对象 ...
Java基础之Java8 新特性
hp实训8.19＿Java基础之Java8新特性 // 信息展示方法 ,接口中,就可以提供一种实现. 就可以使用这种功能.default void print() {System.out.printl ...
Java基础语法96-Java91011新特性
Java基础语法96-Java9&10&11新特性一.java9新特性一. JDK 和 JRE 目录结构的改变 bin 目录包含命令行开发和调试工具,如javac,jar和jav ...
java 10新_【Java基础】Java10 新特性
Java10 新特性局部变量类型推断局部变量的显示类型声明,常常被认为是不必须的. 场景一:类实例化时.在声明一个变量时,总是习惯了敲打两次变量类型,第一次用于声明变量类型,第二次用于构造器. 场 ...
【JAVA基础】java基础之-java8新特性
写在前面的话脑子是个好东西,可惜的是一直没有搞懂脑子的内存删除机制是什么,所以啊,入行多年,零零散散的文章看了无数,却总是学习了很多也忘了很多. 痛定思痛的我决定从今天开始系统的梳理下知识架构,记录 ...
ES6基础-字符串的新特性
字符串的新特性 1. es6新增遍历接口:for...of循环遍历 2. 模版字符串: 使用``号对字符串进行原格式输出可以使用trim()方法进行取消换行模版字符串潜入变量,需要将变量名写在${ ...
【JavaSE】JDK新特性(二)————接口新特性，函数式接口(Suppier,Comsumer,Predicate,Function)
文章目录 1.接口新特性 1.1 接口组成更新概述 1.2 接口中的默认方法 1.3 接口中的静态方法 1.4 接口中的私有方法 2. 函数式接口 2.1 函数式接口概述 2.2 函数式接口作为方法的 ...
前端基础之ECMAScript新特性
目录介绍发展标准 ES6(ES2015) 类(Class) 箭头函数(Arrow function) 函数参数默认值(Function parameter defaults) 模板字符串(Temp ...
夯实基础，Java8新特性Stream详细教程
1 基本特性 Java8的API中添加了一个新的特性: 流,即stream.stream是将数组或者集合的元素视为流,流在管道中流动过程中,对数据进行筛选.排序和其他操作. 1.1 流的特性 stre ...

day02_java基础加强(jdk新特性 javaa设计模式反射)

1.Tcp协议发送数据

2.客户端发送数据数据来自键盘录入

3.文件上传核心逻辑

4.枚举(1.5)

5.单例设计模式

6.工厂设计模式

7.模板设计模式

8.适配器设计模式

9. 装饰设计模式

10.Class介绍

11.反射

1.枚举：（具体见day2——4）

2.单例设计模式：（day2——5）

3.工厂设计模式：（day2——6）

4.模板设计模式：

5.适配器设计模式：

6.反射：

day02_java基础加强(jdk新特性 javaa设计模式反射)相关推荐

最新文章

热门文章

day02_java基础加强(jdk新特性 javaa设计模式 反射)

1.Tcp协议发送数据

2.客户端发送数据 数据来自键盘录入

3.文件上传核心逻辑

4.枚举(1.5)

5.单例设计模式

6.工厂设计模式

7.模板设计模式

8.适配器设计模式

9. 装饰设计模式

10.Class介绍

11.反射

1.枚举：（具体见day2——4）

2.单例设计模式：（day2——5）

3.工厂设计模式：（day2——6）

4.模板设计模式：

5.适配器设计模式：

6.反射：

day02_java基础加强(jdk新特性 javaa设计模式 反射)相关推荐

最新文章

热门文章

day02_java基础加强(jdk新特性 javaa设计模式反射)

2.客户端发送数据数据来自键盘录入

day02_java基础加强(jdk新特性 javaa设计模式反射)相关推荐